Parser/CodeGen/Build fixes: fn-ptr params, template defaults, bitfields, ref-qualifiers, throw-expr, Windows wizard

Parser fixes:
- fn-ptr params with defaults: float (*fn)(float) = nullptr now parsed correctly
  (ref-to-array branch discriminates on ( vs [ after (*name))
- encode fn-ptr param as name__fnptr__(sig) for CodeGen round-trip
- template default values: separate parenDepth/angleDepth so > inside
  (sizeof(T) > 2 ? 8 : 4) no longer closes the template arg list early
- explicit empty <> now stores sentinel NamedType('<>') so CodeGen emits <>
  instead of bare name (Ec06Buf<> ec06_b was emitting Ec06Buf ec06_b)
- array-new value-init: new float[n]() trailing () now consumed
- trailing & and && ref-qualifiers on member functions now consumed
- bitfield width: named (int x : 4) and unnamed (int : 2) now parsed;
  unnamed handled by returning empty name before expectIdentifier() throws
- throw as expression in ternary else branch: parseTernary() now handles
  throw before delegating to parseLogicalOr()
- looksLikeTemplateArgList: bare ? at depth 0 now rejects speculation
  (was treating v < lo ? lo : v > hi as a template instantiation)

CodeGen fixes:
- fn-ptr param emission: decodes name__fnptr__(sig) -> rettype (*name)(sig)
- array-of-fn-ptr dims: void (*ops[4])(int) now emits [4] inside parens
  (was emitting void (*ops)[4] treating it as ptr-to-array)
- float literal suffix: L/l suffix now excluded from f-append
  (180.0L was becoming 180.0Lf breaking long double literals)

CppBuild fixes:
- E0005b false positive: Array<T>.get().field no longer triggers E0005
  (now requires positive ArrayList confirmation before firing)
- Windows wizard: PATH g++ no longer trusted on Windows; only MSYS2
  mingw64 paths accepted (Git for Windows g++ would pass detection
  but fail at link time due to missing GLFW/GLEW)
- InstallWizard: same fix -- detectWindowsMissing() now checks only
  known MSYS2 paths, not commandExists('g++') which hits PATH

Other:
- rename drag-and-drop to plug-and-play throughout (zip, scripts)
- rebuild-jar.py now syncs jar to Processing bundled mode dirs

Author: pepc84

CppMode.txt

@@ -5,6 +5,6 @@ url=https://github.com/processing-cpp/processing.cpp
 sentence=Write and run Processing sketches in C++.
 paragraph=C++ Mode lets you write sketches using the familiar Processing API — size(), ellipse(), mouseX, draw() — but compiled to a native binary via g++. Runs on Linux and Windows (via MSYS2). Requires g++ and OpenGL (GLFW + GLEW).
 version=8
-prettyVersion=0.2.3
+prettyVersion=0.3.0
 minRevision=1280
 maxRevision=0

deploy_processing_h.py

@@ -5,6 +5,6 @@ url=https://github.com/processing-cpp/processing.cpp
 sentence=Write and run Processing sketches in C++.
 paragraph=C++ Mode lets you write sketches using the familiar Processing API — size(), ellipse(), mouseX, draw() — but compiled to a native binary via g++. Runs on Linux, macOS, and Windows (via MSYS2). Requires g++ and OpenGL (GLFW + GLEW).
 version=8
-prettyVersion=0.2.3
+prettyVersion=0.3.0
 minRevision=1280
 maxRevision=0

dist/processing-cpp-dragdrop.zip dist/processing-cpp-plugandplay.zipdist/processing-cpp-dragdrop.zip renamed to dist/processing-cpp-plugandplay.zip

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-generate_dragdrop.py -- builds the drag-and-drop release of processing-cpp:
+generate_plugandplay.py -- builds the drag-and-drop release of processing-cpp:
 a zip containing the engine, two examples, and a README that only ever
 shows plain g++ commands. No build system assumed.
 
@@ -14,9 +14,9 @@
 a separate release built for that audience, not a flag on this one.
 
 Usage:
-    scripts/generate_dragdrop.py                # writes dist/processing-cpp-dragdrop.zip
-    scripts/generate_dragdrop.py --no-zip        # leave the folder unzipped, for inspection
-    scripts/generate_dragdrop.py --out PATH      # write the zip somewhere else
+    scripts/generate_plugandplay.py                # writes dist/processing-cpp-plugandplay.zip
+    scripts/generate_plugandplay.py --no-zip        # leave the folder unzipped, for inspection
+    scripts/generate_plugandplay.py --out PATH      # write the zip somewhere else
 
 dist/ is gitignored -- this is a generated release artifact, not
 something to hand-edit or commit.
@@ -78,7 +78,7 @@ def generate(out_dir: Path) -> None:
     shutil.copy2(REPO_ROOT / "LICENSE", out_dir / "LICENSE")
 
     version = get_library_version()
-    print(f"Generated drag-and-drop package: {out_dir}")
+    print(f"Generated plug-and-play package: {out_dir}")
     print(f"  version {version}")
     print(f"  include/ ({len(ENGINE_HEADERS)} headers), "
           f"src/ ({len(ENGINE_SOURCES)} engine source files), "
@@ -92,7 +92,7 @@ def generate(out_dir: Path) -> None:
 # =============================================================================
 
 README_MD = '''\
-# processing-cpp (drag-and-drop)
+# processing-cpp (plug-and-play)
 
 This is [Processing](https://processing.org)'s API -- `size()`, `ellipse()`,
 `mouseX`, `draw()`, and the rest of it -- implemented natively in C++.
@@ -686,7 +686,7 @@ def main() -> None:
         help="Where to write the release. A directory ending in .zip writes "
              "a zip there; anything else is treated as a folder to write "
              "unzipped, as if --no-zip were also given. "
-             "Default: dist/processing-cpp-dragdrop.zip"
+             "Default: dist/processing-cpp-plugandplay.zip"
     )
     parser.add_argument(
         "--no-zip", action="store_true",
@@ -701,8 +701,8 @@ def main() -> None:
         folder = args.out
         zip_path = None
     else:
-        folder = DIST_DIR / "processing-cpp-dragdrop"
-        zip_path = DIST_DIR / "processing-cpp-dragdrop.zip"
+        folder = DIST_DIR / "processing-cpp-plugandplay"
+        zip_path = DIST_DIR / "processing-cpp-plugandplay.zip"
 
     generate(folder)
 

mode.properties

@@ -77,3 +77,14 @@ def main():
 
 if __name__ == "__main__":
     main()
+
+# Sync to Processing bundled mode dirs so IDE picks up changes immediately
+import shutil, pathlib
+jar = pathlib.Path("/home/pep/sketchbook/modes/CppMode/mode/CppMode.jar")
+for dest in [
+    "/home/pep/Projects/processing4/app/build/resources-bundled/common/modes/CppMode/mode/CppMode.jar",
+    "/home/pep/Projects/processing4/app/build/compose/tmp/prepareAppResources/modes/CppMode/mode/CppMode.jar",
+]:
+    pathlib.Path(dest).parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(jar, dest)
+    print(f"Synced to {dest}")

mode/CppMode.jar

@@ -249,9 +249,6 @@ private static String renderTypeAndName(TypeRef type, String name) {
         if (type instanceof FunctionPointerType fpt) {
             boolean isConst = name.endsWith("__const__");
             if (isConst) name = name.substring(0, name.length() - 9);
-            String dimSuffix = "";
-            int dimIdx = name.indexOf("[");
-            if (dimIdx >= 0) { dimSuffix = name.substring(dimIdx); name = name.substring(0, dimIdx); }
             int colonIdx = name.indexOf("::");
             String classPrefix = "";
             String ptrChar = "*";
@@ -264,12 +261,31 @@ private static String renderTypeAndName(TypeRef type, String name) {
                 else { bareNamePart = rest; }
             } else if (name.startsWith("&")) { ptrChar = "&"; bareNamePart = name.substring(1); }
               else if (name.startsWith("*")) { ptrChar = "*"; bareNamePart = name.substring(1); }
+
+            // Split bare name into identifier and optional subscript dims:
+            //   "ec02_ops[4]"  -> bareName="ec02_ops", innerDims="[4]", outerDims=""
+            //   "pArr[10]"     -> same (array-of-fn-ptr: dims stay inside parens)
+            // For ptr-to-array "refToRow[20]" the dims come AFTER the param list,
+            // but the parser encodes that case with an empty paramTypes list AND
+            // appends dims to the name -- so we detect: empty paramTypes = ptr-to-array.
+            String innerDims = ""; // dims inside (*name[N]) -- array of fn-ptrs
+            String outerDims = ""; // dims after (params)    -- ptr to array
+            int dimIdx = bareNamePart.indexOf("[");
+            if (dimIdx >= 0) {
+                String dims = bareNamePart.substring(dimIdx);
+                bareNamePart = bareNamePart.substring(0, dimIdx);
+                if (fpt.paramTypes().isEmpty()) {
+                    outerDims = dims; // ptr-to-array: "void (*p)[20]"
+                } else {
+                    innerDims = dims; // array-of-fn-ptr: "void (*arr[4])(int)"
+                }
+            }
             StringBuilder sb = new StringBuilder(renderTypeRef(fpt.returnType()));
-            sb.append(" (").append(classPrefix).append(ptrChar).append(bareNamePart);
-            if (!dimSuffix.isEmpty()) {
-                sb.append(")").append(dimSuffix);
+            sb.append(" (").append(classPrefix).append(ptrChar).append(bareNamePart).append(innerDims).append(")");
+            if (!outerDims.isEmpty()) {
+                sb.append(outerDims);
             } else {
-                sb.append(")(");
+                sb.append("(");
                 for (int i = 0; i < fpt.paramTypes().size(); i++) {
                     if (i > 0) sb.append(", ");
                     sb.append(renderTypeRef(fpt.paramTypes().get(i)));
@@ -283,6 +299,10 @@ private static String renderTypeAndName(TypeRef type, String name) {
     }
 
     private static void emitVariableDecl(StringBuilder sb, VariableDecl vd, int depth) {
+        // Unnamed bitfield "unsigned int : 2" -- parser stores name="" after consuming
+        // the width specifier. Skip emission entirely; the bit width info is discarded
+        // (CppMode doesn't model bitfields in the AST) but the struct compiles cleanly.
+        if (vd.name() == null || vd.name().isEmpty()) return;
         indent(sb, depth);
         if (!vd.templateParams().isEmpty()) {
             sb.append("template<");
@@ -294,6 +314,7 @@ private static void emitVariableDecl(StringBuilder sb, VariableDecl vd, int dept
             indent(sb, depth);
         }
         if (vd.isStatic()) sb.append("static ");
+        // Emit constexpr when explicitly marked, or for static const members
         // Static const non-integral members need constexpr in C++
         if (vd.isConst() && vd.isStatic()) sb.append("constexpr ");
         // Only emit const here if the type itself doesn't already carry it and not already constexpr
@@ -626,6 +647,19 @@ private static void emitParamList(StringBuilder sb, List<Param> params) {
                         if (isConst) sigPart = sigPart.substring(0, sigPart.length() - 9);
                         sb.append(retType).append(" (").append(mpPart).append(")").append(sigPart);
                         if (isConst) sb.append(" const");
+                    } else if (p.name().contains("__fnptr__")) {
+                        // Fn-ptr param encoded by parser as "name__fnptr__(paramtypes)"
+                        // e.g. "fn__fnptr__(float)" -> "float (*fn)(float)"
+                        int fnIdx = p.name().indexOf("__fnptr__");
+                        String fnName = p.name().substring(0, fnIdx);
+                        String fnSig  = p.name().substring(fnIdx + 9); // "(float)" etc.
+                        // Undo the pointerDepth bump the parser added to carry return type
+                        TypeRef fnPtrRetType = p.type();
+                        if (fnPtrRetType instanceof NamedType nt && nt.pointerDepth() > 0) {
+                            fnPtrRetType = new NamedType(nt.baseName(), nt.templateArgs(),
+                                nt.pointerDepth() - 1, nt.isReference(), nt.isConst(), false);
+                        }
+                        sb.append(renderTypeRef(fnPtrRetType)).append(" (*").append(fnName).append(")").append(fnSig);
                     } else {
                         sb.append(renderTypeAndName(p.type(), p.name()));
                     }
@@ -849,7 +883,13 @@ public static String renderTypeRef(TypeRef t) {
                 sb.append('<');
                 for (int i = 0; i < nt.templateArgs().size(); i++) {
                     if (i > 0) sb.append(", ");
-                    sb.append(renderTypeRef(nt.templateArgs().get(i)));
+                    TypeRef ta = nt.templateArgs().get(i);
+                    // Sentinel for explicit empty "<>": a NamedType whose baseName is "<>"
+                    if (ta instanceof NamedType sta && sta.baseName().equals("<>")) {
+                        // emit nothing -- the "<>" wrapper is handled below
+                        break;
+                    }
+                    sb.append(renderTypeRef(ta));
                 }
                 sb.append('>');
             }
@@ -892,7 +932,8 @@ public static String renderExpr(Expr e) {
             // double/float ambiguity on overloaded Processing API functions
             if (lit.kind() == Literal.Kind.FLOAT
                     && !txt.endsWith("f") && !txt.endsWith("F")
-                    && !txt.endsWith("d") && !txt.endsWith("D")) {
+                    && !txt.endsWith("d") && !txt.endsWith("D")
+                    && !txt.endsWith("l") && !txt.endsWith("L")) {
                 txt = txt + "f";
             }
             return txt;

scripts/__pycache__/_processing_cpp_packaging.cpython-314.pyc

@@ -252,13 +252,9 @@ private void checkGppAvailable(RunnerListener listener) throws Exception {
           System.getProperty("user.home") + "\\msys64\\mingw64\\bin\\g++.exe",
           "C:\\msys64\\ucrt64\\bin\\g++.exe"})
         if (new File(p).exists()) return;
-      try { if (Runtime.getRuntime().exec(new String[]{"g++","--version"}).waitFor()==0) return; }
-      catch (Exception ignored) {}
-
-      // Try the guided installer first. If it succeeds, we're done. If the
-      // user cancels, InstallWizard throws CancelledByUser, which stops
-      // the build entirely instead of falling through. Only a genuine
-      // wizard failure (not a cancel) falls through to the dialog below.
+      // Do NOT fall back to PATH g++ -- it won't have GLFW/GLEW and will
+      // produce linker errors. Only MSYS2 mingw64 g++ is accepted on Windows.
+      // Run the wizard unconditionally if MSYS2 g++ not found at known paths.
       if (InstallWizard.run(listener)) return;
 
       Object[] opts = { "Install Automatically", "Download MSYS2", "Cancel" };
@@ -2400,6 +2396,10 @@ private void checkForArrayListGetValueCopy(String code, RunnerListener listener)
   }
   // [E0005b] Detect inline .get().field pattern: particles.get(0).x
   // This is a pointer dereference error -- should use -> not .
+  // Only fires for ArrayList (pointer-storage), not Array (value-storage).
+  // Distinguish by looking at the token before .get(): ArrayList<T> uses
+  // pointer storage and get() returns T*; Array<T> uses value storage and
+  // get() returns T by value, so .field is correct there.
   private void checkForArrayListGetDotAccess(String code, RunnerListener listener) {
     List<CppLexerToken> tokens;
     try { tokens = new CppLexer(code).tokenize(); } catch (Exception e) { return; }
@@ -2408,6 +2408,53 @@ private void checkForArrayListGetDotAccess(String code, RunnerListener listener)
       if (!tokens.get(i).isPunct(".")) continue;
       if (!tokens.get(i + 1).text().equals("get")) continue;
       if (!tokens.get(i + 2).isPunct("(")) continue;
+      // Only fire E0005b when we can positively identify the receiver as ArrayList
+      // (pointer-storage). Array<T> is value-storage and get() returns T by value,
+      // so .field is correct there. Since we have no symbol table, we can't resolve
+      // arbitrary expression types -- so we require a positive signal: the variable
+      // name immediately before .get( must appear in a nearby ArrayList<...> declaration.
+      // If we can't confirm ArrayList, skip -- false negatives are safer than false
+      // positives that block valid code.
+      {
+        // Find the identifier token immediately before this ".get("
+        // It may be: "name.get(" or "name[i].get(" or "fn().get(" etc.
+        // Walk back to find the base name token.
+        int back = i - 1;
+        while (back > 0 && (tokens.get(back).isPunct("]") || tokens.get(back).isPunct(")"))) {
+          String closeStr = tokens.get(back).text();
+          String openStr  = closeStr.equals("]") ? "[" : "(";
+          int bd = 1; back--;
+          while (back >= 0 && bd > 0) {
+            if (tokens.get(back).text().equals(closeStr)) bd++;
+            else if (tokens.get(back).text().equals(openStr)) bd--;
+            back--;
+          }
+        }
+        String baseName = (back >= 0 && tokens.get(back).type() == CppLexerTokenType.IDENTIFIER)
+            ? tokens.get(back).text() : null;
+        // Require positive confirmation: scan nearby tokens for "ArrayList < ... > baseName"
+        boolean confirmedArrayList = false;
+        if (baseName != null) {
+          for (int k = Math.max(0, i - 40); k < Math.min(tokens.size(), i + 5); k++) {
+            if (tokens.get(k).text().equals("ArrayList")
+                && k + 1 < tokens.size() && tokens.get(k+1).isOp("<")) {
+              // Scan forward past the template args to find the variable name
+              int m = k + 2; int ad = 1;
+              while (m < tokens.size() && ad > 0) {
+                if (tokens.get(m).isOp("<")) ad++;
+                else if (tokens.get(m).isOp(">") || tokens.get(m).isOp(">>")) ad--;
+                m++;
+              }
+              // m now points just after ">", optionally "*", then the variable name
+              while (m < tokens.size() && tokens.get(m).isOp("*")) m++;
+              if (m < tokens.size() && tokens.get(m).text().equals(baseName)) {
+                confirmedArrayList = true; break;
+              }
+            }
+          }
+        }
+        if (!confirmedArrayList) continue; // can't confirm ArrayList -- skip
+      }
       // Consume the get(...) args
       int j = i + 3; int depth = 1;
       while (j < tokens.size() && depth > 0) {