Support for FlexPRET platform

core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java

@@ -196,6 +196,38 @@ CodeBuilder generateCMakeCode(
         }
         // remove warnings for rp2040 only to make debug easier
         cMakeCode.pr("set(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} -w\")");
+        break;
+      case FLEXPRET:
+        if (System.getenv("FP_PATH") == null) {
+          messageReporter.
+              nowhere().
+              warning("No FP_PATH environment variable found");
+        }
+        if (System.getenv("FP_SDK_PATH") == null) {
+            messageReporter.
+                nowhere().
+                warning("No FP_SDK_PATH environment variable found");
+        }
+        cMakeCode.newLine();
+        cMakeCode.pr("# Include toolchain file and set project");
+        cMakeCode.pr("include($ENV{FP_SDK_PATH}/cmake/riscv-toolchain.cmake)");
+        cMakeCode.pr("Project(" + executableName + " LANGUAGES C ASM)");
+        cMakeCode.newLine();
+
+        String selectedBoard = platformOptions.board();
+        if (selectedBoard != null) {
+          cMakeCode.pr("# Board selected from target property");
+          cMakeCode.pr("set(TARGET " + selectedBoard + ")");
+          cMakeCode.newLine();
+        } // No TARGET will automatically become emulator
+
+        var selectedFlashDevice = platformOptions.port();
+        if (selectedFlashDevice != null) {
+          cMakeCode.pr("# Flash device selected from target property");
+          cMakeCode.pr("set(FP_FLASH_DEVICE " + selectedFlashDevice + ")");
+          cMakeCode.newLine();
+        } // No FP_FLASH_DEVICE will automatically become /dev/ttyUSB0
+
         break;
       default:
         cMakeCode.pr("project(" + executableName + " LANGUAGES C)");
@@ -289,6 +321,13 @@ CodeBuilder generateCMakeCode(
                 executableName,
                 Stream.concat(additionalSources.stream(), sources.stream())));
         break;
+      case FLEXPRET:
+        cMakeCode.pr(
+            setUpMainTargetFlexPRET(
+                hasMain,
+                executableName,
+                Stream.concat(additionalSources.stream(), sources.stream())));
+        break;
       default:
         cMakeCode.pr(
             setUpMainTarget.getCmakeCode(
@@ -312,6 +351,7 @@ CodeBuilder generateCMakeCode(
     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)");
+    cMakeCode.newLine();
 
     // post target definition board configurations
     switch (platformOptions.platform()) {
@@ -326,6 +366,12 @@ CodeBuilder generateCMakeCode(
         cMakeCode.pr("pico_enable_stdio_usb(${LF_MAIN_TARGET} " + (usb ? 1 : 0) + ")");
         cMakeCode.pr("pico_enable_stdio_uart(${LF_MAIN_TARGET} " + (uart ? 1 : 0) + ")");
         break;
+      case FLEXPRET:
+        cMakeCode.pr("# Include necessary commands to generate .mem, .dump, and executable files");
+        cMakeCode.pr("include($ENV{FP_SDK_PATH}/cmake/fp-app.cmake)");
+        cMakeCode.pr("fp_add_outputs(${LF_MAIN_TARGET})");
+        cMakeCode.newLine();
+        break;
     }
 
     if (targetConfig.get(AuthProperty.INSTANCE)) {
@@ -345,7 +391,8 @@ CodeBuilder generateCMakeCode(
     }
 
     if (!targetConfig.get(SingleThreadedProperty.INSTANCE)
-        && platformOptions.platform() != Platform.ZEPHYR) {
+        && platformOptions.platform() != Platform.ZEPHYR
+        && platformOptions.platform() != Platform.FLEXPRET) {
       // If threaded computation is requested, add the threads option.
       cMakeCode.pr("# Find threads and link to it");
       cMakeCode.pr("find_package(Threads REQUIRED)");
@@ -364,7 +411,7 @@ CodeBuilder generateCMakeCode(
       cMakeCode.newLine();
     } else {
       cMakeCode.pr("# Set flag to indicate a single-threaded runtime");
-      cMakeCode.pr("target_compile_definitions( ${LF_MAIN_TARGET} PUBLIC LF_SINGLE_THREADED=1)");
+      cMakeCode.pr("target_compile_definitions(${LF_MAIN_TARGET} PUBLIC LF_SINGLE_THREADED=1)");
     }
     cMakeCode.newLine();
 
@@ -398,9 +445,27 @@ CodeBuilder generateCMakeCode(
       cMakeCode.newLine();
     }
 
-    // Add the install option
-    cMakeCode.pr(installCode);
-    cMakeCode.newLine();
+    if (platformOptions.platform() == Platform.FLEXPRET) {
+      cMakeCode.pr("""
+          # FlexPRET SDK generates a script that runs the program;
+          # install it to the top-level bin
+          install(
+              FILES ${CMAKE_SOURCE_DIR}/bin/${LF_MAIN_TARGET}
+              DESTINATION ${CMAKE_INSTALL_BINDIR}
+              PERMISSIONS
+                  OWNER_EXECUTE # Need execute, the others are normal permissions
+                  OWNER_READ 
+                  OWNER_WRITE 
+                  GROUP_READ 
+                  WORLD_READ
+          )
+          """);
+      cMakeCode.newLine();
+    } else {
+      // Add the install option
+      cMakeCode.pr(installCode);
+      cMakeCode.newLine();
+    }
 
     // Add the include file
     for (String includeFile : targetConfig.getOrDefault(CmakeIncludeProperty.INSTANCE)) {
@@ -513,4 +578,38 @@ private static String setUpMainTargetRp2040(
     code.newLine();
     return code.toString();
   }
+
+  private static String setUpMainTargetFlexPRET(
+      boolean hasMain, String executableName, Stream<String> cSources) {
+    var code = new CodeBuilder();
+    code.pr("add_subdirectory(core)");
+    code.newLine();
+
+    code.pr("# Add FlexPRET's out-of-tree SDK");
+    code.pr("add_subdirectory($ENV{FP_SDK_PATH} BINARY_DIR)");
+    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();
+
+    code.pr("target_link_libraries(${LF_MAIN_TARGET} PRIVATE fp-sdk)");
+    code.newLine();
+
+    return code.toString();
+  }
 }

core/src/main/java/org/lflang/generator/c/CCompiler.java

@@ -178,7 +178,7 @@ public boolean runCCompiler(GeneratorBase generator, LFGeneratorContext context)
                     + " finished with no errors.");
       }
       var options = targetConfig.getOrDefault(PlatformProperty.INSTANCE);
-      if (options.platform() == Platform.ZEPHYR && options.flash()) {
+      if (options.platform() == Platform.ZEPHYR && options.flash().value()) {
         messageReporter.nowhere().info("Invoking flash command for Zephyr");
         LFCommand flash = buildWestFlashCommand(options);
         int flashRet = flash.run();

core/src/main/java/org/lflang/target/property/PlatformProperty.java

@@ -13,6 +13,7 @@
 import org.lflang.target.property.type.DictionaryType.DictionaryElement;
 import org.lflang.target.property.type.PlatformType;
 import org.lflang.target.property.type.PlatformType.Platform;
+
 import org.lflang.target.property.type.PrimitiveType;
 import org.lflang.target.property.type.TargetPropertyType;
 import org.lflang.target.property.type.UnionType;
@@ -32,16 +33,23 @@ private PlatformProperty() {
 
   @Override
   public PlatformOptions initialValue() {
-    return new PlatformOptions(Platform.AUTO, null, null, 9600, false, 0);
+    FlashOption flash = new FlashOption(false, false);
+    BaudRateOption baudRate = new BaudRateOption(false, 0);
+
+    return new PlatformOptions(Platform.AUTO, null, null, baudRate, flash, 0);
   }
 
   @Override
   public PlatformOptions fromAst(Element node, MessageReporter reporter) {
     var platform = Platform.AUTO;
     String board = null;
     String port = null;
-    var baudRate = 9600;
-    var flash = false;
+
+    int baudRateValue = 0; // Default value
+    boolean baudRateSet = false;
+
+    boolean flashValue = false;
+    boolean flashSet = false;
     var userThreads = 0;
     if (node.getLiteral() != null || node.getId() != null) {
       platform = new PlatformType().forName(ASTUtils.elementToSingleString(node));
@@ -55,15 +63,25 @@ public PlatformOptions fromAst(Element node, MessageReporter reporter) {
               platform =
                   new PlatformType().forName(ASTUtils.elementToSingleString(entry.getValue()));
             }
-            case BAUDRATE -> baudRate = ASTUtils.toInteger(entry.getValue());
+            case BAUDRATE -> {
+              baudRateSet = true;
+              baudRateValue = ASTUtils.toInteger(entry.getValue());
+            }
             case BOARD -> board = ASTUtils.elementToSingleString(entry.getValue());
-            case FLASH -> flash = ASTUtils.toBoolean(entry.getValue());
+            case FLASH -> {
+              flashSet = true;
+              flashValue = ASTUtils.toBoolean(entry.getValue());
+            }
             case PORT -> port = ASTUtils.elementToSingleString(entry.getValue());
             case USER_THREADS -> userThreads = ASTUtils.toInteger(entry.getValue());
           }
         }
       }
     }
+
+    FlashOption flash = new FlashOption(flashSet, flashValue);
+    BaudRateOption baudRate = new BaudRateOption(baudRateSet, baudRateValue);
+
     return new PlatformOptions(platform, board, port, baudRate, flash, userThreads);
   }
 
@@ -74,11 +92,62 @@ protected PlatformOptions fromString(String string, MessageReporter reporter) {
 
   @Override
   public void validate(TargetConfig config, MessageReporter reporter) {
+    var platform = config.get(PlatformProperty.INSTANCE).platform;
+    switch (platform) {
+      case RP2040:
+        validateRP2040(config, reporter);
+        break;
+      case FLEXPRET:
+        validateFlexPRET(config, reporter);
+        break;
+      default:
+        break;
+    }
+  }
+
+  private void validateRP2040(TargetConfig config, MessageReporter reporter) {
     var singleThreaded = config.get(SingleThreadedProperty.INSTANCE);
-    if (!singleThreaded && config.get(PlatformProperty.INSTANCE).platform == Platform.RP2040) {
+    if (!singleThreaded) {
       reporter
+        .at(config.lookup(this), Literals.KEY_VALUE_PAIR__VALUE)
+        .error("Platform " + Platform.RP2040 + " does not support threading.");
+    }
+  }
+
+  private void validateFlexPRET(TargetConfig config, MessageReporter reporter) {
+    var platform = config.get(PlatformProperty.INSTANCE);
+    var board = platform.board();
+    if (board != null) {
+      if (!board.equals("emulator") && !board.equals("fpga")) {
+        reporter
           .at(config.lookup(this), Literals.KEY_VALUE_PAIR__VALUE)
-          .error("Platform " + Platform.RP2040 + " does not support threading.");
+          .error("Only \"emulator\" and \"fpga\" are valid options for board property. Got " + board + ".");
+      }
+
+      // Do validation specific to emulator
+      if (board.equals("emulator")) {
+        if (platform.port() != null) {
+          reporter
+            .at(config.lookup(this), Literals.KEY_VALUE_PAIR__VALUE)
+            .warning("Port property ignored for emulator");
+        }
+        if (platform.flash().setByUser()) {
+          reporter
+            .at(config.lookup(this), Literals.KEY_VALUE_PAIR__VALUE)
+            .warning("Flash property ignored for emulator");
+        }
+        if (platform.baudRate().setByUser()) {
+          reporter
+            .at(config.lookup(this), Literals.KEY_VALUE_PAIR__VALUE)
+            .warning("Baudrate property ignored for emulator");
+        }
+      } else {
+        if (platform.baudRate().setByUser()) {
+          reporter
+            .at(config.lookup(this), Literals.KEY_VALUE_PAIR__VALUE)
+            .error("Baudrate property is entirely controlled by FlexPRET's SDK and cannot be set by the user");
+        }
+      }
     }
   }
 
@@ -91,9 +160,9 @@ public Element toAstElement(PlatformOptions value) {
       pair.setName(opt.toString());
       switch (opt) {
         case NAME -> pair.setValue(ASTUtils.toElement(value.platform.toString()));
-        case BAUDRATE -> pair.setValue(ASTUtils.toElement(value.baudRate));
+        case BAUDRATE -> pair.setValue(ASTUtils.toElement(value.baudRate().value()));
         case BOARD -> pair.setValue(ASTUtils.toElement(value.board));
-        case FLASH -> pair.setValue(ASTUtils.toElement(value.flash));
+        case FLASH -> pair.setValue(ASTUtils.toElement(value.flash().value()));
         case PORT -> pair.setValue(ASTUtils.toElement(value.port));
         case USER_THREADS -> pair.setValue(ASTUtils.toElement(value.userThreads));
       }
@@ -111,6 +180,34 @@ public String name() {
     return "platform";
   }
 
+  /** 
+   * The purpose of this record is to keep track of whether the flash option
+   * was set by the user or is a default value. This is useful for producing
+   * warnings or errors.
+   */
+  public record FlashOption(
+      /**
+       * Whether the user set the option
+       */
+      boolean setByUser, 
+
+      /**
+       * The value (either set by the user or a default value)
+       */
+      boolean value) {}
+
+  /** Same reasoning as FlashOption */
+  public record BaudRateOption(
+      /**
+       * Whether the user set the option
+       */
+      boolean setByUser,
+
+      /**
+       * The value (either set by the user or a default value)
+       */
+      int value) {}
+
   /** Settings related to Platform Options. */
   public record PlatformOptions(
       /**
@@ -136,17 +233,16 @@ public record PlatformOptions(
        * 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.
        */
-      int baudRate,
+      BaudRateOption baudRate,
 
       /**
        * 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.
        */
-      boolean flash,
+      FlashOption flash,
 
       /**
-       * 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.
+       * The number of threads requested by the user.
        */
       int userThreads) {
 

core/src/main/java/org/lflang/target/property/type/PlatformType.java

@@ -18,6 +18,7 @@ public enum Platform {
     LINUX("Linux", true),
     MAC("Darwin", true),
     ZEPHYR("Zephyr", true),
+    FLEXPRET("FlexPRET", true),
     WINDOWS("Windows", true);
 
     final String cMakeName;

core/src/main/java/org/lflang/util/ArduinoUtil.java

@@ -109,7 +109,7 @@ public void buildArduino(FileConfig fileConfig, TargetConfig targetConfig) {
             "SUCCESS: Compiling generated code for "
                 + fileConfig.name
                 + " finished with no errors.");
-    if (targetConfig.get(PlatformProperty.INSTANCE).flash()) {
+    if (targetConfig.get(PlatformProperty.INSTANCE).flash().value()) {
       if (targetConfig.get(PlatformProperty.INSTANCE).port() != null) {
         messageReporter.nowhere().info("Invoking flash command for Arduino");
         LFCommand flash =