// Trace mode entry point public TypeDefinitionCompiler(AssemblyCompiler parent, TypeTrace typeTrace) { Env = parent.Env; Parent = parent; TyconEnv = parent.AssmEnv.AddType(typeTrace.Type); this.TypeTrace = typeTrace; if (typeTrace.IncludeType && typeTrace.Parent.Parent.Flavor == TraceFlavor.Remainder) { // Create a self-loader fragment file NameSupply = new JST.NameSupply(Constants.Globals); // Will be bound by function passed to root's BindType RootId = NameSupply.GenSym(); AssemblyId = NameSupply.GenSym(); TypeDefinitionId = NameSupply.GenSym(); } else { // Possibly inline type definition and/or method definitions into trace NameSupply = parent.NameSupply; // Already bound by parent RootId = parent.RootId; AssemblyId = parent.AssemblyId; // Will be bound locally TypeDefinitionId = NameSupply.GenSym(); } }
public void BindUsage(ISeq <JST.Statement> statements, CST.Usage usage, TypePhase typePhase) { foreach (var kv in usage.Assemblies) { if (kv.Value > 1) { if (!boundAssemblies.ContainsKey(kv.Key)) { var e = env.JSTHelpers.DefaultResolveAssembly(this, kv.Key); if (e != null) { if (env.DebugMode) { statements.Add(new JST.CommentStatement(kv.Key.ToString())); } var id = NameSupply.GenSym(); statements.Add(JST.Statement.Var(id, e)); boundAssemblies.Add(kv.Key, id.ToE()); } } // else: use outer binding } // else: inline expression as need it } foreach (var kv in usage.Types) { if (kv.Value > 1) { var existing = default(ExpressionAndPhase); var b = boundTypes.TryGetValue(kv.Key, out existing); if (!b || typePhase > existing.Phase) { var e = env.JSTHelpers.DefaultResolveType(this, kv.Key, typePhase); if (e != null) { if (env.DebugMode) { statements.Add(new JST.CommentStatement(kv.Key.ToString())); } var id = NameSupply.GenSym(); statements.Add(JST.Statement.Var(id, e)); var updated = new ExpressionAndPhase(id.ToE(), typePhase); if (b) { boundTypes[kv.Key] = updated; } else { boundTypes.Add(kv.Key, updated); } } } // else: use outer binding } // else: inline expression as need it } }
// Collecting mode entry point public AssemblyCompiler(CompilerEnvironment env, CST.AssemblyDef assemblyDef) : this(env) { assmEnv = env.Global.Environment().AddAssembly(assemblyDef); assemblyTrace = null; NameSupply = new JST.NameSupply(Constants.Globals); rootId = NameSupply.GenSym(); assemblyId = NameSupply.GenSym(); }
public static TypeCompilerEnvironment EnterType (CompilerEnvironment env, JST.NameSupply nameSupply, JST.Identifier rootId, JST.Identifier assemblyId, JST.Identifier typeId, CST.TypeEnvironment typeEnv, TypeTrace typeTrace) { var typeBoundTypeParameterIds = new Seq <JST.Identifier>(); for (var i = 0; i < typeEnv.Type.Arity; i++) { typeBoundTypeParameterIds.Add(nameSupply.GenSym()); } var res = new TypeCompilerEnvironment (typeEnv.Global, typeEnv.SkolemDefs, typeEnv.Assembly, typeEnv.Type, typeEnv.TypeBoundArguments, env, nameSupply, rootId, assemblyId, typeId, typeBoundTypeParameterIds, typeTrace); res.BindSpecial(); return(res); }
private void BindMap <T> (ISeq <JST.Statement> statements, IMap <T, int> usageMap, IMap <T, JST.Expression> boundMap, Func <T, string> mkName, Func <T, JST.Expression> mkExpression) { foreach (var kv in usageMap) { if (!boundMap.ContainsKey(kv.Key)) { if (kv.Value > 1) { var e = mkExpression(kv.Key); if (e != null) { if (env.DebugMode) { statements.Add(new JST.CommentStatement(mkName(kv.Key))); } var id = NameSupply.GenSym(); statements.Add(JST.Statement.Var(id, e)); boundMap.Add(kv.Key, id.ToE()); } } // else: inline expression as need it } // else: use outer binding } }
// Traced mode entry point public AssemblyCompiler(TraceCompiler parent, AssemblyTrace assemblyTrace) : this(parent.Env) { assmEnv = parent.Env.Global.Environment().AddAssembly(assemblyTrace.Assembly); this.assemblyTrace = assemblyTrace; if (assemblyTrace.Parent.Flavor == TraceFlavor.Remainder) { NameSupply = new JST.NameSupply(Constants.Globals); rootId = NameSupply.GenSym(); assemblyId = NameSupply.GenSym(); } else { NameSupply = parent.NameSupply; rootId = parent.RootId; assemblyId = NameSupply.GenSym(); } }
public TraceCompiler(CompilerEnvironment env, Trace trace) { Env = env; Trace = trace; if (trace.Flavor != TraceFlavor.Remainder) { NameSupply = new JST.NameSupply(Constants.Globals); RootId = NameSupply.GenSym(); } }
public TypeCompiler(TypeDefinitionCompiler parent) { // Type compiler is always in context of it's type definition Env = parent.Env; Parent = parent; var typeEnv = parent.TyconEnv.AddSelfTypeBoundArguments(); NameSupply = typeEnv.Type.Arity > 0 ? parent.NameSupply.Fork() : parent.NameSupply; RootId = parent.RootId; AssemblyId = parent.AssemblyId; TypeDefinitionId = parent.TypeDefinitionId; TypeId = typeEnv.Type.Arity > 0 ? NameSupply.GenSym() : parent.TypeDefinitionId; TypeCompEnv = TypeCompilerEnvironment.EnterType(Env, NameSupply, RootId, AssemblyId, TypeId, typeEnv, parent.TypeTrace); }
// Collecting mode entry point public TypeDefinitionCompiler(AssemblyCompiler parent, CST.TypeDef typeDef) { Env = parent.Env; Parent = parent; TyconEnv = parent.AssmEnv.AddType(typeDef); TypeTrace = null; // Inline type definition and method definitions into overall assembly NameSupply = parent.NameSupply; // Already bound by parent RootId = parent.RootId; AssemblyId = parent.AssemblyId; // Will be bound locally TypeDefinitionId = NameSupply.GenSym(); }
public static MethodCompilerEnvironment EnterMethod (CompilerEnvironment env, JST.NameSupply outerNameSupply, JST.NameSupply nameSupply, JST.Identifier rootId, JST.Identifier assemblyId, JST.Identifier typeDefinitonId, CST.CompilationEnvironment compEnv, TypeTrace typeTrace) { // BUG: IE messes up scoping for function identifiers. To compensate we must allocate its // identifier in the outer scope var methodId = outerNameSupply.GenSym(); if (env.DebugMode) { var sb = new StringBuilder(); sb.Append(methodId.Value); sb.Append('_'); var namedTypeDef = compEnv.Type as CST.NamedTypeDef; if (namedTypeDef != null) { if (namedTypeDef.Name.Namespace.Length > 0) { JST.Lexemes.AppendStringToIdentifier(sb, namedTypeDef.Name.Namespace.Replace('.', '_')); sb.Append('_'); } foreach (var n in namedTypeDef.Name.Types) { JST.Lexemes.AppendStringToIdentifier(sb, n); sb.Append('_'); } } JST.Lexemes.AppendStringToIdentifier(sb, compEnv.Method.Name); methodId = new JST.Identifier(sb.ToString()); } var typeBoundTypeParameterIds = new Seq <JST.Identifier>(); for (var i = 0; i < compEnv.Type.Arity; i++) { typeBoundTypeParameterIds.Add(nameSupply.GenSym()); } var methodBoundTypeParameterIds = new Seq <JST.Identifier>(); for (var i = 0; i < compEnv.Method.TypeArity; i++) { methodBoundTypeParameterIds.Add(nameSupply.GenSym()); } var res = new MethodCompilerEnvironment (compEnv.Global, compEnv.SkolemDefs, compEnv.Assembly, compEnv.Type, compEnv.TypeBoundArguments, compEnv.Method, compEnv.MethodBoundArguments, compEnv.Variables, compEnv.ValueParameterIds, compEnv.LocalIds, env, nameSupply, rootId, assemblyId, typeDefinitonId, methodId, typeBoundTypeParameterIds, methodBoundTypeParameterIds, typeTrace); res.BindSpecial(); return(res); }