import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
-import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.simantics.scl.compiler.module.repository.ImportFailure;
import org.simantics.scl.compiler.module.repository.ImportFailureException;
import org.simantics.scl.compiler.module.repository.ModuleRepository;
+import org.simantics.scl.compiler.module.repository.UpdateListener;
import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
import org.simantics.scl.compiler.top.ExpressionEvaluator;
import org.simantics.scl.compiler.top.LocalStorage;
THashMap<String,Type> variableTypes = new THashMap<String,Type>();
PrintStream fileOutput;
-
+ private UpdateListener dependenciesListener;
+
+ /**
+ * Only checks the commands for compilation errors but does not run them.
+ */
+ private boolean validateOnly;
+
public CommandSession(ModuleRepository moduleRepository, SCLReportingHandler handler) {
this.moduleRepository = moduleRepository;
this.defaultHandler = new PrintDecorator(
runtimeEnvironment = null;
try {
+ if(dependenciesListener != null)
+ dependenciesListener.stopListening();
try {
runtimeEnvironment = moduleRepository.createRuntimeEnvironment(
environmentSpecification,
- getClass().getClassLoader());
+ getClass().getClassLoader(),
+ dependenciesListener);
} catch(ImportFailureException e) {
THashSet<String> failedModules = new THashSet<String>();
for(ImportFailure failure : e.failures) {
try {
runtimeEnvironment = moduleRepository.createRuntimeEnvironment(
environmentSpecification,
- getClass().getClassLoader());
+ getClass().getClassLoader()); // no listener here, because should listen also failed modules
} catch (ImportFailureException e1) {
for(ImportFailure failure : e1.failures)
defaultHandler.printError(failure.toString());
Function command = (Function)evaluator
.localEnvironment(localEnvironment)
.decorateExpression(true)
+ .validateOnly(validateOnly)
.eval();
return new CompiledCommand(command, evaluator.getType());
}
handler.printCommand(reader.extractString(expression.location));
command = compile(expression);
} catch (SCLExpressionCompilationException e) {
- CompilationError[] errors = ((SCLExpressionCompilationException)e).getErrors();
+ if(validateOnly)
+ throw e;
+ CompilationError[] errors = e.getErrors();
for(CompilationError error : errors) {
if(error.location != Locations.NO_LOCATION)
handler.printError(reader.locationUnderlining(error.location));
}
reader.forgetEverythingBefore(Locations.endOf(expression.location));
- Object resultValue = command.command.apply(variableValues);
- String resultString = toString(resultValue, command.type);
- if(!resultString.isEmpty())
- handler.print(resultString);
+ if(!validateOnly) {
+ Object resultValue = command.command.apply(variableValues);
+ String resultString = toString(resultValue, command.type);
+ if(!resultString.isEmpty())
+ handler.print(resultString);
+ }
} catch(Exception e) {
+ if(validateOnly)
+ throw e;
if(!(e instanceof CancelExecution)) {
if(e instanceof InterruptedException)
handler.printError("Execution interrupted.");
void finishBlock() {
if(currentBlock != null) {
checkInterrupted();
- LinkedList<Statement> statements = currentBlock.getStatements();
currentBlock.location = Locations.combine(
- statements.getFirst().location,
- statements.getLast().location);
+ currentBlock.getFirst().location,
+ currentBlock.getLast().location);
execute(reader, currentBlock, handler);
currentBlock = null;
}
}
}
+ private CompilationError[] validate(Reader commandReader) {
+ CommandParser parser = new CommandParser(defaultHandler, new MemoReader(commandReader));
+ validateOnly = true;
+ try {
+ parser.parseCommands();
+ parser.finishBlock();
+ return CompilationError.EMPTY_ARRAY;
+ } catch(SCLExpressionCompilationException e) {
+ return e.getErrors();
+ } catch(SCLSyntaxErrorException e) {
+ return new CompilationError[] { new CompilationError(e.location, e.getMessage()) };
+ } catch(Exception e) {
+ return new CompilationError[] { new CompilationError(Locations.NO_LOCATION, e.getMessage()) };
+ } finally {
+ validateOnly = false;
+ }
+ }
+
public void execute(Reader commandReader, SCLReportingHandler handler) {
if(handler == null)
handler = defaultHandler;
if(e.location != Locations.NO_LOCATION)
handler.printError(parser.reader.locationUnderlining(e.location));
handler.printError(e.getMessage());
- } catch(Exception e) {
+ } catch (Exception | AssertionError e) {
if(e instanceof InterruptedException)
handler.printError("Execution interrupted.");
else
execute(new StringReader(command), handler);
}
- public CompilationError[] validate(String command) {
- return CompilationError.EMPTY_ARRAY;
- /*try {
- compile(command);
- return CompilationError.EMPTY_ARRAY;
- } catch(SCLExpressionCompilationException e) {
- return e.getErrors();
- }*/
- }
-
private static final String THIS_CLASS_NAME = CommandSession.class.getName();
public static void formatException(
b.append("\tat ");
if("_SCL_Module".equals(fileName)
|| "_SCL_TypeClassInstance".equals(fileName))
- b.append(NameMangling.demangle(methodName))
+ b.append(className)
+ .append('.')
+ .append(NameMangling.demangle(methodName))
.append('(').append(element.getLineNumber()).append(')');
else
b.append(element);
formatException(handler, e);
}
}
+
+ public static CompilationError[] validate(ModuleRepository moduleRepository,StringReader commandReader) {
+ CommandSession session = new CommandSession(moduleRepository, null);
+ return session.validate(commandReader);
+ }
+
+ public static CompilationError[] validate(ModuleRepository moduleRepository,String command) {
+ return validate(moduleRepository, new StringReader(command));
+ }
+
+ public CompilationError[] validate(String command) {
+ return validate(new StringReader(command));
+ }
+
+ public void setDependenciesListener(UpdateListener dependenciesListener) {
+ this.dependenciesListener = dependenciesListener;
+ }
}