renderSVG :: ICanvasContext -> <Proc> String
+ "Render an SVG with known width and height in pixels: `renderScaledSVG context width height`"
+ @JavaName renderSVG
+ renderScaledSVG :: ICanvasContext -> Double -> Double -> <Proc> String
+
getSceneGraphProvider :: Diagram -> <Proc> ICanvasSceneGraphProvider
getSceneGraphProvider diagram = do
diagramName = syncRead(\() -> getSafeName diagram)
}
- public static Element renderSVGNode(IG2DNode node) {
-
- // Get a DOMImplementation.
- DOMImplementation domImpl = GenericDOMImplementation.getDOMImplementation();
-
- // Create an instance of org.w3c.dom.Document.
- String svgNS = "http://www.w3.org/2000/svg";
- Document document = domImpl.createDocument(svgNS, "svg", null);
-
- SVGGeneratorContext ctx = SVGGeneratorContext.createDefault(document);
- ctx.setComment(null);
-
- // Create an instance of the SVG Generator.
- SVGGraphics2D svgGenerator = new Generator(ctx, false);
+ public static Element renderSVGNode(SVGGraphics2D svgGenerator, IG2DNode node) {
try {
}
public static String renderSVG3(ICanvasContext ctx) {
- return renderSVG0(ctx, p0 -> p0.stream().collect(Collectors.toMap(p1 -> p1, p2 -> p2)));
+ return renderSVG3(ctx, -1, -1);
+ }
+
+ public static String renderSVG3(ICanvasContext ctx, double width, double height) {
+ return renderSVG0(width, height, ctx, p0 -> p0.stream().collect(Collectors.toMap(p1 -> p1, p2 -> p2)));
}
/**
* Default no-op mapper
*/
private static final Function1<Set<?>, Map<?, ?>> mapper = p0 -> p0.stream().collect(Collectors.toMap(p1 -> p1, p2 -> p2));
-
+
+ public static String renderSVG(ICanvasContext ctx, double width, double height) {
+ return renderSVG0(width, height, ctx, mapper);
+ }
+
public static String renderSVG(ICanvasContext ctx) {
- return renderSVG0(ctx, mapper);
+ return renderSVG(ctx, -1, -1);
}
+ public static String renderSVGMapIdentifiers(ICanvasContext ctx) {
+ return renderSVGMapIdentifiers(ctx, -1, -1);
+ }
+
/**
* Renders ICanvasContext into SVG by mapping the SVG id's into URI based
* GUID's
* @param ctx
* @return
*/
- public static String renderSVGMapIdentifiers(ICanvasContext ctx) {
- return renderSVG0(ctx, new Function1<Set<?>, Map<?, ?>>() {
+ public static String renderSVGMapIdentifiers(ICanvasContext ctx, double width, double height) {
+ return renderSVG0(width, height, ctx, new Function1<Set<?>, Map<?, ?>>() {
@Override
public Map<?, ?> apply(Set<?> p0) {
}
- private static String renderSVG0(ICanvasContext ctx, Function1<Set<?>, Map<?, ?>> mappingFunction) {
+ private static String renderSVG0(double width, double height, ICanvasContext ctx, Function1<Set<?>, Map<?, ?>> mappingFunction) {
// Get a DOMImplementation.
DOMImplementation domImpl = GenericDOMImplementation.getDOMImplementation();
RTreeNode rtree = NodeUtil.getNearestChildByClass(root, RTreeNode.class);
Rectangle2D rtreeBounds = NodeUtil.getLocalBounds(rtree);
- // nav is a node that has zooming functionalities
- NavigationNode nav = NodeUtil.getNearestChildByClass(root, NavigationNode.class);
- nav.setZoomEnabled(true);
-
- // fit view with the contents of rtreeBounds
- nav.zoomTo(rtreeBounds);
-
// get the bounds of the content
- Rectangle2D content = NodeUtil.getLocalBounds(nav);
-
- svgGenerator.scale(3,3);
-
+ Rectangle2D content = rtreeBounds;
+
+ // To account for dynamic padding of selection rectangles (5 units + stroke width)
+ int offset = 6;
+
+ double scale = width < 0 || height < 0 ? 1.0 : Math.min((width - 2*offset) / content.getWidth(), (height - 2*offset) / content.getHeight());
+
+ svgGenerator.translate(offset, offset);
+ svgGenerator.scale(scale, scale);
// translate svgGenerator to the x and y coordinates of current content
- svgGenerator.translate(-1 * content.getX(), (-1 * content.getY()));
-
- Rectangle2D destination = new Rectangle2D.Double(0,0,1000,1000);
- double sx = destination.getWidth() / content.getWidth();
- double sy = destination.getHeight() / content.getHeight();
- double scale = sx < sy ? sx : sy;
+ svgGenerator.translate(-content.getX(), -content.getY());
- // Set svgCanvasSize to the given size parameters
- svgGenerator.setSVGCanvasSize(new Dimension((int)(scale * content.getWidth()), (int)(scale * content.getHeight())));
- svgGenerator.setClip(content);
-
- double trX = -1 * content.getX();
- double trY = -1 * content.getY();
-
- // NaNs
- if(!Double.isFinite(trX)) trX = 0;
- if(!Double.isFinite(trY)) trY = 0;
+ svgGenerator.setSVGCanvasSize(new Dimension((int)Math.ceil(scale * content.getWidth()) + 2*offset, (int)Math.ceil(scale * content.getHeight()) + 2*offset));
+ //svgGenerator.setClip(content);
result.append(MAIN_SECTION, "<g class=\"symbols\">");
result.append(SELECTION_SECTION, "<g class=\"selections\">");
result.append(SELECTION_MASK_SECTION, "<g class=\"selectionMasks\">");
- result.append(ALL_SECTIONS, "<g transform=\"translate(");
- result.append(ALL_SECTIONS, "" + trX);
- result.append(ALL_SECTIONS, ", ");
- result.append(ALL_SECTIONS, "" + trY);
- result.append(ALL_SECTIONS, ")\">");
-
-
KeyVisitor keyVisitor = new KeyVisitor();
sg.accept(keyVisitor);
Map<?, ?> mappings = mappingFunction.apply(keys);
- IG2DNodeVisitor visitor = new PrintingVisitor(result, mappings);
+ IG2DNodeVisitor visitor = new PrintingVisitor(svgGenerator, result, mappings);
sg.accept(visitor);
}
- result.append(ALL_SECTIONS, "</g></g>");
+ result.append(ALL_SECTIONS, "</g>");
StringBuilder res = new StringBuilder();
res.append("<svg width=\"100%\" height=\"100%\" stroke=\"black\">");
HashMap<SingleElementNode,RenderSVGContext> senBuilders = new HashMap<>();
private RenderSVGContext result;
+ private SVGGraphics2D svgGenerator;
private Map<?, ?> mappings;
- public PrintingVisitor(RenderSVGContext result, Map<?, ?> mappings) {
+ public PrintingVisitor(SVGGraphics2D svgGenerator, RenderSVGContext result, Map<?, ?> mappings) {
this.result = result;
this.mappings = mappings;
+ this.svgGenerator = svgGenerator;
}
private String getKey(SingleElementNode node) {
parentBuilder.append(SELECTION_SECTION, "\n<g style=\"visibility:hidden\" class=\"selection\" id=\"" + key + "\">");
parentBuilder.append(SELECTION_MASK_SECTION, "\n<g class=\"selectionMask\" opacity=\"0.001\" id=\"" + key + "\">");
- Element doc = renderSVGNode((IG2DNode)node);
+ Element doc = renderSVGNode(svgGenerator, (IG2DNode)node);
String svg = printSVGDocument(doc);
parentBuilder.append(MAIN_SECTION, svg);
n.setIgnoreSelection(false);
}
- doc = renderSVGNode((IG2DNode)node);
+ doc = renderSVGNode(svgGenerator, (IG2DNode)node);
svg = printSVGDocument(doc);
parentBuilder.append(SELECTION_SECTION, svg);
n.setDynamicStroke(bs);
}
- doc = renderSVGNode((IG2DNode)node);
+ doc = renderSVGNode(svgGenerator, (IG2DNode)node);
svg = printSVGDocument(doc);
parentBuilder.append(SELECTION_MASK_SECTION, svg);
String key = getKey(parentSEN);
n.setIgnore(false);
- Element doc = renderSVGNode((IG2DNode)node);
+ Element doc = renderSVGNode(svgGenerator, (IG2DNode)node);
n.setIgnore(true);
String svg = printSVGDocument(doc);
parentBuilder2.append(SELECTION_SECTION, "\n<g style=\"visibility:hidden\" class=\"selection\" id=\"" + key + "\">");
parentBuilder2.append(SELECTION_SECTION, svg);
parentBuilder2.append(SELECTION_SECTION, "\n</g>");
- parentBuilder2.append(SELECTION_MASK_SECTION, "\n<g class=\"selectionMask\" id=\"" + key + "\">");
+ AffineTransform transform = svgGenerator.getTransform();
+ double[] matrix = new double[6];
+ transform.getMatrix(matrix);
+ String matrixString = String.format("matrix(%f,%f,%f,%f,%f,%f)", matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
+ parentBuilder2.append(SELECTION_MASK_SECTION, "\n<g class=\"selectionMask\" id=\"" + key + "\" transform=\"" + matrixString + "\">");
Rectangle2D rect = n.getRect();
// NaN
if(rect.getHeight() == rect.getHeight() && rect.getWidth() == rect.getWidth()) {
RenderSVGContext b = senBuilders.get(sen);
String content = b.get(MAIN_SECTION);
if(content.isEmpty()) {
- for(SelectionNode n : NodeUtil.collectNodes(node, SelectionNode.class)) {
- n.setIgnore(true);
+ if(sen.getKey() != null) {
+
+ for(SelectionNode n : NodeUtil.collectNodes(node, SelectionNode.class)) {
+ n.setIgnore(true);
+ }
+
+ Element doc = renderSVGNode(svgGenerator, (IG2DNode)node);
+ String svg = printSVGDocument(doc);
+ parentBuilder.append(MAIN_SECTION, svg);
}
- Element doc = renderSVGNode((IG2DNode)node);
- String svg = printSVGDocument(doc);
- parentBuilder.append(MAIN_SECTION, svg);
} else {
parentBuilder.append(b);
}
org.simantics.scl.compiler.markdown.nodes,
org.simantics.scl.compiler.module,
org.simantics.scl.compiler.module.coverage,
+ org.simantics.scl.compiler.module.debug,
org.simantics.scl.compiler.module.options,
org.simantics.scl.compiler.module.repository,
org.simantics.scl.compiler.runtime,
--- /dev/null
+module {
+ features = [edo],
+ export = [whoCalls, unusedDefinitions]
+}
+
+import "SCL/Reflection"
+
+@JavaType "org.simantics.scl.compiler.module.debug.SymbolReference"
+data SymbolReference =
+ @JavaType "org.simantics.scl.compiler.module.debug.SymbolReference"
+ @FieldNames [referred, referrer, referenceLocation]
+ SymbolReference {referred :: Name, referrer :: String, referenceLocation :: Location}
+
+importJava "org.simantics.scl.compiler.module.debug.ModuleDebugInfo" where
+ data ModuleDebugInfo
+
+ symbolReferences :: ModuleDebugInfo -> [SymbolReference]
+
+importJava "org.simantics.scl.compiler.module.Module" where
+ @JavaName "getModuleDebugInfo"
+
+ debugInfo :: Module -> Maybe ModuleDebugInfo
+
+whoCalls :: String -> String -> <Proc> [(String, String, Long)]
+whoCalls moduleName valueName =
+ [ (callerModuleName, referrer, referenceLocation)
+ | callerModuleName <- sclModuleNames
+ , Just callerModule = moduleByName callerModuleName
+ , Just debugInfo = debugInfo callerModule
+ , SymbolReference {referred, referrer, referenceLocation} <- symbolReferences debugInfo
+ , referred == name
+ ]
+ where
+ name = createName moduleName valueName
+
+unusedDefinitions :: <Proc> [Name]
+unusedDefinitions =
+ [ createName moduleName def
+ | moduleName <- sclModuleNames
+ , Just module = moduleByName moduleName
+ , def <- valueNamesOf module
+ ]
+ \\
+ [ referred
+ | callerModuleName <- sclModuleNames
+ , Just callerModule = moduleByName callerModuleName
+ , Just debugInfo = debugInfo callerModule
+ , SymbolReference {referred} <- symbolReferences debugInfo
+ ]
\ No newline at end of file
module {
- export = [possibleUnsafeSclValueByName, unsafeSclValueByName, sclModuleNames]
+ export = [possibleUnsafeSclValueByName, unsafeSclValueByName, sclModuleNames, moduleByName,
+ moduleOfName, nameOfName, createName, valueNamesOf]
}
include "SCL/ReflectionJava"
@JavaName getSourceRepository
moduleSourceRepositoryOf :: ModuleRepository -> ModuleSourceRepository
+ @JavaName getModule
+ moduleByName_ :: ModuleRepository -> String -> <Proc> Failable Module
+
importJava "org.simantics.scl.compiler.source.repository.ModuleSourceRepository" where
data ModuleSourceRepository
@JavaName getModuleNames
sclModuleNames_ :: ModuleSourceRepository -> [String]
+
+importJava "org.simantics.scl.compiler.errors.Failable" where
+ data Failable a
+
+ didSucceed :: Failable a -> Boolean
+ getResult :: Failable a -> Maybe a
+
+importJava "org.simantics.scl.compiler.module.Module" where
+ data Module
+
+ @JavaName getValueNames
+ valueNamesOf_ :: Module -> [String]
+
+importJava "org.simantics.scl.compiler.common.names.Name" where
+ data Name
+
+ @JavaName module
+ moduleOfName_ :: Name -> String
+ @JavaName name
+ nameOfName_ :: Name -> String
+
+ @JavaName create
+ createName_ :: String -> String -> Name
+
+instance Show Name where
+ sb <+ n = sb << moduleOfName n << "/" << nameOfName n
+
+moduleOfName = moduleOfName_
+nameOfName = nameOfName_
+createName = createName_
+valueNamesOf = valueNamesOf_
+
+type Location = Long
unsafeSclValueByName :: String -> <Proc> a
unsafeSclValueByName = unsafeSclValueByName_ MODULE_REPOSITORY
sclModuleNames :: <Proc> [String]
sclModuleNames = sclModuleNames_ (moduleSourceRepositoryOf MODULE_REPOSITORY)
+
+moduleByName :: String -> <Proc> Maybe Module
+moduleByName name = getResult failable
+ where
+ failable = moduleByName_ MODULE_REPOSITORY name
\ No newline at end of file
import org.simantics.scl.compiler.internal.codegen.utils.JavaNamingPolicy;
import org.simantics.scl.compiler.internal.header.ModuleHeader;
import org.simantics.scl.compiler.module.ConcreteModule;
+import org.simantics.scl.compiler.module.debug.ModuleDebugInfo;
import org.simantics.scl.compiler.module.repository.ModuleRepository;
import org.simantics.scl.compiler.types.Type;
public JavaNamingPolicy namingPolicy;
public ConcreteModule module;
public ModuleHeader header;
+ public ModuleDebugInfo moduleDebugInfo;
private THashMap<Name, SCLValue> valueCache = new THashMap<Name, SCLValue>();
import org.simantics.scl.compiler.module.ImportDeclaration;
import org.simantics.scl.compiler.module.InvalidModulePathException;
import org.simantics.scl.compiler.module.ModuleUtils;
+import org.simantics.scl.compiler.module.debug.ModuleDebugInfo;
import org.simantics.scl.compiler.module.repository.ImportFailure;
import org.simantics.scl.compiler.module.repository.ImportFailureException;
+import org.simantics.scl.compiler.top.SCLCompilerConfiguration;
import org.simantics.scl.compiler.types.TCon;
import org.simantics.scl.compiler.types.TForAll;
import org.simantics.scl.compiler.types.TFun;
final THashMap<SectionName, Query[]> sections = new THashMap<SectionName, Query[]>();
- final TranslationContext context = createTranslationContext();
+ final TranslationContext context = createTranslationContext(ruleName);
if(length > 0) {
THashMap<String, Variable> variables = context.getVariables();
for(TransformationRule extendsRule : extendsRules) {
continue;
try {
SCLValue value = module.getValue(name);
- TranslationContext context = createTranslationContext();
+ TranslationContext context = createTranslationContext(name);
Expression expression = context.translateCases2(defs);
value.setExpression(expression);
continue;
try {
SCLValue value = module.getValue(name);
- TranslationContext context = createTranslationContext();
+ TranslationContext context = createTranslationContext(name);
Expression expression = context.translateCases2(defs);
value.setExpression(expression);
DRelationAst definition = definitions.get(0);
ConcreteRelation relation = (ConcreteRelation)module.getRelation(name);
relation.location = definition.location;
- TranslationContext context = createTranslationContext();
+ TranslationContext context = createTranslationContext(name);
definition.translateTo(context, relation);
}
}
- private TranslationContext createTranslationContext() {
- return new TranslationContext(compilationContext, null);
+ private TranslationContext createTranslationContext(String definitionName) {
+ return new TranslationContext(compilationContext, null, definitionName);
}
private void handleAnnotation(SCLValue value, ArrayList<DValueAst> defs, DAnnotationAst annotation) {
branchPoints.put(valueName, injector.getAndClearBranchPoints());
}
}
+
+ public void collectDebugInfo() {
+ module.moduleDebugInfo = compilationContext.moduleDebugInfo = new ModuleDebugInfo();
+ }
}
declarations.relationDefinitionsAst);
if(options.computeCoverage)
elaboration.addCoverageBranchPoints();
+ if(options.collectDebugInfo)
+ elaboration.collectDebugInfo();
// Elaboration
if(hasErrors()) return;
elaboration.addTypesToEnvironment(
import java.util.Arrays;
import org.simantics.scl.compiler.common.names.Name;
-import org.simantics.scl.compiler.common.names.Names;
import org.simantics.scl.compiler.common.precedence.Associativity;
import org.simantics.scl.compiler.common.precedence.Precedence;
import org.simantics.scl.compiler.compilation.CompilationContext;
import org.simantics.scl.compiler.environment.filter.AcceptAllNamespaceFilter;
import org.simantics.scl.compiler.errors.Locations;
import org.simantics.scl.compiler.internal.parsing.declarations.DValueAst;
+import org.simantics.scl.compiler.module.debug.ModuleDebugInfo;
+import org.simantics.scl.compiler.module.debug.SymbolReference;
import org.simantics.scl.compiler.top.SCLCompilerConfiguration;
import org.simantics.scl.compiler.types.Type;
public CHRRuleset currentRuleset;
+ public ModuleDebugInfo moduleDebugInfo;
+
+ private String definitionName;
+
static class Entry {
String name;
Variable variable;
}
}
- public TranslationContext(CompilationContext compilationContext, LocalEnvironment localEnvironment) {
+ public TranslationContext(CompilationContext compilationContext, LocalEnvironment localEnvironment, String definitionName) {
super(compilationContext);
this.localEnvironment = localEnvironment;
+ this.moduleDebugInfo = compilationContext.moduleDebugInfo;
+ this.definitionName = definitionName;
}
public static boolean isConstructorName(String name) {
String deprecatedDescription = value.isDeprecated();
if(deprecatedDescription != null)
errorLog.logWarning(location, "Deprecated value " + value.getName().name + "." + (deprecatedDescription.isEmpty() ? "" : " " + deprecatedDescription));
+ if(moduleDebugInfo != null)
+ moduleDebugInfo.symbolReferences.add(new SymbolReference(value.getName(), definitionName, location));
return new EConstant(location, value);
} catch (AmbiguousNameException e) {
if(SCLCompilerConfiguration.ALLOW_OVERLOADING)
public Expression realize() {
EConstant expression = new EConstant(altValue);
expression.location = location;
+ if(moduleDebugInfo != null)
+ moduleDebugInfo.symbolReferences.add(new SymbolReference(altValue.getName(), definitionName, location));
return expression;
}
import java.util.Collections;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.SynchronousQueue;
import java.util.function.Consumer;
import org.simantics.scl.compiler.common.names.Name;
import org.simantics.scl.compiler.environment.filter.NamespaceFilter;
import org.simantics.scl.compiler.errors.CompilationError;
import org.simantics.scl.compiler.internal.codegen.effects.EffectConstructor;
+import org.simantics.scl.compiler.module.debug.ModuleDebugInfo;
import org.simantics.scl.compiler.top.ModuleInitializer;
import org.simantics.scl.compiler.types.TCon;
import org.simantics.scl.runtime.profiling.BranchPoint;
ModuleInitializer moduleInitializer;
protected Documentation documentation;
+
+ public ModuleDebugInfo moduleDebugInfo;
public ConcreteModule(String moduleName) {
this.moduleName = moduleName;
consumer.accept(value);
});
}
+
+ @Override
+ public List<String> getValueNames() {
+ return new ArrayList<String>(values.keySet());
+ }
public Collection<SCLRelation> getRelations() {
return relations.values();
public void setDeprecation(String deprecation) {
this.deprecation = deprecation;
}
+
+ @Override
+ public ModuleDebugInfo getModuleDebugInfo() {
+ return moduleDebugInfo;
+ }
}
package org.simantics.scl.compiler.module;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Consumer;
import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
import org.simantics.scl.compiler.elaboration.rules.MappingRelation;
import org.simantics.scl.compiler.elaboration.rules.TransformationRule;
+import org.simantics.scl.compiler.environment.filter.AcceptAllNamespaceFilter;
import org.simantics.scl.compiler.environment.filter.NamespaceFilter;
import org.simantics.scl.compiler.errors.CompilationError;
import org.simantics.scl.compiler.internal.codegen.effects.EffectConstructor;
+import org.simantics.scl.compiler.module.debug.ModuleDebugInfo;
import org.simantics.scl.compiler.top.ModuleInitializer;
import org.simantics.scl.compiler.types.TCon;
import org.simantics.scl.runtime.profiling.BranchPoint;
String getDefaultLocalName();
SCLValue getValue(String name);
+ default List<String> getValueNames() {
+ ArrayList<String> valueNames = new ArrayList<String>();
+ findValuesForPrefix("", AcceptAllNamespaceFilter.INSTANCE, value -> {
+ valueNames.add(value.getName().name);
+ });
+ return valueNames;
+ }
List<Constant> getFieldAccessors(String name);
SCLRelation getRelation(String name);
SCLEntityType getEntityType(String name);
CompilationError[] getWarnings();
ClassLoader getParentClassLoader();
String getDeprecation();
+
+ /**
+ * May return null, if there is no debug info.
+ */
+ default ModuleDebugInfo getModuleDebugInfo() {
+ return null;
+ }
}
--- /dev/null
+package org.simantics.scl.compiler.module.debug;
+
+import java.util.ArrayList;
+
+public class ModuleDebugInfo {
+ public final ArrayList<SymbolReference> symbolReferences = new ArrayList<SymbolReference>();
+}
--- /dev/null
+package org.simantics.scl.compiler.module.debug;
+
+import org.simantics.scl.compiler.common.names.Name;
+
+public class SymbolReference {
+ public final Name referred;
+ public final String referrer;
+ public final long referenceLocation;
+
+ public SymbolReference(Name referred, String referrer, long referenceLocation) {
+ this.referred = referred;
+ this.referrer = referrer;
+ this.referenceLocation = referenceLocation;
+ }
+}
public boolean computeCoverage;
public boolean silent = false;
+ public boolean collectDebugInfo = false;
public ModuleCompilationOptions(boolean computeCoverage) {
this.computeCoverage = computeCoverage;
// Elaboration
{
- TranslationContext context = new TranslationContext(compilationContext, localEnvironment);
+ TranslationContext context = new TranslationContext(compilationContext, localEnvironment, "expression");
expression = expression.resolve(context);
if(!errorLog.hasNoErrors())
throw new SCLExpressionCompilationException(errorLog.getErrors());
import java.util.ArrayList;
+import org.eclipse.core.internal.runtime.PlatformActivator;
import org.simantics.scl.compiler.errors.DoesNotExist;
import org.simantics.scl.compiler.errors.Failable;
import org.simantics.scl.compiler.module.Module;
+import org.simantics.scl.compiler.module.options.ModuleCompilationOptions;
+import org.simantics.scl.compiler.module.options.ModuleCompilationOptionsAdvisor;
import org.simantics.scl.compiler.module.repository.ModuleRepository;
import org.simantics.scl.compiler.source.repository.ModuleSourceRepository;
import org.simantics.scl.compiler.testing.repository.TestRepository;
public static ModuleRepository MODULE_REPOSITORY = new ModuleRepository(SOURCE_REPOSITORY);
public static TestRepository TEST_REPOSITORY = new ServiceBasedTestRepository(Activator.getContext());
+ static {
+ MODULE_REPOSITORY.setAdvisor(new ModuleCompilationOptionsAdvisor() {
+ ModuleCompilationOptions options = null;
+ @Override
+ public ModuleCompilationOptions getOptions(String moduleName) {
+ if(options == null) {
+ options = new ModuleCompilationOptions(false);
+ options.collectDebugInfo = Activator.getContext().getProperty("osgi.dev") != null; //$NON-NLS-1$
+ }
+ return options;
+ }
+ });
+ }
public static String compileAllModules() {
ArrayList<String> modulesWithErrors = new ArrayList<String>();