Merge pull request #609 from processing/preproc_fix_space_equation

java/src/processing/mode/java/preproc/PdeParseTreeListener.java

@@ -589,9 +589,9 @@ public void exitMethodDeclaration(ProcessingParser.MethodDeclarationContext ctx)
     // Insert at start of method or after annoation
     if (!hasVisibilityModifier) {
       if (annoationPoint == null) {
-        insertBefore(possibleModifiers.getStart(), " public ");
+        insertBefore(possibleModifiers.getStart(), "public ");
       } else {
-        insertAfter(annoationPoint.getStop(), " public ");
+        insertAfter(annoationPoint.getStop(), "public ");
       }
     }
 
@@ -693,17 +693,17 @@ protected void handleSizeCall(ParserRuleContext ctx) {
     if (isSize && argsContext.getChildCount() > 2) {
       thisRequiresRewrite = true;
 
-      sketchWidth = argsContext.getChild(0).getText();
-      boolean invalidWidth = PApplet.parseInt(sketchWidth, -1) == -1;
-      invalidWidth = invalidWidth && !sketchWidth.equals("displayWidth");
-      if (invalidWidth) {
+      boolean widthValid = sizeParamValid(argsContext.getChild(0));
+      if (widthValid) {
+        sketchWidth = argsContext.getChild(0).getText();
+      } else {
         thisRequiresRewrite = false;
       }
 
-      sketchHeight = argsContext.getChild(2).getText();
-      boolean invalidHeight = PApplet.parseInt(sketchHeight, -1) == -1;
-      invalidHeight = invalidHeight && !sketchHeight.equals("displayHeight");
-      if (invalidHeight) {
+      boolean validHeight = sizeParamValid(argsContext.getChild(2));
+      if (validHeight) {
+        sketchHeight = argsContext.getChild(2).getText();
+      } else {
         thisRequiresRewrite = false;
       }
 
@@ -1535,4 +1535,36 @@ private ImportStatement createPlainImportStatementInfo(String fullyQualifiedName
     return ImportStatement.parse(fullyQualifiedName);
   }
 
+  private boolean isMethodCall(ParseTree ctx) {
+    return ctx instanceof ProcessingParser.MethodCallContext;
+  }
+
+  private boolean isVariable(ParseTree ctx) {
+    boolean isPrimary = ctx instanceof ProcessingParser.PrimaryContext;
+    if (!isPrimary) {
+      return false;
+    }
+
+    String text = ctx.getText();
+    boolean startsWithAlpha = text.length() > 0 && Character.isAlphabetic(text.charAt(0));
+    return startsWithAlpha;
+  }
+
+  private boolean sizeParamValid(ParseTree ctx) {
+    // Method calls and variables not allowed.
+    if (isMethodCall(ctx) || isVariable(ctx)) {
+      return false;
+    }
+
+    // If user passed an expression, check subexpressions.
+    for (int i = 0; i < ctx.getChildCount(); i++) {
+      if (!sizeParamValid(ctx.getChild(i))) {
+        return false;
+      }
+    }
+
+    // If all sub-expressions passed and not identifier, is valid.
+    return true;
+  }
+
 }

java/test/processing/mode/java/ParserTests.java

@@ -50,6 +50,22 @@ static void expectRecognitionException(final String id,
     }
   }
 
+  static void expectRunnerException(final String id) {
+    try {
+      preprocess(id, res(id + ".pde"));
+      fail("Expected to fail");
+    } catch (SketchException e) {
+      assertNotNull(e);
+    } catch (PdePreprocessIssueException e) {
+      assertNotNull(e.getIssue().getMsg());
+    } catch (Exception e) {
+      if (!e.equals(e.getCause()) && e.getCause() != null)
+        fail(e.getCause().toString());
+      else
+        fail(e.toString());
+    }
+  }
+
   static void expectRunnerException(final String id,
                                     final int expectedLine) {
 
@@ -453,4 +469,24 @@ public void testCustomRootClass() {
     expectGood("customrootclass");
   }
 
+  @Test
+  public void testExpessionSize() {
+    expectGood("expressionsize");
+  }
+
+  @Test
+  public void testExpessionSizeMethod() {
+    expectGood("expressionsizemethod");
+  }
+
+  @Test
+  public void testExpessionSizeVar() {
+    expectGood("expressionsizevar");
+  }
+
+  @Test
+  public void testWhitespace() {
+    expectGood("whitespace", false);
+  }
+
 }

java/test/resources/expressionsize.expected

@@ -0,0 +1,45 @@
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import processing.pdf.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class expressionsize extends PApplet {
+
+
+
+ public void setup() {
+  /* size commented out by preprocessor */;
+}
+
+ public void draw() {
+  // Draw something good here
+  line(0, 0, width/2, height);
+
+  // Exit the program
+  println("Finished.");
+  exit();
+}
+
+
+    public void settings() { size(400*2,4e2/2); }
+
+    static public void main(String[] passedArgs) {
+        String[] appletArgs = new String[] { "expressionsize" };
+        if (passedArgs != null) {
+            PApplet.main(concat(appletArgs, passedArgs));
+        } else {
+            PApplet.main(appletArgs);
+        }
+    }
+}

java/test/resources/expressionsize.pde

@@ -0,0 +1,14 @@
+import processing.pdf.*;
+
+void setup() {
+  size(400*2, 4e2/2);
+}
+
+void draw() {
+  // Draw something good here
+  line(0, 0, width/2, height);
+
+  // Exit the program
+  println("Finished.");
+  exit();
+}

java/test/resources/expressionsizemethod.expected

@@ -0,0 +1,44 @@
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import processing.pdf.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class expressionsizemethod extends PApplet {
+
+public int getWidth() {
+  return 400*2;
+}
+
+public void setup() {
+  size(getWidth(), 400/2);
+}
+
+ public void draw() {
+  // Draw something good here
+  line(0, 0, width/2, height);
+
+  // Exit the program
+  println("Finished.");
+  exit();
+}
+
+    static public void main(String[] passedArgs) {
+        String[] appletArgs = new String[] { "expressionsizemethod" };
+        if (passedArgs != null) {
+            PApplet.main(concat(appletArgs, passedArgs));
+        } else {
+            PApplet.main(appletArgs);
+        }
+    }
+}

java/test/resources/expressionsizemethod.pde

@@ -0,0 +1,18 @@
+import processing.pdf.*;
+
+int getWidth() {
+  return 400*2;
+}
+
+void setup() {
+  size(getWidth(), 400/2);
+}
+
+void draw() {
+  // Draw something good here
+  line(0, 0, width/2, height);
+
+  // Exit the program
+  println("Finished.");
+  exit();
+}

java/test/resources/expressionsizevar.expected

@@ -0,0 +1,43 @@
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import processing.pdf.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class expressionsizevar extends PApplet {
+
+
+
+public void setup() {
+  int newWidth = 400*2;
+  size(newWidth, 400/2);
+}
+
+ public void draw() {
+  // Draw something good here
+  line(0, 0, width/2, height);
+
+  // Exit the program
+  println("Finished.");
+  exit();
+}
+
+    static public void main(String[] passedArgs) {
+        String[] appletArgs = new String[] { "expressionsizevar" };
+        if (passedArgs != null) {
+            PApplet.main(concat(appletArgs, passedArgs));
+        } else {
+            PApplet.main(appletArgs);
+        }
+    }
+}

java/test/resources/expressionsizevar.pde

@@ -0,0 +1,15 @@
+import processing.pdf.*;
+
+void setup() {
+  int newWidth = 400*2;
+  size(newWidth, 400/2);
+}
+
+void draw() {
+  // Draw something good here
+  line(0, 0, width/2, height);
+
+  // Exit the program
+  println("Finished.");
+  exit();
+}

java/test/resources/whitespace.expected

@@ -0,0 +1,54 @@
+import processing.core.*;
+import processing.data.*;
+import processing.event.*;
+import processing.opengl.*;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class whitespace extends PApplet {
+
+public void setup() {
+    /* size commented out by preprocessor */; 
+    stroke(255);
+    noFill();
+}
+
+public void drawBezier(int i) {
+    bezier(
+        mouseX - (i/2.0f),
+        40+i,
+        410,
+        20,
+        440,
+        300,
+        240 - (i/16.0f),
+        300 + (i/8.0f)
+    );
+}
+
+public void draw() {
+    background(0);
+    for (int i = 0; i < 200; i += 20) {
+        drawBezier(i);
+    }
+}
+
+
+    public void settings() { size(640, 360); }
+
+    static public void main(String[] passedArgs) {
+        String[] appletArgs = new String[] { "whitespace" };
+        if (passedArgs != null) {
+            PApplet.main(concat(appletArgs, passedArgs));
+        } else {
+            PApplet.main(appletArgs);
+        }
+    }
+}

java/test/resources/whitespace.pde

@@ -0,0 +1,25 @@
+void setup() {
+    size(640, 360); 
+    stroke(255);
+    noFill();
+}
+
+void drawBezier(int i) {
+    bezier(
+        mouseX - (i/2.0),
+        40+i,
+        410,
+        20,
+        440,
+        300,
+        240 - (i/16.0),
+        300 + (i/8.0)
+    );
+}
+
+void draw() {
+    background(0);
+    for (int i = 0; i < 200; i += 20) {
+        drawBezier(i);
+    }
+}