Bundle-ManifestVersion: 2
Bundle-Name: Silk icon set
Bundle-SymbolicName: com.famfamfam.silk
-Bundle-Version: 1.3
+Bundle-Version: 1.3.0
Bundle-Vendor: Semantum Oy
if (parent != null) {\r
_additions.add(new Object[] { ss.getRandomAccessId(parent), ss.getRandomAccessId(entry.component), name, types, id != null ? id.indexString() : "" });\r
} else {\r
- System.err.println("resource " + entry.component + ": no parent for entry " + name + " " + types);\r
+ //System.err.println("resource " + entry.component + ": no parent for entry " + name + " " + types);\r
}\r
} else {\r
- System.err.println("resource " + entry.component + ": " + name + " " + types);\r
+ //System.err.println("resource " + entry.component + ": " + name + " " + types);\r
}\r
} else if(_entry instanceof ComponentModification) {\r
ComponentModification entry = (ComponentModification)_entry;\r
output.. = bin/\r
bin.includes = META-INF/,\\r
.,\\r
- bin/msijni.dll,\\r
- bin/msijni64.dll,\\r
+ msijni.dll,\\r
+ msijni64.dll,\\r
VC90.2008.SP1.KB2467174.redist.x64.exe,\\r
VC90.2008.SP1.KB2467174.redist.x86.exe\r
src.includes = native/\r
Bundle-RequiredExecutionEnvironment: JavaSE-1.8
Export-Package: org.simantics.db.procore.ui
Import-Package:
- org.osgi.framework;version="1.3.0",
+ org.eclipse.core.runtime,
org.eclipse.jface.dialogs,
org.eclipse.jface.operation,
- org.eclipse.core.runtime,
org.eclipse.swt.widgets,
- org.eclipse.ui,
+ org.osgi.framework;version="1.3.0",
org.simantics.db,
- org.simantics.db.exception,
org.simantics.db.common.utils,
+ org.simantics.db.exception,
org.simantics.db.server;visibility:=reexport
Require-Bundle: org.simantics.db.procore;bundle-version="1.2.1"
\r
import org.eclipse.swt.widgets.Display;\r
import org.eclipse.swt.widgets.Shell;\r
-import org.eclipse.ui.IWorkbench;\r
-import org.eclipse.ui.IWorkbenchWindow;\r
import org.simantics.db.DatabaseUserAgent;\r
import org.simantics.db.exception.InternalException;\r
import org.simantics.db.procore.ProCoreDriver;\r
\r
public final class ProCoreUserAgent implements DatabaseUserAgent {\r
- private static Shell getShell(IWorkbench workbench) {\r
- IWorkbenchWindow wbw = workbench.getActiveWorkbenchWindow();\r
+ private static Shell getShell() {\r
Shell shell = null;\r
- if (null != wbw) {\r
- shell = wbw.getShell();\r
- } else {\r
- Display d = getDisplay();\r
- if (d == null)\r
- return null;\r
- shell = d.getActiveShell();\r
- if (null == shell) {\r
- Shell[] shells = d.getShells();\r
- if (null != shells && shells.length > 0)\r
- shell = shells[0];\r
- }\r
+ Display d = getDisplay();\r
+ if (d == null)\r
+ return null;\r
+ shell = d.getActiveShell();\r
+ if (null == shell) {\r
+ Shell[] shells = d.getShells();\r
+ if (null != shells && shells.length > 0)\r
+ shell = shells[0];\r
}\r
return shell;\r
}\r
d = Display.getDefault();\r
return d;\r
}\r
- private IWorkbench workbench;\r
- public ProCoreUserAgent(IWorkbench workbench) {\r
- this.workbench = workbench;\r
- }\r
- private Shell getShell() {\r
- return getShell(workbench);\r
- }\r
@Override\r
public boolean handleStart(InternalException exception) {\r
Shell shell = getShell();\r
.,\\r
win32.x86/,\\r
win32.x86_64/,\\r
- linux.x86/,\\r
linux.x86_64/\r
output.. = bin/\r
bin.includes = META-INF/,\\r
.,\\r
- graphs/*.tg,\\r
graph.tg\r
src.includes = graph/\r
bin.includes = META-INF/,\\r
.,\\r
plugin.xml,\\r
- document.war,\\r
webdefault.xml,\\r
scl/,\\r
src.includes = scl/\r
output.. = bin/\r
bin.includes = META-INF/,\\r
.,\\r
- graphs/*.tg,\\r
graph.tg\r
src.includes = graph/\r
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<classpath>\r
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>\r
+ <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>\r
+ <classpathentry kind="src" path="src"/>\r
+ <classpathentry exported="true" kind="lib" path="jna-4.2.1.jar"/>\r
+ <classpathentry kind="lib" path="jna-platform-4.2.1.jar"/>\r
+ <classpathentry kind="output" path="bin"/>\r
+</classpath>\r
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<projectDescription>\r
+ <name>org.simantics.nativemem</name>\r
+ <comment></comment>\r
+ <projects>\r
+ </projects>\r
+ <buildSpec>\r
+ <buildCommand>\r
+ <name>org.eclipse.jdt.core.javabuilder</name>\r
+ <arguments>\r
+ </arguments>\r
+ </buildCommand>\r
+ <buildCommand>\r
+ <name>org.eclipse.pde.ManifestBuilder</name>\r
+ <arguments>\r
+ </arguments>\r
+ </buildCommand>\r
+ <buildCommand>\r
+ <name>org.eclipse.pde.SchemaBuilder</name>\r
+ <arguments>\r
+ </arguments>\r
+ </buildCommand>\r
+ </buildSpec>\r
+ <natures>\r
+ <nature>org.eclipse.pde.PluginNature</nature>\r
+ <nature>org.eclipse.jdt.core.javanature</nature>\r
+ </natures>\r
+</projectDescription>\r
--- /dev/null
+eclipse.preferences.version=1\r
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled\r
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7\r
+org.eclipse.jdt.core.compiler.compliance=1.7\r
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error\r
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error\r
+org.eclipse.jdt.core.compiler.source=1.7\r
--- /dev/null
+eclipse.preferences.version=1\r
+pluginProject.extensions=false\r
+resolve.requirebundle=false\r
--- /dev/null
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Native Memory Tracking
+Bundle-SymbolicName: org.simantics.nativemem
+Bundle-Version: 1.0.0.qualifier
+Bundle-Vendor: Semantum Oy
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
+Bundle-ClassPath: .,
+ jna-4.2.1.jar,
+ jna-platform-4.2.1.jar
+Export-Package: org.simantics.nativemem
--- /dev/null
+source.. = src/\r
+output.. = bin/\r
+bin.includes = META-INF/,\\r
+ .,\\r
+ jna-4.2.1.jar,\\r
+ jna-platform-4.2.1.jar\r
--- /dev/null
+package org.simantics.nativemem;\r
+\r
+import org.simantics.nativemem.internal.Arch;\r
+import org.simantics.nativemem.internal.OS;\r
+import org.simantics.nativemem.internal.Psapi32;\r
+import org.simantics.nativemem.internal.Psapi64;\r
+\r
+import com.sun.jna.platform.win32.Kernel32;\r
+import com.sun.jna.platform.win32.WinNT.HANDLE;\r
+\r
+\r
+public class NativeMem {\r
+\r
+ /**\r
+ * @param out\r
+ * the structure to write the result into or <code>null</code> to\r
+ * create a new structure\r
+ * @return the result structure\r
+ */\r
+ public static ProcessMemoryCounters getMemoryCounters(ProcessMemoryCounters out) {\r
+ if (out == null)\r
+ out = new ProcessMemoryCounters();\r
+\r
+ OS os = OS.calculate();\r
+ Arch arch = Arch.calculate();\r
+ switch (os) {\r
+ case WINDOWS: {\r
+ HANDLE proc = Kernel32.INSTANCE.GetCurrentProcess();\r
+ switch (arch) {\r
+ case X86: {\r
+ Psapi32.PROCESS_MEMORY_COUNTERS_EX pmem = new Psapi32.PROCESS_MEMORY_COUNTERS_EX();\r
+ boolean ok = Psapi32.INSTANCE.GetProcessMemoryInfo(proc, pmem, pmem.size());\r
+ if (ok)\r
+ pmem.writeTo(out);\r
+ return out;\r
+ }\r
+\r
+ case X86_64: {\r
+ Psapi64.PROCESS_MEMORY_COUNTERS_EX pmem = new Psapi64.PROCESS_MEMORY_COUNTERS_EX();\r
+ boolean ok = Psapi64.INSTANCE.GetProcessMemoryInfo(proc, pmem, pmem.size());\r
+ if (ok)\r
+ pmem.writeTo(out);\r
+ return out;\r
+ }\r
+\r
+ default:\r
+ throw new UnsupportedOperationException("Architecture " + arch + " not supported on operating system " + os);\r
+ }\r
+ }\r
+\r
+ default:\r
+ throw new UnsupportedOperationException("Operating system " + os + " not supported");\r
+ }\r
+ }\r
+\r
+}
\ No newline at end of file
--- /dev/null
+package org.simantics.nativemem;\r
+\r
+/**\r
+ * Architecture-independent version of the Windows PsApi PROCESS_MEMORY_COUNTERS\r
+ * structure.\r
+ * \r
+ * @author Tuukka Lehtonen\r
+ */\r
+public class ProcessMemoryCounters {\r
+ public int PageFaultCount;\r
+ public long PeakWorkingSetSize;\r
+ public long WorkingSetSize;\r
+ public long QuotaPeakPagedPoolUsage;\r
+ public long QuotaPagedPoolUsage;\r
+ public long QuotaPeakNonPagedPoolUsage;\r
+ public long QuotaNonPagedPoolUsage;\r
+ public long PagefileUsage;\r
+ public long PeakPagefileUsage;\r
+ public long PrivateUsage;\r
+\r
+ @Override\r
+ public String toString() {\r
+ return "ProcessMemoryCounters [PageFaultCount="\r
+ + PageFaultCount + ", PeakWorkingSetSize=" + PeakWorkingSetSize\r
+ + ", WorkingSetSize=" + WorkingSetSize\r
+ + ", QuotaPeakPagedPoolUsage=" + QuotaPeakPagedPoolUsage\r
+ + ", QuotaPagedPoolUsage=" + QuotaPagedPoolUsage\r
+ + ", QuotaPeakNonPagedPoolUsage=" + QuotaPeakNonPagedPoolUsage\r
+ + ", QuotaNonPagedPoolUsage=" + QuotaNonPagedPoolUsage\r
+ + ", PagefileUsage=" + PagefileUsage + ", PeakPagefileUsage="\r
+ + PeakPagefileUsage + ", PrivateUsage=" + PrivateUsage + "]";\r
+ }\r
+\r
+ public String toHumanReadableString() {\r
+ StringBuilder sb = new StringBuilder();\r
+ sb.append("ProcessMemoryCounters [\n\tPageFaultCount = ").append(PageFaultCount)\r
+ .append(",\n\tPeakWorkingSetSize = ").append(toMb(PeakWorkingSetSize))\r
+ .append(" MB,\n\tWorkingSetSize = ").append(toMb(WorkingSetSize))\r
+ .append(" MB,\n\tQuotaPeakPagedPoolUsage = ").append(toMb(QuotaPeakPagedPoolUsage))\r
+ .append(" MB,\n\tQuotaPagedPoolUsage = ").append(toMb(QuotaPagedPoolUsage))\r
+ .append(" MB,\n\tQuotaPeakNonPagedPoolUsage = ").append(toMb(QuotaPeakNonPagedPoolUsage))\r
+ .append(" MB,\n\tQuotaNonPagedPoolUsage = ").append(toMb(QuotaNonPagedPoolUsage))\r
+ .append(" MB,\n\tPagefileUsage = ").append(toMb(PagefileUsage))\r
+ .append(" MB,\n\tPeakPagefileUsage = ").append(toMb(PeakPagefileUsage))\r
+ .append(" MB,\n\tPrivateUsage = ").append(toMb(PrivateUsage))\r
+ .append(" MB]");\r
+ return sb.toString();\r
+ }\r
+\r
+ private double toMb(long bytes) {\r
+ return (double) bytes / 1048576.0;\r
+ }\r
+\r
+}
\ No newline at end of file
--- /dev/null
+package org.simantics.nativemem.internal;\r
+\r
+/**\r
+ * @author Tuukka Lehtonen\r
+ */\r
+public enum Arch {\r
+ PPC, PPC_64, SPARC, X86, X86_64, UNKNOWN;\r
+\r
+ public static Arch calculate() {\r
+ String osArch = System.getProperty("os.arch");\r
+ assert osArch != null;\r
+ osArch = osArch.toLowerCase();\r
+ if (osArch.equals("i386") || osArch.equals("i586") || osArch.equals("i686") || osArch.equals("x86"))\r
+ return X86;\r
+ if (osArch.startsWith("amd64") || osArch.startsWith("x86_64"))\r
+ return X86_64;\r
+ if (osArch.equals("ppc"))\r
+ return PPC;\r
+ if (osArch.startsWith("ppc"))\r
+ return PPC_64;\r
+ if (osArch.startsWith("sparc"))\r
+ return SPARC;\r
+ return UNKNOWN;\r
+ }\r
+}\r
--- /dev/null
+package org.simantics.nativemem.internal;\r
+\r
+public enum OS {\r
+ APPLE, LINUX, SUN, WINDOWS, UNKNOWN;\r
+\r
+ public static OS calculate() {\r
+ String osName = System.getProperty("os.name");\r
+ assert osName != null;\r
+ osName = osName.toLowerCase();\r
+ if (osName.startsWith("mac os x"))\r
+ return APPLE;\r
+ if (osName.startsWith("windows"))\r
+ return WINDOWS;\r
+ if (osName.startsWith("linux"))\r
+ return LINUX;\r
+ if (osName.startsWith("sun"))\r
+ return SUN;\r
+ return UNKNOWN;\r
+ }\r
+}\r
--- /dev/null
+package org.simantics.nativemem.internal;\r
+\r
+import java.util.Arrays;\r
+import java.util.List;\r
+\r
+import org.simantics.nativemem.ProcessMemoryCounters;\r
+\r
+import com.sun.jna.Native;\r
+import com.sun.jna.Structure;\r
+import com.sun.jna.platform.win32.WinNT.HANDLE;\r
+import com.sun.jna.win32.StdCallLibrary;\r
+\r
+public interface Psapi32 extends StdCallLibrary {\r
+\r
+ Psapi32 INSTANCE = (Psapi32) Native.loadLibrary("Psapi", Psapi32.class);\r
+\r
+ /*\r
+ * https://msdn.microsoft.com/en-us/library/windows/desktop/ms684874%28v=vs.85%29.aspx\r
+ */\r
+ public static class PROCESS_MEMORY_COUNTERS_EX extends Structure {\r
+ public int cb;\r
+ public int PageFaultCount;\r
+ public int PeakWorkingSetSize;\r
+ public int WorkingSetSize;\r
+ public int QuotaPeakPagedPoolUsage;\r
+ public int QuotaPagedPoolUsage;\r
+ public int QuotaPeakNonPagedPoolUsage;\r
+ public int QuotaNonPagedPoolUsage;\r
+ public int PagefileUsage;\r
+ public int PeakPagefileUsage;\r
+ public int PrivateUsage;\r
+\r
+ @SuppressWarnings("rawtypes")\r
+ @Override\r
+ protected List getFieldOrder() {\r
+ return PROCESS_MEMORY_COUNTERS_EX_FIELDS;\r
+ }\r
+\r
+ static final List<String> PROCESS_MEMORY_COUNTERS_EX_FIELDS = Arrays.asList(new String[] { \r
+ "cb", "PageFaultCount",\r
+ "PeakWorkingSetSize", "WorkingSetSize",\r
+ "QuotaPeakPagedPoolUsage", "QuotaPagedPoolUsage",\r
+ "QuotaPeakNonPagedPoolUsage", "QuotaNonPagedPoolUsage",\r
+ "PagefileUsage", "PeakPagefileUsage", "PrivateUsage"\r
+ });\r
+\r
+ public void writeTo(ProcessMemoryCounters to) {\r
+ to.PageFaultCount = PageFaultCount;\r
+ to.PeakWorkingSetSize = PeakWorkingSetSize;\r
+ to.WorkingSetSize = WorkingSetSize;\r
+ to.QuotaPeakPagedPoolUsage = QuotaPeakPagedPoolUsage;\r
+ to.QuotaPagedPoolUsage = QuotaPagedPoolUsage;\r
+ to.QuotaPeakNonPagedPoolUsage = QuotaPeakNonPagedPoolUsage;\r
+ to.QuotaNonPagedPoolUsage = QuotaNonPagedPoolUsage;\r
+ to.PagefileUsage = PagefileUsage;\r
+ to.PeakPagefileUsage = PeakPagefileUsage;\r
+ to.PrivateUsage = PrivateUsage;\r
+ }\r
+ }\r
+\r
+ /*\r
+ * https://msdn.microsoft.com/en-us/library/windows/desktop/ms683219%28v=vs.85%29.aspx\r
+ */\r
+ boolean GetProcessMemoryInfo(HANDLE Process, PROCESS_MEMORY_COUNTERS_EX ppsmemCounters, int cb);\r
+\r
+\r
+}
\ No newline at end of file
--- /dev/null
+package org.simantics.nativemem.internal;\r
+\r
+import java.util.Arrays;\r
+import java.util.List;\r
+\r
+import org.simantics.nativemem.ProcessMemoryCounters;\r
+\r
+import com.sun.jna.Native;\r
+import com.sun.jna.Structure;\r
+import com.sun.jna.platform.win32.WinNT.HANDLE;\r
+import com.sun.jna.win32.StdCallLibrary;\r
+\r
+public interface Psapi64 extends StdCallLibrary {\r
+\r
+ Psapi64 INSTANCE = (Psapi64) Native.loadLibrary("Psapi", Psapi64.class);\r
+\r
+ /*\r
+ * https://msdn.microsoft.com/en-us/library/windows/desktop/ms684874%28v=vs.85%29.aspx\r
+ */\r
+ public static class PROCESS_MEMORY_COUNTERS_EX extends Structure {\r
+ public int cb;\r
+ public int PageFaultCount;\r
+ public long PeakWorkingSetSize;\r
+ public long WorkingSetSize;\r
+ public long QuotaPeakPagedPoolUsage;\r
+ public long QuotaPagedPoolUsage;\r
+ public long QuotaPeakNonPagedPoolUsage;\r
+ public long QuotaNonPagedPoolUsage;\r
+ public long PagefileUsage;\r
+ public long PeakPagefileUsage;\r
+ public long PrivateUsage;\r
+\r
+ @SuppressWarnings("rawtypes")\r
+ @Override\r
+ protected List getFieldOrder() {\r
+ return PROCESS_MEMORY_COUNTERS_EX_FIELDS;\r
+ }\r
+\r
+ private static final List<String> PROCESS_MEMORY_COUNTERS_EX_FIELDS = Arrays.asList(new String[] { \r
+ "cb", "PageFaultCount",\r
+ "PeakWorkingSetSize", "WorkingSetSize",\r
+ "QuotaPeakPagedPoolUsage", "QuotaPagedPoolUsage",\r
+ "QuotaPeakNonPagedPoolUsage", "QuotaNonPagedPoolUsage",\r
+ "PagefileUsage", "PeakPagefileUsage", "PrivateUsage"\r
+ });\r
+\r
+ public void writeTo(ProcessMemoryCounters to) {\r
+ to.PageFaultCount = PageFaultCount;\r
+ to.PeakWorkingSetSize = PeakWorkingSetSize;\r
+ to.WorkingSetSize = WorkingSetSize;\r
+ to.QuotaPeakPagedPoolUsage = QuotaPeakPagedPoolUsage;\r
+ to.QuotaPagedPoolUsage = QuotaPagedPoolUsage;\r
+ to.QuotaPeakNonPagedPoolUsage = QuotaPeakNonPagedPoolUsage;\r
+ to.QuotaNonPagedPoolUsage = QuotaNonPagedPoolUsage;\r
+ to.PagefileUsage = PagefileUsage;\r
+ to.PeakPagefileUsage = PeakPagefileUsage;\r
+ to.PrivateUsage = PrivateUsage;\r
+ }\r
+ }\r
+\r
+ /*\r
+ * https://msdn.microsoft.com/en-us/library/windows/desktop/ms683219%28v=vs.85%29.aspx\r
+ */\r
+ boolean GetProcessMemoryInfo(HANDLE Process, PROCESS_MEMORY_COUNTERS_EX ppsmemCounters, int cb);\r
+\r
+}
\ No newline at end of file
--- /dev/null
+package org.simantics.nativemem.internal;\r
+\r
+import org.simantics.nativemem.NativeMem;\r
+import org.simantics.nativemem.ProcessMemoryCounters;\r
+\r
+public class Test {\r
+\r
+ public static void main(String[] args) {\r
+ ProcessMemoryCounters mem = NativeMem.getMemoryCounters(null);\r
+ System.out.println(mem.toHumanReadableString());\r
+ }\r
+\r
+}\r
package org.cojen.classfile;
-import java.io.Serializable;
import java.io.Externalizable;
-import java.io.ObjectOutput;
-import java.io.ObjectInput;
import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
import java.io.ObjectStreamException;
+import java.io.Serializable;
import java.lang.reflect.Method;
-import java.util.List;
import java.util.ArrayList;
+import java.util.List;
import org.cojen.util.WeakCanonicalSet;
package org.cojen.classfile;
import java.io.Serializable;
-import java.io.Externalizable;
-import java.io.ObjectOutput;
-import java.io.ObjectInput;
-import java.io.IOException;
-import java.io.ObjectStreamException;
import java.lang.ref.SoftReference;
import java.lang.reflect.Array;
import java.util.Collections;
return false;
}
- Object writeReplace() throws ObjectStreamException {
- return new External(mDescriptor);
- }
-
private static class PrimitiveType extends TypeDesc {
private transient final int mCode;
private transient TypeDesc mArrayType;
}
}
}
-
- private static class External implements Externalizable {
- private String mDescriptor;
-
- public External() {
- }
-
- public External(String desc) {
- mDescriptor = desc;
- }
-
- public void writeExternal(ObjectOutput out) throws IOException {
- out.writeUTF(mDescriptor);
- }
-
- public void readExternal(ObjectInput in) throws IOException {
- mDescriptor = in.readUTF();
- }
-
- public Object readResolve() throws ObjectStreamException {
- return forDescriptor(mDescriptor);
- }
- }
}
package org.simantics.scl.compiler.commands;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.procedure.TObjectProcedure;
-import gnu.trove.set.hash.THashSet;
-
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import org.simantics.scl.runtime.reporting.SCLReportingHandler;
import org.simantics.scl.runtime.tuple.Tuple0;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.procedure.TObjectProcedure;
+import gnu.trove.set.hash.THashSet;
+
public class CommandSession {
package org.simantics.scl.compiler.commands;
-import gnu.trove.map.hash.THashMap;
-
import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
import org.simantics.scl.compiler.top.ExpressionEvaluator;
import org.simantics.scl.compiler.top.SCLExpressionCompilationException;
import org.simantics.scl.compiler.types.Types;
import org.simantics.scl.runtime.function.Function1;
+import gnu.trove.map.hash.THashMap;
+
public class ValueToStringConverter {
final RuntimeEnvironment environment;
final THashMap<Type, Function1> showInstances = new THashMap<Type, Function1>();
package org.simantics.scl.compiler.compilation;\r
\r
-import gnu.trove.map.hash.TObjectLongHashMap;\r
-\r
import java.util.ArrayList;\r
\r
+import gnu.trove.map.hash.TObjectLongHashMap;\r
+\r
public class CompilationTimer {\r
private long initialTime, previousTime;\r
private ArrayList<TimerEntry> entries = new ArrayList<TimerEntry>();\r
package org.simantics.scl.compiler.compilation;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.set.hash.THashSet;
-
import java.util.ArrayList;
import org.simantics.scl.compiler.elaboration.modules.SCLValue;
import org.simantics.scl.compiler.module.ConcreteModule;
import org.simantics.scl.compiler.types.TCon;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.set.hash.THashSet;
+
public class DocumentationGeneration {
THashMap<String, DDocumentationAst> valueDocumentation;
THashMap<String, DDocumentationAst> typeDocumentation;
package org.simantics.scl.compiler.compilation;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.simantics.scl.compiler.environment.AmbiguousNameException;\r
import org.simantics.scl.compiler.environment.Environment;\r
import org.simantics.scl.compiler.errors.ErrorLog;\r
+import org.simantics.scl.compiler.top.SCLCompilerConfiguration;\r
\r
public class NameExistenceChecks {\r
public static void checkIfValueExists(ErrorLog errorLog, long location,\r
Environment environment, String name) {\r
- try {\r
- SCLValue value = environment.getLocalNamespace().getValue(name);\r
- if(value != null)\r
+ if(SCLCompilerConfiguration.ALLOW_OVERLOADING)\r
+ return;\r
+ else {\r
+ try {\r
+ SCLValue value = environment.getLocalNamespace().getValue(name);\r
+ if(value != null)\r
+ errorLog.log(location,\r
+ "Value " + name + " is already defined in the module " + \r
+ value.getName().module + \r
+ " that is imported to the default namespace.");\r
+ } catch(AmbiguousNameException e) {\r
errorLog.log(location,\r
- "Value " + name + " is already defined in the module " + \r
- value.getName().module + \r
- " that is imported to the default namespace.");\r
- } catch(AmbiguousNameException e) {\r
- errorLog.log(location,\r
- "Value " + name + " is already defined in the modules " + \r
- e.conflictingModules[0] + " and " + e.conflictingModules[1] + \r
- " that are imported to the default namespace.");\r
+ "Value " + name + " is already defined in the modules " + \r
+ e.conflictingModules[0] + " and " + e.conflictingModules[1] + \r
+ " that are imported to the default namespace.");\r
+ }\r
}\r
}\r
\r
package org.simantics.scl.compiler.compilation;
-import gnu.trove.procedure.TObjectProcedure;
-
+import java.util.Arrays;
import java.util.function.Consumer;
import org.simantics.scl.compiler.elaboration.modules.SCLValue;
import org.simantics.scl.compiler.environment.filter.NamespaceFilter;
import org.simantics.scl.compiler.internal.codegen.effects.EffectConstructor;
import org.simantics.scl.compiler.module.Module;
+import org.simantics.scl.compiler.top.SCLCompilerConfiguration;
import org.simantics.scl.compiler.types.TCon;
+import gnu.trove.procedure.TObjectProcedure;
+
public class NamespaceOfModule implements Namespace {
private final Namespace base;
private final Module module;
@Override
public SCLValue getValue(String name) throws AmbiguousNameException {
SCLValue value = module.getValue(name);
+ if(SCLCompilerConfiguration.ALLOW_OVERLOADING) {
+ SCLValue value2;
+ try {
+ value2 = base.getValue(name);
+ } catch(AmbiguousNameException e) {
+ if(value != null) {
+ String[] conflictingModules = Arrays.copyOf(e.conflictingModules, e.conflictingModules.length+1);
+ conflictingModules[e.conflictingModules.length] = module.getName();
+ throw new AmbiguousNameException(Arrays.asList(conflictingModules), e.name);
+ }
+ else
+ throw e;
+ }
+ if(value == null)
+ return value2;
+ if(value2 == null)
+ return value;
+ throw new AmbiguousNameException(Arrays.asList(value.getName().module, value2.getName().module), value.getName().name);
+ }
+ else {
if(value != null)
return value;
return base.getValue(name);
+ }
}
@Override
import static org.simantics.scl.compiler.elaboration.expressions.Expressions.lambda;
import static org.simantics.scl.compiler.elaboration.expressions.Expressions.loc;
import static org.simantics.scl.compiler.elaboration.expressions.Expressions.vars;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-import gnu.trove.set.hash.TIntHashSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
+import org.simantics.scl.compiler.elaboration.expressions.EAmbiguous;
import org.simantics.scl.compiler.elaboration.expressions.EPlaceholder;
import org.simantics.scl.compiler.elaboration.expressions.ETransformation;
import org.simantics.scl.compiler.elaboration.expressions.EVariable;
import org.simantics.scl.compiler.types.kinds.Kinds;
import org.simantics.scl.compiler.types.util.Polarity;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
+
public class TypeChecking {
final ErrorLog errorLog;
final Environment environment;
context.pushEffectUpperBound(expression.location, Types.PROC);
expression = expression.checkType(context, value.getType());
context.popEffectUpperBound();
+ for(EAmbiguous overloaded : context.overloadedExpressions)
+ overloaded.assertResolved(errorLog);
value.setExpression(expression);
ArrayList<EVariable> constraintDemand = context.getConstraintDemand();
@Override
public void run() {
Type type = value.getType();
+
Expression expression = value.getExpression();
try {
context.pushEffectUpperBound(expression.location, Types.PROC);
expression = expression.checkType(context, type);
context.popEffectUpperBound();
+ for(EAmbiguous overloaded : context.overloadedExpressions)
+ overloaded.assertResolved(errorLog);
expression.getType().addPolarity(Polarity.POSITIVE);
context.solveSubsumptions(expression.getLocation());
ArrayList<EVariable> demands = context.getConstraintDemand();
+++ /dev/null
-package org.simantics.scl.compiler.compilation;
-
-import static org.simantics.scl.compiler.elaboration.expressions.Expressions.apply;
-import static org.simantics.scl.compiler.elaboration.expressions.Expressions.applyTypes;
-import static org.simantics.scl.compiler.elaboration.expressions.Expressions.lambda;
-import static org.simantics.scl.compiler.elaboration.expressions.Expressions.loc;
-import static org.simantics.scl.compiler.elaboration.expressions.Expressions.vars;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-import gnu.trove.set.hash.TIntHashSet;
-
-import java.util.ArrayList;
-
-import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
-import org.simantics.scl.compiler.elaboration.expressions.EPlaceholder;
-import org.simantics.scl.compiler.elaboration.expressions.EVariable;
-import org.simantics.scl.compiler.elaboration.expressions.Expression;
-import org.simantics.scl.compiler.elaboration.expressions.Variable;
-import org.simantics.scl.compiler.elaboration.modules.SCLValue;
-import org.simantics.scl.compiler.elaboration.rules.MappingRelation;
-import org.simantics.scl.compiler.elaboration.rules.TransformationRule;
-import org.simantics.scl.compiler.environment.Environment;
-import org.simantics.scl.compiler.errors.ErrorLog;
-import org.simantics.scl.compiler.errors.Locations;
-import org.simantics.scl.compiler.internal.elaboration.constraints.Constraint;
-import org.simantics.scl.compiler.internal.elaboration.constraints.ConstraintEnvironment;
-import org.simantics.scl.compiler.internal.elaboration.constraints.ConstraintSolver;
-import org.simantics.scl.compiler.internal.elaboration.constraints.ExpressionAugmentation;
-import org.simantics.scl.compiler.internal.elaboration.constraints.ReducedConstraints;
-import org.simantics.scl.compiler.internal.elaboration.utils.StronglyConnectedComponents;
-import org.simantics.scl.compiler.module.ConcreteModule;
-import org.simantics.scl.compiler.types.TPred;
-import org.simantics.scl.compiler.types.TVar;
-import org.simantics.scl.compiler.types.Type;
-import org.simantics.scl.compiler.types.Types;
-import org.simantics.scl.compiler.types.kinds.Kinds;
-import org.simantics.scl.compiler.types.util.Polarity;
-
-public class TypeCheckingOld {
- public static final boolean PRINT_VALUES = false;
-
- ErrorLog errorLog;
- Environment environment;
- ConcreteModule module;
-
- ConstraintEnvironment ce;
- ArrayList<SCLValue[]> valuesWithoutTypeAnnotation = new ArrayList<SCLValue[]>();
- ArrayList<SCLValue> valuesWithTypeAnnotation = new ArrayList<SCLValue>();
-
- public TypeCheckingOld(ErrorLog errorLog, Environment environment,
- ConcreteModule module) {
- this.errorLog = errorLog;
- this.environment = environment;
- this.module = module;
- }
-
- public void typeCheck() {
- ce = new ConstraintEnvironment(environment);
- groupValueDefinitionsByDependency();
- typeCheckValuesWithoutTypeAnnotations();
- typeCheckValuesWithTypeAnnotations();
- typeCheckRules();
- }
-
- private void groupValueDefinitionsByDependency() {
- // Collect all untyped names
- final ArrayList<SCLValue> values = new ArrayList<SCLValue>();
- for(SCLValue value : module.getValues()) {
- if(value.getExpression() != null) {
- if(value.getType() == null)
- values.add(value);
- else
- valuesWithTypeAnnotation.add(value);
- }
- }
-
- // Create inverse
- final TObjectIntHashMap<Object> allRefs =
- new TObjectIntHashMap<Object>(values.size()*2, 0.5f, -1);
- for(int i=0;i<values.size();++i)
- allRefs.put(values.get(i), i);
-
- // Create groups
- new StronglyConnectedComponents(values.size()) {
-
- TIntHashSet set = new TIntHashSet();
-
- @Override
- protected void reportComponent(int[] component) {
- SCLValue[] valueComponent = new SCLValue[component.length];
- for(int i=0;i<component.length;++i)
- valueComponent[i] = values.get(component[i]);
- valuesWithoutTypeAnnotation.add(valueComponent);
- }
-
- @Override
- protected int[] findDependencies(int u) {
- Expression expression = values.get(u).getExpression();
- expression.collectRefs(allRefs, set);
-
- int[] result = set.toArray();
- set.clear();
-
- return result;
- }
-
- }.findComponents();
- }
-
- private void typeCheckValuesWithoutTypeAnnotations() {
- for(SCLValue[] group : valuesWithoutTypeAnnotation) {
- if(PRINT_VALUES) {
- System.out.println("---------------------------------------------");
- System.out.print("---");
- for(SCLValue value : group)
- System.out.print(" " + value.getName());
- System.out.println();
- }
-
- for(int i=0;i<group.length;++i)
- group[i].setType(Types.metaVar(Kinds.STAR));
-
- TypingContext context = new TypingContext(errorLog, environment);
- context.recursiveValues = new THashSet<SCLValue>();
- for(SCLValue value : group)
- context.recursiveValues.add(value);
-
- @SuppressWarnings("unchecked")
- ArrayList<EVariable>[] constraintDemands = new ArrayList[group.length];
-
- @SuppressWarnings("unchecked")
- ArrayList<EPlaceholder>[] recursiveReferences = new ArrayList[group.length];
- for(int i=0;i<group.length;++i) {
- context.recursiveReferences = new ArrayList<EPlaceholder>();
-
- SCLValue value = group[i];
- Expression expression = value.getExpression();
- expression = expression.checkType(context, value.getType());
- value.setExpression(expression);
-
- ArrayList<EVariable> constraintDemand = context.getConstraintDemand();
- if(!constraintDemand.isEmpty()) {
- constraintDemands[i] = constraintDemand;
- context.resetConstraintDemand();
- }
-
- recursiveReferences[i] = context.recursiveReferences;
- }
-
- for(Type type : Types.getTypes(group))
- type.addPolarity(Polarity.POSITIVE);
- context.solveSubsumptions(group[0].getExpression().getLocation());
- ArrayList<Constraint> allUnsolvedConstraints = new ArrayList<Constraint>();
-
- @SuppressWarnings("unchecked")
- ArrayList<Variable>[] freeEvidence = new ArrayList[group.length];
- for(int i=0;i<group.length;++i) {
- if(constraintDemands[i] != null) {
- SCLValue value = group[i];
- Expression expression = value.getExpression();
-
- ReducedConstraints red = ConstraintSolver.solve(
- ce, new ArrayList<TPred>(0), constraintDemands[i],
- true /*!Types.isFunction(expression.getType())*/);
-
- expression = ExpressionAugmentation.augmentSolved(
- red.solvedConstraints,
- expression);
- value.setExpression(expression);
- value.setType(expression.getType());
-
- for(Constraint c : red.unsolvedConstraints)
- if(c.constraint.isGround()) {
- errorLog.log(c.getDemandLocation(), "There is no instance for <"+c.constraint+">.");
- }
-
- ArrayList<Variable> fe = new ArrayList<Variable>(red.unsolvedConstraints.size());
- for(Constraint c : red.unsolvedConstraints) {
- allUnsolvedConstraints.add(c);
- fe.add(c.evidence);
- }
- freeEvidence[i] = fe;
- }
- else {
- group[i].setExpression(group[i].getExpression().decomposeMatching());
- freeEvidence[i] = new ArrayList<Variable>(0);
- }
- }
-
- THashSet<TVar> varSet = new THashSet<TVar>();
- for(int i=0;i<group.length;++i) {
- SCLValue value = group[i];
- Type type = value.getType();
- type = type.convertMetaVarsToVars();
- value.setType(type);
- varSet.addAll(Types.freeVars(type));
- }
-
- TVar[] vars = varSet.toArray(new TVar[varSet.size()]);
-
- // Collect all constraints needed in the group
- THashSet<TPred> constraintSet = new THashSet<TPred>();
- for(int i=0;i<group.length;++i) {
- for(Variable evidence : freeEvidence[i]) {
- constraintSet.add((TPred)evidence.getType());
- }
- }
- TPred[] constraints = constraintSet.toArray(new TPred[constraintSet.size()]);
- for(TPred constraint : constraints)
- if(constraint.containsMetaVars()) {
- for(Constraint c : allUnsolvedConstraints) {
- if(Types.equals(c.constraint, constraint)) {
- errorLog.log(c.getDemandLocation(),
- "Constrain " + constraint +
- " contains free variables not mentioned in the type of the value.");
- break;
- }
- }
- }
-
-
- // TODO copy to TypeChecking2 from this onwards
- for(int i=0;i<group.length;++i) {
- // Create evidence array of every value in the group that has the variables
- // in the same array as in the shared array
- ArrayList<Variable> fe = freeEvidence[i];
- THashMap<TPred, Variable> indexedEvidence = new THashMap<TPred, Variable>(fe.size());
- for(Variable v : fe)
- indexedEvidence.put((TPred)v.getType(), v);
- fe.clear();
- for(TPred c : constraints) {
- Variable var = indexedEvidence.get(c);
- if(var == null) {
- // These are variables that are not directly needed in
- // this definition but in the definitions that are
- // recursively called
- var = new Variable("evX");
- var.setType(c);
- fe.add(var);
- }
- fe.add(var);
- }
-
- // Add evidence parameters to the functions
- SCLValue value = group[i];
- value.setExpression(lambda(Types.NO_EFFECTS, fe, value.getExpression())
- .closure(vars));
- value.setType(Types.forAll(vars,
- Types.constrained(constraints, value.getType())));
-
- // Add evidence parameters to recursive calls
- for(EPlaceholder ref : recursiveReferences[i]) {
- ref.expression = loc(ref.expression.location, apply(
- Types.NO_EFFECTS,
- applyTypes(ref.expression, vars),
- vars(fe)));
- }
- }
- }
- }
-
- private void typeCheckValuesWithTypeAnnotations() {
- ArrayList<TPred> givenConstraints = new ArrayList<TPred>();
- for(SCLValue value : valuesWithTypeAnnotation) {
- Type type = value.getType();
- if(type != null) {
- if(PRINT_VALUES) {
- System.out.println("---------------------------------------------");
- System.out.println("--- " + value.getName() + " :: " + type);
- }
- Expression expression = value.getExpression();
- ArrayList<TVar> vars = new ArrayList<TVar>();
- type = Types.removeForAll(type, vars);
- type = Types.removePred(type, givenConstraints);
-
- /*System.out.println("---------------------------------------------");
- TypeUnparsingContext tuc = new TypeUnparsingContext();
- System.out.println("--- " + value.getName() + " :: " + type.toString(tuc));
- for(TPred t : givenConstraints)
- System.out.println(">>> " + t.toString(tuc));
- */
- TypingContext context = new TypingContext(errorLog, environment);
- //System.out.println(expression);
- expression = expression.checkType(context, type);
- //System.out.println(expression);
- expression.getType().addPolarity(Polarity.POSITIVE);
- context.solveSubsumptions(expression.getLocation());
- ArrayList<EVariable> demands = context.getConstraintDemand();
- if(!demands.isEmpty() || !givenConstraints.isEmpty()) {
- ReducedConstraints red =
- ConstraintSolver.solve(ce, givenConstraints, demands, true);
- givenConstraints.clear();
- for(Constraint c : red.unsolvedConstraints) {
- errorLog.log(c.getDemandLocation(),
- "Constraint <"+c.constraint+"> is not given and cannot be derived.");
- }
- if(errorLog.isEmpty()) { // To prevent exceptions
- expression = ExpressionAugmentation.augmentSolved(
- red.solvedConstraints,
- expression);
- expression = ExpressionAugmentation.augmentUnsolved(
- red.givenConstraints,
- expression);
- }
- }
- else {
- if(errorLog.isEmpty()) // To prevent exceptions
- expression = expression.decomposeMatching();
- }
- expression = expression.closure(vars.toArray(new TVar[vars.size()]));
- value.setExpression(expression);
- }
- }
- }
-
- public void typeCheckRules() {
- TypingContext context = new TypingContext(errorLog, environment);
- for(TransformationRule rule : module.getRules()) {
- context.pushEffectUpperBound(rule.location, Types.metaVar(Kinds.EFFECT));
- rule.checkType(context);
- rule.setEffect(Types.canonical(context.popEffectUpperBound()));
- }
- context.solveSubsumptions(Locations.NO_LOCATION);
-
- ArrayList<EVariable> demands = context.getConstraintDemand();
- if(!demands.isEmpty()) {
- ReducedConstraints red =
- ConstraintSolver.solve(ce, new ArrayList<TPred>(), demands, true);
- for(Constraint c : red.unsolvedConstraints) {
- errorLog.log(c.getDemandLocation(),
- "Constraint <"+c.constraint+"> is not given and cannot be derived.");
- }
- }
-
- for(MappingRelation mappingRelation : module.getMappingRelations())
- for(Type parameterType : mappingRelation.parameterTypes)
- if(!parameterType.isGround()) {
- errorLog.log(mappingRelation.location, "Parameter types of the mapping relation are not completely determined.");
- break;
- }
-
- /*for(Rule rule : module.getRules()) {
- System.out.println(rule.name);
- for(Variable variable : rule.variables)
- System.out.println(" " + variable.getName() + " :: " + variable.getType());
- }*/
- }
-}
package org.simantics.scl.compiler.compilation;
-import gnu.trove.impl.Constants;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-import gnu.trove.set.hash.TIntHashSet;
-
import java.util.ArrayList;
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
import org.simantics.scl.compiler.types.TPred;
import org.simantics.scl.compiler.types.TVar;
+import gnu.trove.impl.Constants;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
+
/**
* Schedules the order of type checking.
*
package org.simantics.scl.compiler.compilation;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-import gnu.trove.set.hash.TIntHashSet;
-
import java.util.ArrayList;
import java.util.Collection;
import org.simantics.scl.compiler.types.TPred;
import org.simantics.scl.compiler.types.TVar;
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
+
public interface TypeInferableDefinition {
long getLocation();
Collection<Object> getDefinedObjects();
package org.simantics.scl.compiler.constants;
-import org.simantics.scl.compiler.internal.codegen.utils.LocalVariable;
import org.cojen.classfile.TypeDesc;
+import org.simantics.scl.compiler.internal.codegen.utils.LocalVariable;
import org.simantics.scl.compiler.internal.codegen.utils.MethodBuilder;
import org.simantics.scl.compiler.internal.codegen.utils.TransientClassBuilder;
import org.simantics.scl.compiler.types.Type;
package org.simantics.scl.compiler.constants;
-import org.simantics.scl.compiler.internal.codegen.utils.LocalVariable;
import org.cojen.classfile.TypeDesc;
+import org.simantics.scl.compiler.internal.codegen.utils.LocalVariable;
import org.simantics.scl.compiler.internal.codegen.utils.MethodBuilder;
import org.simantics.scl.compiler.internal.codegen.utils.TransientClassBuilder;
import org.simantics.scl.compiler.types.Type;
package org.simantics.scl.compiler.constants.generic;
-import gnu.trove.map.hash.THashMap;
-
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.simantics.scl.compiler.constants.generic.MethodRef.StaticMethodRef;
import org.simantics.scl.compiler.internal.codegen.utils.MethodBuilderBase;
+import gnu.trove.map.hash.THashMap;
+
/**
* This class is a reference to a Java class that contains a map of MethodRef for each
* method declared by the referenced class.
package org.simantics.scl.compiler.elaboration.contexts;
-import gnu.trove.list.array.TLongArrayList;
-import gnu.trove.map.hash.THashMap;
-
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
import org.simantics.scl.compiler.common.names.Name;
import org.simantics.scl.compiler.constants.Constant;
import org.simantics.scl.compiler.types.exceptions.MatchException;
import org.simantics.scl.compiler.types.util.MultiFunction;
+import gnu.trove.list.array.TLongArrayList;
+import gnu.trove.map.hash.THashMap;
+
public class SimplificationContext implements EnvironmentalContext {
Environment environment;
ErrorLog errorLog;
package org.simantics.scl.compiler.elaboration.contexts;
-import gnu.trove.list.array.TIntArrayList;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.procedure.TObjectProcedure;
-import gnu.trove.set.hash.THashSet;
-
import java.util.ArrayList;
import java.util.Arrays;
import org.simantics.scl.compiler.common.precedence.Associativity;
import org.simantics.scl.compiler.common.precedence.Precedence;
import org.simantics.scl.compiler.elaboration.expressions.Case;
+import org.simantics.scl.compiler.elaboration.expressions.EAmbiguous;
import org.simantics.scl.compiler.elaboration.expressions.EConstant;
import org.simantics.scl.compiler.elaboration.expressions.EEntityTypeAnnotation;
import org.simantics.scl.compiler.elaboration.expressions.EError;
import org.simantics.scl.compiler.errors.ErrorLog;
import org.simantics.scl.compiler.errors.Locations;
import org.simantics.scl.compiler.internal.parsing.declarations.DValueAst;
+import org.simantics.scl.compiler.top.SCLCompilerConfiguration;
+import org.simantics.scl.compiler.types.Type;
+
+import gnu.trove.list.array.TIntArrayList;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.procedure.TObjectProcedure;
+import gnu.trove.set.hash.THashSet;
public class TranslationContext extends TypeTranslationContext implements EnvironmentalContext {
}
private Expression resolveIn(long location, Namespace namespace, String name) {
- SCLValue value = resolveValueIn(location, namespace, name);
+ SCLValue value;
+ try {
+ value = resolveValueIn(location, namespace, name);
+ } catch (AmbiguousNameException e) {
+ if(SCLCompilerConfiguration.ALLOW_OVERLOADING) {
+ EAmbiguous.Alternative[] alternatives = new EAmbiguous.Alternative[e.conflictingModules.length];
+ //System.out.println("Overloading:");
+ for(int i=0;i<e.conflictingModules.length;++i) {
+ Name altName = Name.create(e.conflictingModules[i], e.name);
+ //System.out.println(" " + altName);
+ SCLValue altValue = environment.getValue(altName);
+ alternatives[i] = new EAmbiguous.Alternative() {
+ @Override
+ public Type getType() {
+ return altValue.getType();
+ }
+
+ @Override
+ public Expression realize() {
+ EConstant expression = new EConstant(altValue);
+ expression.location = location;
+ return expression;
+ }
+
+ @Override
+ public String toString() {
+ return altValue.getName().toString().replace('/', '.');
+ }
+ };
+ }
+ EAmbiguous expression = new EAmbiguous(alternatives);
+ expression.location = location;
+ return expression;
+ }
+ else {
+ errorLog.log(location, e.getMessage());
+ value = null;
+ }
+ }
if(value == null)
return new EError(location);
return new EConstant(location, value);
return prec;
}
- private SCLValue resolveValueIn(long location, Namespace namespace, final String name) {
- try {
+ private SCLValue resolveValueIn(long location, Namespace namespace, final String name) throws AmbiguousNameException {
SCLValue value = namespace.getValue(name);
if(value == null) {
StringBuilder message = new StringBuilder();
return null;
}
return value;
- } catch (AmbiguousNameException e) {
- errorLog.log(location, e.getMessage());
- return null;
- }
}
public Case translateCase(Expression lhs, Expression rhs) {
package org.simantics.scl.compiler.elaboration.contexts;
-import gnu.trove.map.hash.THashMap;
-
import org.simantics.scl.compiler.environment.Environment;
import org.simantics.scl.compiler.errors.ErrorLog;
import org.simantics.scl.compiler.internal.parsing.exceptions.SCLSyntaxErrorException;
import org.simantics.scl.compiler.types.kinds.Kind;
import org.simantics.scl.compiler.types.kinds.Kinds;
+import gnu.trove.map.hash.THashMap;
+
public class TypeTranslationContext {
Environment environment;
package org.simantics.scl.compiler.elaboration.contexts;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.set.hash.THashSet;
-
import java.util.ArrayList;
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
import org.simantics.scl.compiler.common.names.Name;
import org.simantics.scl.compiler.constants.NoRepConstant;
+import org.simantics.scl.compiler.elaboration.expressions.EAmbiguous;
import org.simantics.scl.compiler.elaboration.expressions.EApply;
import org.simantics.scl.compiler.elaboration.expressions.EConstant;
import org.simantics.scl.compiler.elaboration.expressions.EError;
import org.simantics.scl.compiler.types.kinds.Kinds;
import org.simantics.scl.compiler.types.util.TypeUnparsingContext;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.set.hash.THashSet;
+
public class TypingContext implements EnvironmentalContext {
private ErrorLog errorLog;
public THashSet<SCLValue> recursiveValues;
public ArrayList<EPlaceholder> recursiveReferences;
+ // Overloading
+ public ArrayList<EAmbiguous> overloadedExpressions = new ArrayList<EAmbiguous>();
+
//TypeUnparsingContext tuc = new TypeUnparsingContext();
Environment environment;
* Instantiates type abstractions and constraints from the value.
*/
public Expression instantiate(Expression expr) {
- Type type = Types.weakCanonical(expr.getType());
+ Type type = Types.canonical(expr.getType());
while(type instanceof TForAll) {
TForAll forAll = (TForAll)type;
TVar var = forAll.var;
* type applications, lambdas and effect subsumptions.
*/
public Expression subsume(Expression expr, Type b) {
- b = Types.weakCanonical(b);
+ b = Types.canonical(b);
/*if(b instanceof TForAll) {
TForAll forAll = (TForAll)b;
TVar var = forAll.var;
\r
@Override\r
public void checkType(TypingContext context) {\r
- guard = guard.inferType(context);\r
+ guard = guard.checkIgnoredType(context);\r
}\r
\r
@Override\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.types.Type;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public abstract class ASTExpression extends SimplifiableExpression {\r
public ASTExpression() {\r
}\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.internal.parsing.Symbol;\r
import org.simantics.scl.compiler.types.Type;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class Case extends Symbol {\r
public Expression[] patterns;\r
public Expression value;\r
patterns[i] = patterns[i].checkTypeAsPattern(context, parameterTypes[i]);\r
value = value.checkType(context, requiredType);\r
}\r
+ \r
+ public void checkIgnoredType(TypingContext context, Type[] parameterTypes) {\r
+ if(patterns.length != parameterTypes.length) {\r
+ context.getErrorLog().log(location, "This case has different arity ("+patterns.length+\r
+ ") than than the first case (+"+parameterTypes.length+"+).");\r
+ return;\r
+ }\r
+ for(int i=0;i<patterns.length;++i)\r
+ patterns[i] = patterns[i].checkTypeAsPattern(context, parameterTypes[i]);\r
+ value = value.checkIgnoredType(context);\r
+ }\r
\r
public void decorate(ExpressionDecorator decorator) {\r
for(int i=0;i<patterns.length;++i)\r
expression = expression.checkBasicType(context, requiredType);
return this;
}
+
+ @Override
+ public Expression checkIgnoredType(TypingContext context) {
+ expression = expression.checkIgnoredType(context);
+ return this;
+ }
}
--- /dev/null
+package org.simantics.scl.compiler.elaboration.expressions;
+
+import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
+import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
+import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
+import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
+import org.simantics.scl.compiler.errors.ErrorLog;
+import org.simantics.scl.compiler.errors.Locations;
+import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;
+import org.simantics.scl.compiler.types.Skeletons;
+import org.simantics.scl.compiler.types.TMetaVar;
+import org.simantics.scl.compiler.types.Type;
+import org.simantics.scl.compiler.types.Types;
+import org.simantics.scl.compiler.types.exceptions.MatchException;
+import org.simantics.scl.compiler.types.exceptions.UnificationException;
+import org.simantics.scl.compiler.types.util.TypeListener;
+import org.simantics.scl.compiler.types.util.TypeUnparsingContext;
+
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
+
+public class EAmbiguous extends SimplifiableExpression {
+ public static final boolean DEBUG = false;
+
+ Alternative[] alternatives;
+ boolean[] active;
+ int activeCount;
+ transient TypingContext context;
+ Expression resolvedExpression;
+
+ public abstract static class Alternative {
+ public abstract Type getType();
+ public abstract Expression realize();
+ }
+
+ public EAmbiguous(Alternative[] alternatives) {
+ this.alternatives = alternatives;
+ this.active = new boolean[alternatives.length];
+ for(int i=0;i<alternatives.length;++i)
+ this.active[i] = true;
+ this.activeCount = alternatives.length;
+ }
+
+ @Override
+ public void collectRefs(TObjectIntHashMap<Object> allRefs,
+ TIntHashSet refs) {
+ }
+
+ @Override
+ public void collectVars(TObjectIntHashMap<Variable> allVars,
+ TIntHashSet vars) {
+ }
+
+ @Override
+ public void forVariables(VariableProcedure procedure) {
+ }
+
+ @Override
+ protected void updateType() throws MatchException {
+ throw new InternalCompilerError();
+ }
+
+ private Type getCommonSkeleton() {
+ Type[] types = new Type[activeCount];
+ for(int i=0,j=0;i<alternatives.length;++i)
+ if(active[i])
+ types[j++] = Types.instantiateAndStrip(alternatives[i].getType());
+ return Skeletons.commonSkeleton(context.getEnvironment(), types);
+ }
+
+ private void filterActive() {
+ THashMap<TMetaVar,Type> unifications = new THashMap<TMetaVar,Type>();
+ Type requiredType = getType();
+ if(DEBUG)
+ System.out.println("EAmbigious.filterActive with " + requiredType);
+ for(int i=0;i<alternatives.length;++i)
+ if(active[i]) {
+ unifications.clear();
+ Type alternativeType = Types.instantiateAndStrip(alternatives[i].getType());
+ if(DEBUG)
+ System.out.println(" " + alternativeType);
+ if(!Skeletons.areSkeletonsCompatible(unifications, alternativeType, requiredType)) {
+ active[i] = false;
+ --activeCount;
+ }
+ }
+ if(DEBUG)
+ System.out.println(" activeCount = " + activeCount);
+ }
+
+ private String getNoMatchDescription(Type requiredType) {
+ StringBuilder b = new StringBuilder();
+ b.append("Expected <");
+ requiredType.toString(new TypeUnparsingContext(), b);
+ b.append(">, but no alteratives match the type: ");
+ for(int i=0;i<alternatives.length;++i) {
+ b.append("\n ");
+ b.append(alternatives[i]);
+ b.append(" :: ");
+ alternatives[i].getType().toString(new TypeUnparsingContext(), b);
+ }
+ b.append('.');
+ return b.toString();
+ }
+
+ private String getAmbiguousDescription(Type requiredType) {
+ StringBuilder b = new StringBuilder();
+ b.append("Expected <");
+ requiredType.toString(new TypeUnparsingContext(), b);
+ b.append(">, but multiple values match the type: ");
+ for(int i=0;i<alternatives.length;++i) {
+ b.append("\n ");
+ b.append(alternatives[i]);
+ b.append(" :: ");
+ alternatives[i].getType().toString(new TypeUnparsingContext(), b);
+ }
+ b.append('.');
+ return b.toString();
+ }
+
+
+ private void resolveTo(int i) {
+ if(DEBUG)
+ System.out.println("EAmbigious.resolve to " + alternatives[i]);
+ resolvedExpression = context.instantiate(alternatives[i].realize());
+ Type requiredType = getType();
+ try {
+ Types.unify(resolvedExpression.getType(), requiredType);
+ } catch (UnificationException e) {
+ context.getErrorLog().log(location, getNoMatchDescription(requiredType));
+ }
+ }
+
+ private void listenType() {
+ if(DEBUG)
+ System.out.println("EAmbigious.listenType " + getType());
+ new TypeListener() {
+ @Override
+ public void notifyAboutChange() {
+ if(DEBUG)
+ System.out.println("EAmbigious.notifyAboutChange " + getType());
+ Type requiredType = getType();
+ filterActive();
+ if(activeCount == 0) {
+ context.getErrorLog().log(location, getNoMatchDescription(requiredType));
+ return;
+ }
+ else if(activeCount == 1) {
+ for(int i=0;i<alternatives.length;++i)
+ if(active[i]) {
+ resolveTo(i);
+ return;
+ }
+ }
+ Type commonType = getCommonSkeleton();
+ try {
+ Skeletons.unifySkeletons(requiredType, commonType);
+ listenType();
+ } catch (UnificationException e) {
+ context.getErrorLog().log(location, getNoMatchDescription(requiredType));
+ }
+ }
+ }.listenSkeleton(getType());
+ }
+
+ @Override
+ public Expression inferType(TypingContext context) {
+ this.context = context;
+ context.overloadedExpressions.add(this);
+ setType(getCommonSkeleton());
+ listenType();
+ return this;
+ }
+
+ @Override
+ public void collectFreeVariables(THashSet<Variable> vars) {
+ }
+
+ @Override
+ public Expression resolve(TranslationContext context) {
+ throw new InternalCompilerError("EAmbiguousConstant should not exist in resolve phase.");
+ }
+
+ @Override
+ public void setLocationDeep(long loc) {
+ if(location == Locations.NO_LOCATION)
+ location = loc;
+ }
+
+ @Override
+ public Expression decorate(ExpressionDecorator decorator) {
+ return this;
+ }
+
+ @Override
+ public void collectEffects(THashSet<Type> effects) {
+ // TODO Auto-generated method stub
+ }
+
+ @Override
+ public void accept(ExpressionVisitor visitor) {
+ // TODO Auto-generated method stub
+ }
+
+ @Override
+ public Expression simplify(SimplificationContext context) {
+ if(resolvedExpression != null)
+ return resolvedExpression;
+ else {
+ context.getErrorLog().log(location, getAmbiguousDescription(getType()));
+ return this;
+ }
+ }
+
+ public void assertResolved(ErrorLog errorLog) {
+ if(resolvedExpression == null)
+ errorLog.log(location, getAmbiguousDescription(getType()));
+ }
+
+ @Override
+ public Expression accept(ExpressionTransformer transformer) {
+ return transformer.transform(this);
+ }
+
+}
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
\r
import org.simantics.scl.compiler.common.names.Name;\r
+import org.simantics.scl.compiler.constants.NoRepConstant;\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.internal.interpreted.IExpression;\r
import org.simantics.scl.compiler.internal.interpreted.IListLiteral;\r
import org.simantics.scl.compiler.top.ExpressionInterpretationContext;\r
+import org.simantics.scl.compiler.types.Skeletons;\r
+import org.simantics.scl.compiler.types.TFun;\r
import org.simantics.scl.compiler.types.Type;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
import org.simantics.scl.compiler.types.util.MultiFunction;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EApply extends Expression {\r
Expression function;\r
Expression[] parameters;\r
return new IApply(function.toIExpression(target), parametersI);\r
}\r
\r
- @Override\r
- public Expression inferType(TypingContext context) {\r
+ private void inferType(TypingContext context, boolean ignoreResult) {\r
function = function.inferType(context);\r
function = context.instantiate(function);\r
MultiFunction mfun;\r
setType(Types.metaVar(Kinds.STAR));\r
for(int i=0;i<parameters.length;++i)\r
parameters[i] = parameters[i].inferType(context);\r
- return this;\r
+ return;\r
+ }\r
+ if((ignoreResult && Skeletons.canonicalSkeleton(mfun.returnType) instanceof TFun &&\r
+ Types.canonical(mfun.effect) == Types.NO_EFFECTS) ||\r
+ (context.isInPattern() && Skeletons.canonicalSkeleton(mfun.returnType) instanceof TFun)) {\r
+ context.getErrorLog().log(location, "The function is applied with too few parameters.");\r
}\r
\r
// Check parameter types\r
\r
context.declareEffect(location, mfun.effect);\r
setType(mfun.returnType);\r
-\r
+ }\r
+ \r
+ @Override\r
+ public Expression inferType(TypingContext context) {\r
+ inferType(context, false);\r
+ return this;\r
+ }\r
+ \r
+ @Override\r
+ public Expression checkIgnoredType(TypingContext context) {\r
+ inferType(context, true);\r
+ if(Types.canonical(getType()) != Types.UNIT)\r
+ return new ESimpleLet(location, null, this, new ELiteral(NoRepConstant.PUNIT));\r
return this;\r
}\r
\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EApplyType extends Expression { \r
Expression expression;\r
Type parameter;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.types.Type;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EAsPattern extends Expression {\r
\r
Variable var;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.types.exceptions.UnificationException;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EBind extends SimplifiableExpression {\r
public Expression pattern;\r
public Expression value;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
\r
import org.simantics.scl.compiler.common.names.Name;\r
import org.simantics.scl.compiler.types.util.MultiFunction;\r
import org.simantics.scl.compiler.types.util.TypeUnparsingContext;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EConstant extends Expression {\r
SCLValue value;\r
Type[] typeParameters;\r
return this;\r
}\r
else\r
- return this;\r
+ return applyPUnit(context);\r
}\r
\r
@Override\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EEnforce extends SimplifiableExpression {\r
\r
Query query;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import static org.simantics.scl.compiler.elaboration.expressions.Expressions.*;\r
-import gnu.trove.map.hash.THashMap;\r
+import static org.simantics.scl.compiler.elaboration.expressions.Expressions.loc;\r
\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.java.EqRelation;\r
import org.simantics.scl.compiler.errors.Locations;\r
import org.simantics.scl.compiler.internal.parsing.Token;\r
\r
+import gnu.trove.map.hash.THashMap;\r
+\r
public class EEntityTypeAnnotation extends ASTExpression {\r
\r
Expression expression;\r
return this;\r
}\r
\r
+ @Override\r
+ public Expression checkIgnoredType(TypingContext context) {\r
+ return inferType(context);\r
+ }\r
+\r
@Override\r
public Expression simplify(SimplificationContext context) {\r
context.getErrorLog().log(location, "Equations should be transformed into other expressions before simplification phase.");\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EError extends Expression {\r
\r
public EError(long loc, Type type) {\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
import org.simantics.scl.compiler.types.util.TypeUnparsingContext;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EExternalConstant extends Expression {\r
Object value;\r
\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.common.names.Name;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EFieldAccess extends SimplifiableExpression {\r
\r
private static final Type VARIABLE = Types.con("Simantics/Variables", "Variable");\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.types.Type;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EGetConstraint extends SimplifiableExpression {\r
TPred constraint;\r
EVariable evidence;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EIf extends Expression {\r
public Expression condition;\r
public Expression then_;\r
return this;\r
}\r
\r
+ @Override\r
+ public Expression checkIgnoredType(TypingContext context) {\r
+ condition = condition.checkType(context, Types.BOOLEAN);\r
+ then_ = then_.checkIgnoredType(context);\r
+ else_ = else_.checkIgnoredType(context);\r
+ return this;\r
+ }\r
+ \r
@Override\r
public Expression decorate(ExpressionDecorator decorator) {\r
condition = condition.decorate(decorator);\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.constants.DoubleConstant;\r
import org.simantics.scl.compiler.constants.FloatConstant;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EIntegerLiteral extends SimplifiableExpression {\r
public String value;\r
EVariable constraint;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
import org.simantics.scl.compiler.types.util.MultiFunction;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ELambda extends SimplifiableExpression {\r
public Case[] cases;\r
Type effect = Types.NO_EFFECTS;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ELambdaType extends Expression {\r
public TVar[] parameters;\r
public Expression value;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ELet extends Expression {\r
public Assignment[] assignments;\r
public Expression in;\r
in = in.checkType(context, requiredType);\r
return this;\r
}\r
+ \r
+ @Override\r
+ public Expression checkIgnoredType(TypingContext context) {\r
+ checkAssignments(context);\r
+ in = in.checkIgnoredType(context);\r
+ return this;\r
+ }\r
\r
@Override\r
public Expression decorate(ExpressionDecorator decorator) {\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EListComprehension extends SimplifiableExpression {\r
\r
public Expression head;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EListLiteral extends SimplifiableExpression {\r
\r
Expression[] components;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
\r
import org.simantics.scl.compiler.constants.Constant;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
import org.simantics.scl.compiler.types.util.TypeUnparsingContext;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ELiteral extends Expression {\r
Constant value;\r
\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.environment.Environment;\r
import org.simantics.scl.compiler.errors.Locations;\r
import org.simantics.scl.compiler.internal.codegen.references.IVal;\r
+import org.simantics.scl.compiler.internal.codegen.ssa.exits.Throw;\r
import org.simantics.scl.compiler.internal.codegen.writer.CodeWriter;\r
import org.simantics.scl.compiler.internal.elaboration.matching.PatternMatchingCompiler;\r
import org.simantics.scl.compiler.internal.elaboration.matching.Row;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EMatch extends Expression {\r
\r
public Expression[] scrutinee;\r
CodeWriter joinPoint = w.createBlock(getType());\r
CodeWriter failurePoint = w.createBlock(); // TODO generate only one failurePoint per function\r
PatternMatchingCompiler.split(w, env, scrutineeVals, joinPoint.getContinuation(), failurePoint.getContinuation(), rows);\r
- failurePoint.throw_(location, "Matching failure at: " + toString());\r
+ failurePoint.throw_(location, Throw.MatchingException, "Matching failure at: " + toString());\r
w.continueAs(joinPoint);\r
return w.getParameters()[0];\r
}\r
setType(requiredType);\r
return this;\r
}\r
+ \r
+ @Override\r
+ public Expression checkIgnoredType(TypingContext context) {\r
+ Type[] scrutineeTypes = new Type[scrutinee.length];\r
+ for(int i=0;i<scrutinee.length;++i) {\r
+ scrutinee[i] = scrutinee[i].checkType(context, Types.metaVar(Kinds.STAR));\r
+ scrutineeTypes[i] = scrutinee[i].getType();\r
+ }\r
+ for(Case case_ : cases)\r
+ case_.checkIgnoredType(context, scrutineeTypes);\r
+ setType(Types.UNIT);\r
+ return this;\r
+ }\r
\r
@Override\r
public Expression decorate(ExpressionDecorator decorator) {\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.THashMap;\r
-import gnu.trove.procedure.TObjectObjectProcedure;\r
-\r
import java.util.ArrayList;\r
import java.util.List;\r
\r
import org.simantics.scl.compiler.elaboration.expressions.lhstype.LhsType;\r
import org.simantics.scl.compiler.errors.Locations;\r
\r
+import gnu.trove.map.hash.THashMap;\r
+import gnu.trove.procedure.TObjectObjectProcedure;\r
+\r
public class EPreLet extends ASTExpression {\r
\r
List<LetStatement> assignments;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.THashMap;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.expressions.ERuleset.DatalogRule;\r
import org.simantics.scl.compiler.elaboration.expressions.block.RuleStatement;\r
import org.simantics.scl.compiler.elaboration.relations.LocalRelation;\r
import org.simantics.scl.compiler.errors.Locations;\r
\r
+import gnu.trove.map.hash.THashMap;\r
+\r
public class EPreRuleset extends ASTExpression {\r
\r
RuleStatement[] statements;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.constants.DoubleConstant;\r
import org.simantics.scl.compiler.constants.FloatConstant;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ERealLiteral extends SimplifiableExpression {\r
public String value;\r
EVariable constraint;\r
return new EError(constructor.location);
}
THashMap<String,FieldAssignment> recordMap = new THashMap<String,FieldAssignment>(fields.length);
- for(FieldAssignment field : fields)
- recordMap.put(field.name, field);
+ for(FieldAssignment field : fields) {
+ if(field.value == null) {
+ String bestMatch = null;
+ int bestMatchLength = 0;
+ for(int i=0;i<fieldNames.length;++i) {
+ String fieldName = fieldNames[i];
+ if(field.name.startsWith(fieldName) && fieldName.length() > bestMatchLength) {
+ bestMatch = fieldName;
+ bestMatchLength = fieldName.length();
+ }
+ }
+ if(bestMatch == null) {
+ context.getErrorLog().log(field.location, "Invalid shorthand field " + field.name + " is defined twice.");
+ return new EError(location);
+ }
+ field.value = new EVar(field.location, field.name);
+ field.name = bestMatch;
+ }
+ if(recordMap.put(field.name, field) != null) {
+ context.getErrorLog().log(field.location, "Field " + field.name + " is defined more than once.");
+ return new EError(location);
+ }
+ }
Expression[] parameters = new Expression[fieldNames.length];
boolean error = false;
for(int i=0;i<fieldNames.length;++i) {
if(location == Locations.NO_LOCATION) {
location = loc;
for(FieldAssignment field : fields)
- field.value.setLocationDeep(loc);
+ if(field.value != null)
+ field.value.setLocationDeep(loc);
}
}
return compile(context);\r
}\r
\r
+ @Override\r
+ public Expression checkIgnoredType(TypingContext context) {\r
+ checkRuleTypes(context);\r
+ in = in.checkIgnoredType(context);\r
+ return compile(context);\r
+ }\r
+ \r
@Override\r
public void collectFreeVariables(THashSet<Variable> vars) {\r
for(DatalogRule rule : rules) {\r
import static org.simantics.scl.compiler.elaboration.expressions.Expressions.seq;\r
import static org.simantics.scl.compiler.elaboration.expressions.Expressions.tuple;\r
import static org.simantics.scl.compiler.elaboration.expressions.Expressions.var;\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.common.names.Name;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ESelect extends SimplifiableExpression {\r
\r
private final Type ARRAY_LIST = Types.con("ArrayList", "T"); \r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
import org.simantics.scl.compiler.types.util.MultiFunction;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ESimpleLambda extends Expression {\r
public Variable parameter;\r
public Expression value;\r
\r
private void checkBinding(TypingContext context) {\r
if(variable == null)\r
- value = value.inferType(context);\r
+ value = value.checkIgnoredType(context);\r
else if(variable.getType() == null) {\r
value = value.inferType(context);\r
variable.setType(value.getType());\r
in = in.checkType(context, requiredType);\r
return this;\r
}\r
+ \r
+ @Override\r
+ public Expression checkIgnoredType(TypingContext context) {\r
+ checkBinding(context);\r
+ in = in.checkIgnoredType(context);\r
+ return this;\r
+ }\r
\r
@Override\r
public Expression decorate(ExpressionDecorator decorator) {\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
import java.util.Collections;\r
import java.util.Comparator;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ETransformation extends SimplifiableExpression {\r
public static final Object TRANSFORMATION_RULES_TYPECHECKED = new Object();\r
\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.types.Type;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ETypeAnnotation extends SimplifiableExpression {\r
Expression value;\r
Type type;\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
import org.simantics.scl.compiler.types.util.TypeUnparsingContext;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EVariable extends Expression {\r
public static final EVariable[] EMPTY_ARRAY = new EVariable[0];\r
\r
\r
@Override\r
public Expression inferType(TypingContext context) {\r
- if(context.isInPattern())\r
+ if(context.isInPattern()) {\r
variable.setType(Types.metaVar(Kinds.STAR));\r
- return this;\r
+ return this;\r
+ }\r
+ else\r
+ return applyPUnit(context);\r
}\r
\r
@Override\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.types.exceptions.UnificationException;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class EWhen extends SimplifiableExpression {\r
\r
public Query query;\r
for(Variable variable : variables)\r
variable.setType(Types.metaVar(Kinds.STAR));\r
query.checkType(context);\r
- action.checkType(context, Types.UNIT);\r
+ action.checkIgnoredType(context);\r
\r
// Compile query\r
return compile(context);\r
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.common.precedence.Precedence;\r
+import org.simantics.scl.compiler.constants.NoRepConstant;\r
+import org.simantics.scl.compiler.elaboration.contexts.EnvironmentalContext;\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
import org.simantics.scl.compiler.types.util.Typed;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public abstract class Expression extends Symbol implements Typed {\r
public static final Expression[] EMPTY_ARRAY = new Expression[0];\r
\r
public Expression inferType(TypingContext context) {\r
return checkBasicType(context, Types.metaVar(Kinds.STAR));\r
}\r
- \r
- public Expression checkBasicType(TypingContext context, Type requiredType) {\r
- return context.subsume(inferType(context), requiredType);\r
- }\r
+\r
+ public Expression checkBasicType(TypingContext context, Type requiredType) {\r
+ return context.subsume(inferType(context), requiredType);\r
+ }\r
+ \r
+ protected Expression applyPUnit(EnvironmentalContext context) {\r
+ Type type = Types.canonical(getType());\r
+ if(type instanceof TFun) {\r
+ TFun fun = (TFun)type;\r
+ if(fun.getCanonicalDomain() == Types.PUNIT) {\r
+ EApply result = new EApply(location, this, new ELiteral(NoRepConstant.PUNIT));\r
+ result.effect = fun.getCanonicalEffect();\r
+ return result;\r
+ }\r
+ }\r
+ return this;\r
+ }\r
+\r
+ public Expression checkIgnoredType(TypingContext context) {\r
+ Expression expression = inferType(context);\r
+ if(Types.canonical(expression.getType()) != Types.UNIT)\r
+ expression = new ESimpleLet(location, null, expression, new ELiteral(NoRepConstant.PUNIT));\r
+ return expression;\r
+ }\r
\r
/**\r
* Checks the type of the expression against the given type. Adds type\r
public final Expression checkType(TypingContext context, Type requiredType) {\r
//System.out.println("checkType: " + this + " :: " + requiredType);\r
if(!context.isInPattern()) {\r
- requiredType = Types.weakCanonical(requiredType);\r
+ requiredType = Types.canonical(requiredType);\r
if(requiredType instanceof TForAll) {\r
TForAll forAll = (TForAll)requiredType;\r
TVar var = forAll.var;\r
public interface ExpressionTransformer {
+ Expression transform(EAmbiguous expression);
Expression transform(EApply expression);
Expression transform(EApplyType expression);
Expression transform(EAsPattern expression);
package org.simantics.scl.compiler.elaboration.expressions;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
-import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.errors.Locations;\r
import org.simantics.scl.compiler.internal.codegen.continuations.ICont;\r
import org.simantics.scl.compiler.internal.codegen.references.IVal;\r
+import org.simantics.scl.compiler.internal.codegen.ssa.exits.Throw;\r
import org.simantics.scl.compiler.internal.codegen.writer.CodeWriter;\r
import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;\r
import org.simantics.scl.compiler.types.Type;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.exceptions.MatchException;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class GuardedExpressionGroup extends Expression {\r
public GuardedExpression[] expressions;\r
\r
CodeWriter failure = w.createBlock();\r
compile(env, w, success.getContinuation(), failure.getContinuation());\r
w.continueAs(success);\r
- failure.throw_(location, "Matching failure at: " + toString());\r
+ failure.throw_(location, Throw.MatchingException, "Matching failure at: " + toString());\r
return result;\r
//throw new InternalCompilerError("GuardedExpressionGroup should be handled in match compilation.");\r
}\r
ExpressionTransformer, QueryTransformer, ListQualifierTransformer, StatementVisitor,
EquationVisitor {
+ @Override
+ public Expression transform(EAmbiguous expression) {
+ return expression;
+ }
+
@Override
public Expression transform(EApply expression) {
expression.function = expression.function.accept(this);
package org.simantics.scl.compiler.elaboration.expressions.accessor;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;\r
import org.simantics.scl.compiler.types.Types;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ExpressionAccessor extends FieldAccessor {\r
public Expression fieldName;\r
\r
package org.simantics.scl.compiler.elaboration.expressions.accessor;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;\r
import org.simantics.scl.compiler.internal.parsing.Symbol;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public abstract class FieldAccessor extends Symbol {\r
public char accessSeparator;\r
\r
\r
@Override\r
public Expression toExpression(EnvironmentalContext context, boolean monadic, Expression in) {\r
- Variable var = new Variable("_");\r
- if(monadic)\r
+ if(monadic) {\r
+ Variable var = new Variable("_");\r
return new EBind(location, new EVariable(location, var), value, in);\r
+ }\r
else\r
- return new ESimpleLet(location, var, value, in);\r
+ return new ESimpleLet(location, null, value, in);\r
}\r
\r
@Override\r
package org.simantics.scl.compiler.elaboration.expressions.list;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;\r
import org.simantics.scl.compiler.types.Type;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ListAssignment extends ListQualifier {\r
public Expression pattern;\r
public Expression value;\r
package org.simantics.scl.compiler.elaboration.expressions.list;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ListGenerator extends ListQualifier {\r
public Expression pattern;\r
public Expression value;\r
package org.simantics.scl.compiler.elaboration.expressions.list;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.types.Type;\r
import org.simantics.scl.compiler.types.Types;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ListGuard extends ListQualifier {\r
public Expression condition;\r
\r
package org.simantics.scl.compiler.elaboration.expressions.list;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.internal.parsing.Symbol;\r
import org.simantics.scl.compiler.types.Type;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public abstract class ListQualifier extends Symbol {\r
\r
public abstract void checkType(TypingContext context);\r
package org.simantics.scl.compiler.elaboration.expressions.list;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;\r
import org.simantics.scl.compiler.types.Type;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ListSeq extends ListQualifier {\r
public ListQualifier a;\r
public ListQualifier b;\r
package org.simantics.scl.compiler.elaboration.expressions.list;\r
\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
import org.simantics.scl.compiler.types.exceptions.UnificationException;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+import gnu.trove.set.hash.THashSet;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ListThen extends ListQualifier {\r
public ListQualifier left;\r
public Expression transformer;\r
import org.simantics.scl.compiler.elaboration.expressions.EAsPattern;\r
import org.simantics.scl.compiler.elaboration.expressions.EBind;\r
import org.simantics.scl.compiler.elaboration.expressions.EConstant;\r
+import org.simantics.scl.compiler.elaboration.expressions.ECoveringBranchPoint;\r
import org.simantics.scl.compiler.elaboration.expressions.EEnforce;\r
import org.simantics.scl.compiler.elaboration.expressions.EEquations;\r
import org.simantics.scl.compiler.elaboration.expressions.EError;\r
import org.simantics.scl.compiler.elaboration.expressions.ELiteral;\r
import org.simantics.scl.compiler.elaboration.expressions.EMatch;\r
import org.simantics.scl.compiler.elaboration.expressions.EPlaceholder;\r
-import org.simantics.scl.compiler.elaboration.expressions.ECoveringBranchPoint;\r
import org.simantics.scl.compiler.elaboration.expressions.ERealLiteral;\r
import org.simantics.scl.compiler.elaboration.expressions.ERuleset;\r
import org.simantics.scl.compiler.elaboration.expressions.ESelect;\r
ESimpleLet let = (ESimpleLet)expression;\r
Variable variable = let.getVariable();\r
Expression value = let.getValue();\r
- if("_".equals(variable.getName()))\r
+ if(variable == null || "_".equals(variable.getName()))\r
printAsDo(value);\r
else {\r
newLine();\r
package org.simantics.scl.compiler.elaboration.java;
-import static org.simantics.scl.compiler.elaboration.expressions.Expressions.*;
+import static org.simantics.scl.compiler.elaboration.expressions.Expressions.apply;
+import static org.simantics.scl.compiler.elaboration.expressions.Expressions.constant;
+import static org.simantics.scl.compiler.elaboration.expressions.Expressions.string;
+import static org.simantics.scl.compiler.elaboration.expressions.Expressions.var;
import org.cojen.classfile.TypeDesc;
import org.simantics.scl.compiler.constants.generic.CallJava;
package org.simantics.scl.compiler.elaboration.macros;
-import gnu.trove.map.hash.THashMap;
-
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;
import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
import org.simantics.scl.compiler.elaboration.expressions.EApply;
import org.simantics.scl.compiler.types.TVar;
import org.simantics.scl.compiler.types.Type;
+import gnu.trove.map.hash.THashMap;
+
/**
* This is a macro rule that replaces an application with
* the definition of the function.
package org.simantics.scl.compiler.elaboration.modules;\r
\r
-import gnu.trove.map.hash.THashMap;\r
-\r
import java.util.ArrayList;\r
\r
import org.cojen.classfile.TypeDesc;\r
import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.kinds.Kinds;\r
\r
+import gnu.trove.map.hash.THashMap;\r
+\r
public class TypeClass extends TypeConstructor {\r
public final TPred[] context;\r
public final TCon name;\r
package org.simantics.scl.compiler.elaboration.modules;\r
\r
-import gnu.trove.map.hash.THashMap;\r
-\r
import org.simantics.scl.compiler.constants.Constant;\r
import org.simantics.scl.compiler.elaboration.errors.ElabNode;\r
import org.simantics.scl.compiler.types.TPred;\r
import org.simantics.scl.compiler.types.TVar;\r
\r
+import gnu.trove.map.hash.THashMap;\r
+\r
public class TypeClassInstance extends ElabNode {\r
public final TypeClass typeClass;\r
public final TPred[] context; \r
package org.simantics.scl.compiler.elaboration.query;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-import gnu.trove.set.hash.TIntHashSet;
-
import java.util.Arrays;
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
import org.simantics.scl.compiler.elaboration.query.pre.QPreExists;
import org.simantics.scl.compiler.elaboration.query.pre.QPreGuard;
import org.simantics.scl.compiler.errors.Locations;
-import org.simantics.scl.compiler.types.Type;
+
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
public abstract class QAbstractCombiner extends Query {
public Query[] queries;
package org.simantics.scl.compiler.elaboration.query;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-import gnu.trove.set.hash.TIntHashSet;
-
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
import org.simantics.scl.compiler.elaboration.expressions.Variable;
import org.simantics.scl.compiler.elaboration.expressions.VariableProcedure;
import org.simantics.scl.compiler.errors.Locations;
-import org.simantics.scl.compiler.types.Type;
+
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
public abstract class QAbstractModifier extends Query {
public Query query;
package org.simantics.scl.compiler.elaboration.query;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.map.hash.TIntObjectHashMap;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-import gnu.trove.set.hash.TIntHashSet;
-
import java.util.ArrayList;
import java.util.Set;
import org.simantics.scl.compiler.types.Type;
import org.simantics.scl.compiler.types.Types;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TIntObjectHashMap;
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
+
public class QAtom extends Query {
public SCLRelation relation;
public Type[] typeParameters;
public Expression[] parameters;
-
+
public QAtom(SCLRelation relation, Expression ... parameters) {
this.relation = relation;
this.parameters = parameters;
}
-
+
public QAtom(SCLRelation relation, Type[] typeParameters, Expression ... parameters) {
this.relation = relation;
this.typeParameters = typeParameters;
for(Expression parameter : parameters)
parameter.collectFreeVariables(vars);
}
-
+
@Override
public void checkType(TypingContext context) {
// Type parameters
typeParameters = new Type[typeVariables.length];
for(int i=0;i<typeVariables.length;++i)
typeParameters[i] = Types.metaVar(typeVariables[i].getKind());
-
+
// Check parameter types
Type[] parameterTypes = relation.getParameterTypes();
if(parameterTypes.length != parameters.length)
parameters[i] = parameters[i]
.checkType(context, parameterTypes[i].replace(typeVariables, typeParameters));
}
-
+
public Expression generateEnforce(EnforcingContext context) {
Variable[] variables = new Variable[parameters.length];
for(int i=0;i<variables.length;++i)
private static class VariableMaskProcedure implements VariableProcedure {
ConstraintCollectionContext context;
long requiredVariablesMask = 0L;
-
+
public VariableMaskProcedure(ConstraintCollectionContext context) {
this.context = context;
}
requiredVariablesMask |= 1L << id;
}
}
-
+
@Override
public void collectConstraints(ConstraintCollectionContext context) {
try {
}
}
}
-
+
// Combine required and optional variables
TIntHashSet allVariablesSet = new TIntHashSet();
for(int v : optionalVariableByParameter)
if(v >= 0)
allVariablesSet.add(v);
-
+
context.addConstraint(new RelationConstraint(allVariablesSet.toArray(), varParameters, this,
optionalVariableByParameter, procedure.requiredVariablesMask));
} catch(Exception e) {
context.getQueryCompilationContext().getTypingContext().getErrorLog().log(location, e);
}
}
-
+
private static void collectRefs(SCLRelation relation, TObjectIntHashMap<Object> allRefs,
TIntHashSet refs) {
if(relation instanceof CompositeRelation) {
for(Expression parameter : parameters)
parameter.collectRefs(allRefs, refs);
}
-
+
@Override
public void collectVars(TObjectIntHashMap<Variable> allVars,
TIntHashSet vars) {
return new Diff[] { new Diff(diffable.id, new QConjunction(eqs)) };
}
}
-
+
private static boolean containsReferenceTo(
CompositeRelation relation,
THashMap<SCLRelation, Diffable> diffables) {
else
return this;
}
-
+
@Override
public void setLocationDeep(long loc) {
if(location == Locations.NO_LOCATION) {
parameter.setLocationDeep(loc);
}
}
-
+
@Override
public void accept(QueryVisitor visitor) {
visitor.visit(this);
}
list.add(this);
}
-
+
@Override
public Query accept(QueryTransformer transformer) {
return transformer.transform(this);
package org.simantics.scl.compiler.elaboration.query;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.map.hash.TIntObjectHashMap;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.Set;
import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
import org.simantics.scl.compiler.types.Types;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TIntObjectHashMap;
+
public class QConjunction extends QAbstractCombiner {
package org.simantics.scl.compiler.elaboration.query;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.map.hash.TLongObjectHashMap;
-import gnu.trove.set.hash.TIntHashSet;
-
import java.util.ArrayList;
import java.util.Set;
import org.simantics.scl.compiler.errors.Locations;
import org.simantics.scl.compiler.types.Types;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TLongObjectHashMap;
+import gnu.trove.set.hash.TIntHashSet;
+
public class QDisjunction extends QAbstractCombiner {
package org.simantics.scl.compiler.elaboration.query;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.set.hash.THashSet;
-
import java.util.Collection;
import java.util.Set;
import org.simantics.scl.compiler.types.Types;
import org.simantics.scl.compiler.types.kinds.Kinds;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.set.hash.THashSet;
+
public class QExists extends QAbstractModifier {
Variable[] variables;
package org.simantics.scl.compiler.elaboration.query;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-import gnu.trove.set.hash.TIntHashSet;
-
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
import org.simantics.scl.compiler.errors.Locations;
import org.simantics.scl.compiler.types.Type;
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
+
public class QMapping extends Query {
public final MappingRelation mappingRelation;
public final Expression[] parameters;
package org.simantics.scl.compiler.elaboration.query;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.set.hash.TIntHashSet;
-
import org.simantics.scl.compiler.common.names.Name;
import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;
import org.simantics.scl.compiler.elaboration.expressions.EApply;
import org.simantics.scl.compiler.elaboration.relations.LocalRelation;
import org.simantics.scl.compiler.types.Type;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.set.hash.TIntHashSet;
+
public class QNegation extends QAbstractModifier {
package org.simantics.scl.compiler.elaboration.query;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.map.hash.TIntObjectHashMap;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-import gnu.trove.set.hash.TIntHashSet;
-
import java.util.ArrayList;
import java.util.Set;
import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
import org.simantics.scl.compiler.internal.parsing.Symbol;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TIntObjectHashMap;
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
+
public abstract class Query extends Symbol {
public static final Query[] EMPTY_ARRAY = new Query[0];
package org.simantics.scl.compiler.elaboration.query.compilation;
-import gnu.trove.impl.Constants;
-import gnu.trove.map.hash.TObjectIntHashMap;
-
import java.util.ArrayList;
import org.simantics.scl.compiler.elaboration.expressions.Variable;
+import gnu.trove.impl.Constants;
+import gnu.trove.map.hash.TObjectIntHashMap;
+
public class ConstraintCollectionContext {
QueryCompilationContext context;
ArrayList<Variable> variables = new ArrayList<Variable>();
package org.simantics.scl.compiler.elaboration.query.compilation;
-import gnu.trove.map.hash.TLongObjectHashMap;
-import gnu.trove.procedure.TLongObjectProcedure;
-
import java.util.ArrayList;
import java.util.Collections;
+import gnu.trove.map.hash.TLongObjectHashMap;
+import gnu.trove.procedure.TLongObjectProcedure;
+
public class DynamicProgrammingOrdering {
final ConstraintCollectionContext collectionContext;
int variableCount;
package org.simantics.scl.compiler.elaboration.query.compilation;\r
\r
-import gnu.trove.map.hash.THashMap;\r
-import gnu.trove.procedure.TObjectObjectProcedure;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
import java.util.ArrayList;\r
\r
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
import org.simantics.scl.compiler.types.TVar;\r
import org.simantics.scl.compiler.types.Type;\r
\r
+import gnu.trove.map.hash.THashMap;\r
+import gnu.trove.procedure.TObjectObjectProcedure;\r
+import gnu.trove.set.hash.TIntHashSet;\r
+\r
public class ExpressionConstraint extends QueryConstraint {\r
Variable variable;\r
Expression expression;\r
package org.simantics.scl.compiler.elaboration.query.pre;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-import gnu.trove.set.hash.TIntHashSet;
-
import java.util.ArrayList;
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
import org.simantics.scl.compiler.elaboration.query.Query;
import org.simantics.scl.compiler.elaboration.query.QueryVisitor;
import org.simantics.scl.compiler.elaboration.query.compilation.ConstraintCollectionContext;
-import org.simantics.scl.compiler.types.Type;
+
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
/**
* Query classes that may exist before resolving
package org.simantics.scl.compiler.elaboration.relations;
-import static org.simantics.scl.compiler.elaboration.expressions.Expressions.*;
+import static org.simantics.scl.compiler.elaboration.expressions.Expressions.apply;
+import static org.simantics.scl.compiler.elaboration.expressions.Expressions.newVar;
+import static org.simantics.scl.compiler.elaboration.expressions.Expressions.tuple;
+import static org.simantics.scl.compiler.elaboration.expressions.Expressions.var;
+import static org.simantics.scl.compiler.elaboration.expressions.Expressions.vars;
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
import org.simantics.scl.compiler.common.names.Name;
import org.simantics.scl.compiler.elaboration.expressions.Variable;
import org.simantics.scl.compiler.elaboration.query.compilation.EnforcingContext;
import org.simantics.scl.compiler.elaboration.query.compilation.QueryCompilationContext;
-import org.simantics.scl.compiler.types.TPred;
import org.simantics.scl.compiler.types.TVar;
import org.simantics.scl.compiler.types.Type;
import static org.simantics.scl.compiler.elaboration.expressions.Expressions.var;
import org.simantics.scl.compiler.common.names.Name;
-import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
import org.simantics.scl.compiler.elaboration.expressions.EApply;
import org.simantics.scl.compiler.elaboration.expressions.EVariable;
import org.simantics.scl.compiler.elaboration.expressions.Expression;
import org.simantics.scl.compiler.elaboration.expressions.Variable;
import org.simantics.scl.compiler.elaboration.query.compilation.QueryCompilationContext;
-import org.simantics.scl.compiler.errors.Locations;
-import org.simantics.scl.compiler.types.TPred;
import org.simantics.scl.compiler.types.TVar;
import org.simantics.scl.compiler.types.Type;
import org.simantics.scl.compiler.types.Types;
package org.simantics.scl.compiler.elaboration.rules;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.procedure.TObjectObjectProcedure;
-import gnu.trove.procedure.TObjectProcedure;
-import gnu.trove.set.hash.THashSet;
-
import org.simantics.scl.compiler.common.names.Name;
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
import org.simantics.scl.compiler.elaboration.expressions.Variable;
import org.simantics.scl.compiler.types.Types;
import org.simantics.scl.compiler.types.kinds.Kinds;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.procedure.TObjectObjectProcedure;
+import gnu.trove.procedure.TObjectProcedure;
+import gnu.trove.set.hash.THashSet;
+
public class TransformationRule extends Symbol {
public static final TransformationRule[] EMPTY_ARRAY = new TransformationRule[0];
package org.simantics.scl.compiler.environment;\r
\r
-import gnu.trove.procedure.TObjectProcedure;\r
-\r
import org.simantics.scl.compiler.elaboration.expressions.ESimpleLambda;\r
import org.simantics.scl.compiler.elaboration.expressions.Expression;\r
import org.simantics.scl.compiler.elaboration.expressions.Variable;\r
import org.simantics.scl.compiler.types.Type;\r
-import org.simantics.scl.compiler.types.Types;\r
import org.simantics.scl.compiler.types.util.ProcedureType;\r
\r
+import gnu.trove.procedure.TObjectProcedure;\r
+\r
public abstract class AbstractLocalEnvironment implements LocalEnvironment {\r
\r
@Override\r
package org.simantics.scl.compiler.environment;
-import gnu.trove.map.hash.THashMap;
-
import java.util.Collection;
import org.simantics.scl.compiler.elaboration.rules.TransformationRule;
import org.simantics.scl.compiler.module.Module;
+import gnu.trove.map.hash.THashMap;
+
public class ConcreteEnvironment extends AbstractEnvironment {
private final THashMap<String, Module> moduleMap;
package org.simantics.scl.compiler.environment;
-import gnu.trove.procedure.TObjectProcedure;
-
import java.util.function.Consumer;
import org.simantics.scl.compiler.elaboration.modules.SCLValue;
import org.simantics.scl.compiler.internal.codegen.effects.EffectConstructor;
import org.simantics.scl.compiler.types.TCon;
+import gnu.trove.procedure.TObjectProcedure;
+
public enum EmptyNamespace implements Namespace {
INSTANCE;
package org.simantics.scl.compiler.environment;
-import gnu.trove.procedure.TObjectProcedure;
-
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import org.simantics.scl.compiler.types.TCon;
import org.simantics.scl.compiler.types.Type;
+import gnu.trove.procedure.TObjectProcedure;
+
public class Environments {
/**
* Get the SCLValue object representing an SCL value defined in a given environment.
package org.simantics.scl.compiler.environment;\r
\r
-import gnu.trove.procedure.TObjectProcedure;\r
-\r
import org.simantics.scl.compiler.elaboration.expressions.Expression;\r
import org.simantics.scl.compiler.types.Type;\r
import org.simantics.scl.compiler.types.util.ProcedureType;\r
\r
+import gnu.trove.procedure.TObjectProcedure;\r
+\r
/**\r
* Provides local variable names for expressions\r
* that do not need to defined in any module.\r
package org.simantics.scl.compiler.environment;
-import gnu.trove.procedure.TObjectProcedure;
-
import java.util.function.Consumer;
import org.simantics.scl.compiler.elaboration.modules.SCLValue;
import org.simantics.scl.compiler.internal.codegen.effects.EffectConstructor;
import org.simantics.scl.compiler.types.TCon;
+import gnu.trove.procedure.TObjectProcedure;
+
public interface Namespace {
/**
* Find a sub-namespace with a given name
package org.simantics.scl.compiler.environment;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.procedure.TObjectProcedure;
-
import java.util.ArrayList;
import java.util.function.Consumer;
import org.simantics.scl.compiler.module.Module;
import org.simantics.scl.compiler.types.TCon;
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.procedure.TObjectProcedure;
+
public class NamespaceImpl implements Namespace {
private final THashMap<String, Namespace> namespaceMap;
package org.simantics.scl.compiler.environment;\r
\r
-import gnu.trove.map.hash.THashMap;\r
-\r
import java.util.Map;\r
\r
import org.simantics.scl.compiler.environment.NamespaceImpl.ModuleImport;\r
\r
+import gnu.trove.map.hash.THashMap;\r
+\r
public class NamespaceSpec {\r
public final THashMap<String, NamespaceSpec> namespaceMap = new THashMap<String, NamespaceSpec>();\r
public final THashMap<String, ModuleImport> moduleMap = new THashMap<String, ModuleImport>();\r
package org.simantics.scl.compiler.environment.filter;\r
\r
-import gnu.trove.set.hash.THashSet;\r
-\r
import org.simantics.scl.compiler.elaboration.expressions.EVar;\r
import org.simantics.scl.compiler.module.ImportDeclaration.ImportSpec;\r
\r
+import gnu.trove.set.hash.THashSet;\r
+\r
public class NamespaceFilters {\r
public static NamespaceFilter createFromSpec(ImportSpec spec) {\r
if(spec.hiding) {\r
package org.simantics.scl.compiler.errors;
-import gnu.trove.list.array.TIntArrayList;
-
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
+import gnu.trove.list.array.TIntArrayList;
+
public class CompilationErrorFormatter {
public static int[] rows(Reader reader) throws IOException {
package org.simantics.scl.compiler.internal.codegen.analysis;\r
Code Review / simantics / platform.git / commitdiff
