?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-03-02 Jb Evain <jbevain@novell.com>
[mcs.git] / class / System.Web / System.Web.Compilation / BaseCompiler.cs
blob393f34979b47f43ebe79d7ccbd9d1e2126428b63
1 //
2 // System.Web.Compilation.BaseCompiler
3 //
4 // Authors:
5 // Gonzalo Paniagua Javier (gonzalo@ximian.com)
6 //
7 // (c) Copyright 2002,2003 Ximian, Inc (http://www.ximian.com)
8 //
9
10 //
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
18 //
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
21 //
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30
31 using System;
32 using System.CodeDom;
33 using System.CodeDom.Compiler;
34 using System.Collections;
35 using System.Collections.Specialized;
36 using System.Reflection;
37 using System.Text;
38 using System.Web.UI;
39 using System.Web.Configuration;
40 using System.IO;
41
42 namespace System.Web.Compilation
43 {
44 abstract class BaseCompiler
45 {
46 const string DEFAULT_NAMESPACE = "ASP";
47 internal static Guid HashMD5 = new Guid(0x406ea660, 0x64cf, 0x4c82, 0xb6, 0xf0, 0x42, 0xd4, 0x81, 0x72, 0xa7, 0x99);
48 static BindingFlags replaceableFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
49
50 TemplateParser parser;
51 CodeDomProvider provider;
52 ICodeCompiler compiler;
53 CodeCompileUnit unit;
54 CodeNamespace mainNS;
55 CompilerParameters compilerParameters;
56 bool isRebuilding = false;
57 protected Hashtable partialNameOverride = new Hashtable();
58 protected CodeTypeDeclaration partialClass;
59 protected CodeTypeReferenceExpression partialClassExpr;
60 protected CodeTypeDeclaration mainClass;
61 protected CodeTypeReferenceExpression mainClassExpr;
62 protected static CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression ();
63
64 VirtualPath inputVirtualPath;
65
66 public VirtualPath InputVirtualPath {
67 get {
68 if (inputVirtualPath == null)
69 inputVirtualPath = new VirtualPath (VirtualPathUtility.Combine (parser.BaseVirtualDir, Path.GetFileName (parser.InputFile)));
70
71 return inputVirtualPath;
72 }
73 }
74
75 protected BaseCompiler (TemplateParser parser)
76 {
77 this.parser = parser;
78 }
79
80 protected void AddReferencedAssembly (Assembly asm)
81 {
82 if (unit == null || asm == null)
83 return;
84
85 StringCollection refAsm = unit.ReferencedAssemblies;
86 string asmLocation = asm.Location;
87 if (!refAsm.Contains (asmLocation))
88 refAsm.Add (asmLocation);
89 }
90
91 internal CodeStatement AddLinePragma (CodeExpression expression, ControlBuilder builder)
92 {
93 return AddLinePragma (new CodeExpressionStatement (expression), builder);
94 }
95
96 internal CodeStatement AddLinePragma (CodeStatement statement, ControlBuilder builder)
97 {
98 if (builder == null || statement == null)
99 return statement;
100
101 ILocation location = null;
102
103 if (!(builder is CodeRenderBuilder))
104 location = builder.Location;
105
106 if (location != null)
107 return AddLinePragma (statement, location);
108 else
109 return AddLinePragma (statement, builder.Line, builder.FileName);
110 }
111
112 internal CodeStatement AddLinePragma (CodeStatement statement, ILocation location)
113 {
114 if (location == null || statement == null)
115 return statement;
116
117 return AddLinePragma (statement, location.BeginLine, location.Filename);
118 }
119
120 bool IgnoreFile (string fileName)
121 {
122 if (parser != null && !parser.LinePragmasOn)
123 return true;
124
125 return String.Compare (fileName, "@@inner_string@@", StringComparison.OrdinalIgnoreCase) == 0;
126 }
127
128 internal CodeStatement AddLinePragma (CodeStatement statement, int line, string fileName)
129 {
130 if (statement == null || IgnoreFile (fileName))
131 return statement;
132
133 statement.LinePragma = new CodeLinePragma (fileName, line);
134 return statement;
135 }
136
137 internal CodeTypeMember AddLinePragma (CodeTypeMember member, ControlBuilder builder)
138 {
139 if (builder == null || member == null)
140 return member;
141
142 ILocation location = builder.Location;
143
144 if (location != null)
145 return AddLinePragma (member, location);
146 else
147 return AddLinePragma (member, builder.Line, builder.FileName);
148 }
149
150 internal CodeTypeMember AddLinePragma (CodeTypeMember member, ILocation location)
151 {
152 if (location == null || member == null)
153 return member;
154
155 return AddLinePragma (member, location.BeginLine, location.Filename);
156 }
157
158 internal CodeTypeMember AddLinePragma (CodeTypeMember member, int line, string fileName)
159 {
160 if (member == null || IgnoreFile (fileName))
161 return member;
162
163 member.LinePragma = new CodeLinePragma (fileName, line);
164 return member;
165 }
166
167 internal void ConstructType ()
168 {
169 unit = new CodeCompileUnit ();
170 byte[] md5checksum = parser.MD5Checksum;
171
172 if (md5checksum != null) {
173 CodeChecksumPragma pragma = new CodeChecksumPragma ();
174 pragma.FileName = parser.InputFile;
175 pragma.ChecksumAlgorithmId = HashMD5;
176 pragma.ChecksumData = md5checksum;
177
178 unit.StartDirectives.Add (pragma);
179 }
180
181 if (parser.IsPartial) {
182 string partialns = null;
183 string partialclasstype = parser.PartialClassName;
184
185 int partialdot = partialclasstype.LastIndexOf ('.');
186 if (partialdot != -1) {
187 partialns = partialclasstype.Substring (0, partialdot);
188 partialclasstype = partialclasstype.Substring (partialdot + 1);
189 }
190
191 CodeNamespace partialNS = new CodeNamespace (partialns);
192 partialClass = new CodeTypeDeclaration (partialclasstype);
193 partialClass.IsPartial = true;
194 partialClassExpr = new CodeTypeReferenceExpression (parser.PartialClassName);
195
196 unit.Namespaces.Add (partialNS);
197 partialClass.TypeAttributes = TypeAttributes.Public;
198 partialNS.Types.Add (partialClass);
199 }
200
201 string mainclasstype = parser.ClassName;
202 string mainns = DEFAULT_NAMESPACE;
203 int maindot = mainclasstype.LastIndexOf ('.');
204 if (maindot != -1) {
205 mainns = mainclasstype.Substring (0, maindot);
206 mainclasstype = mainclasstype.Substring (maindot + 1);
207 }
208
209 mainNS = new CodeNamespace (mainns);
210 mainClass = new CodeTypeDeclaration (mainclasstype);
211 CodeTypeReference baseTypeRef;
212 if (partialClass != null) {
213 baseTypeRef = new CodeTypeReference (parser.PartialClassName);
214 baseTypeRef.Options |= CodeTypeReferenceOptions.GlobalReference;
215 } else {
216 baseTypeRef = new CodeTypeReference (parser.BaseType.FullName);
217 if (parser.BaseTypeIsGlobal)
218 baseTypeRef.Options |= CodeTypeReferenceOptions.GlobalReference;
219 }
220 mainClass.BaseTypes.Add (baseTypeRef);
221
222 mainClassExpr = new CodeTypeReferenceExpression (mainns + "." + mainclasstype);
223
224 unit.Namespaces.Add (mainNS);
225 mainClass.TypeAttributes = TypeAttributes.Public;
226 mainNS.Types.Add (mainClass);
227
228 foreach (object o in parser.Imports.Keys) {
229 if (o is string)
230 mainNS.Imports.Add (new CodeNamespaceImport ((string) o));
231 }
232
233 // StringCollection.Contains has O(n) complexity, but
234 // considering the number of comparisons we make on
235 // average and the fact that using an intermediate array
236 // would be even more costly, this is fine here.
237 StringCollection refAsm = unit.ReferencedAssemblies;
238 string asmName;
239 if (parser.Assemblies != null) {
240 foreach (object o in parser.Assemblies) {
241 asmName = o as string;
242 if (asmName != null && !refAsm.Contains (asmName))
243 refAsm.Add (asmName);
244 }
245 }
246
247 ArrayList al = WebConfigurationManager.ExtraAssemblies;
248 if (al != null && al.Count > 0) {
249 foreach (object o in al) {
250 asmName = o as string;
251 if (asmName != null && !refAsm.Contains (asmName))
252 refAsm.Add (asmName);
253 }
254 }
255
256 IList list = BuildManager.CodeAssemblies;
257 if (list != null && list.Count > 0) {
258 Assembly asm;
259 foreach (object o in list) {
260 asm = o as Assembly;
261 if (o == null)
262 continue;
263 asmName = asm.Location;
264 if (asmName != null && !refAsm.Contains (asmName))
265 refAsm.Add (asmName);
266 }
267 }
268
269 // Late-bound generators specifics (as for MonoBASIC/VB.NET)
270 unit.UserData["RequireVariableDeclaration"] = parser.ExplicitOn;
271 unit.UserData["AllowLateBound"] = !parser.StrictOn;
272
273 InitializeType ();
274 AddInterfaces ();
275 AddClassAttributes ();
276 CreateStaticFields ();
277 AddApplicationAndSessionObjects ();
278 AddScripts ();
279 CreateMethods ();
280 CreateConstructor (null, null);
281 }
282
283 internal CodeFieldReferenceExpression GetMainClassFieldReferenceExpression (string fieldName)
284 {
285 CodeTypeReference mainClassTypeRef;
286 mainClassTypeRef = new CodeTypeReference (mainNS.Name + "." + mainClass.Name);
287 mainClassTypeRef.Options |= CodeTypeReferenceOptions.GlobalReference;
288
289 return new CodeFieldReferenceExpression (
290 new CodeTypeReferenceExpression (mainClassTypeRef), fieldName);
291 }
292
293 protected virtual void InitializeType ()
294 {}
295
296 protected virtual void CreateStaticFields ()
297 {
298 CodeMemberField fld = new CodeMemberField (typeof (bool), "__initialized");
299 fld.Attributes = MemberAttributes.Private | MemberAttributes.Static;
300 fld.InitExpression = new CodePrimitiveExpression (false);
301 mainClass.Members.Add (fld);
302 }
303
304 void AssignAppRelativeVirtualPath (CodeConstructor ctor)
305 {
306 if (String.IsNullOrEmpty (parser.InputFile))
307 return;
308
309 Type baseType = parser.CodeFileBaseClassType;
310 if (baseType == null)
311 baseType = parser.BaseType;
312 if (baseType == null)
313 return;
314 if (!baseType.IsSubclassOf (typeof (System.Web.UI.TemplateControl)))
315 return;
316
317 CodeTypeReference baseTypeRef = new CodeTypeReference (baseType.FullName);
318 if (parser.BaseTypeIsGlobal)
319 baseTypeRef.Options |= CodeTypeReferenceOptions.GlobalReference;
320
321 CodeExpression cast = new CodeCastExpression (baseTypeRef, new CodeThisReferenceExpression ());
322 CodePropertyReferenceExpression arvpProp = new CodePropertyReferenceExpression (cast, "AppRelativeVirtualPath");
323 CodeAssignStatement arvpAssign = new CodeAssignStatement ();
324 arvpAssign.Left = arvpProp;
325 arvpAssign.Right = new CodePrimitiveExpression (VirtualPathUtility.RemoveTrailingSlash (InputVirtualPath.AppRelative));
326 ctor.Statements.Add (arvpAssign);
327 }
328
329 protected virtual void CreateConstructor (CodeStatementCollection localVars,
330 CodeStatementCollection trueStmt)
331 {
332 CodeConstructor ctor = new CodeConstructor ();
333 ctor.Attributes = MemberAttributes.Public;
334 mainClass.Members.Add (ctor);
335
336 if (localVars != null)
337 ctor.Statements.AddRange (localVars);
338
339 AssignAppRelativeVirtualPath (ctor);
340
341 CodeFieldReferenceExpression initialized = GetMainClassFieldReferenceExpression ("__initialized");
342
343 CodeBinaryOperatorExpression bin;
344 bin = new CodeBinaryOperatorExpression (initialized,
345 CodeBinaryOperatorType.ValueEquality,
346 new CodePrimitiveExpression (false));
347
348 CodeAssignStatement assign = new CodeAssignStatement (initialized,
349 new CodePrimitiveExpression (true));
350
351 CodeConditionStatement cond = new CodeConditionStatement ();
352 cond.Condition = bin;
353
354 if (trueStmt != null)
355 cond.TrueStatements.AddRange (trueStmt);
356 cond.TrueStatements.Add (assign);
357 ctor.Statements.Add (cond);
358 AddStatementsToConstructor (ctor);
359 }
360
361 protected virtual void AddStatementsToConstructor (CodeConstructor ctor)
362 {
363 }
364
365 void AddScripts ()
366 {
367 if (parser.Scripts == null || parser.Scripts.Count == 0)
368 return;
369
370 ServerSideScript sss;
371
372 foreach (object o in parser.Scripts) {
373 sss = o as ServerSideScript;
374
375 if (sss == null)
376 continue;
377
378 mainClass.Members.Add (AddLinePragma (new CodeSnippetTypeMember (sss.Script), sss.Location));
379 }
380 }
381
382 protected internal virtual void CreateMethods ()
383 {
384 }
385
386 void InternalCreatePageProperty (string retType, string name, string contextProperty)
387 {
388 CodeMemberProperty property = new CodeMemberProperty ();
389 property.Name = name;
390 property.Type = new CodeTypeReference (retType);
391 property.Attributes = MemberAttributes.Family | MemberAttributes.Final;
392
393 CodeMethodReturnStatement ret = new CodeMethodReturnStatement ();
394 CodeCastExpression cast = new CodeCastExpression ();
395 ret.Expression = cast;
396
397 CodePropertyReferenceExpression refexp = new CodePropertyReferenceExpression ();
398 refexp.TargetObject = new CodePropertyReferenceExpression (new CodeThisReferenceExpression (), "Context");
399 refexp.PropertyName = contextProperty;
400
401 cast.TargetType = new CodeTypeReference (retType);
402 cast.Expression = refexp;
403
404 property.GetStatements.Add (ret);
405 if (partialClass == null)
406 mainClass.Members.Add (property);
407 else
408 partialClass.Members.Add (property);
409 }
410
411 protected void CreateProfileProperty ()
412 {
413 string retType;
414 if (AppCodeCompiler.HaveCustomProfile (WebConfigurationManager.GetWebApplicationSection ("system.web/profile") as ProfileSection))
415 retType = "ProfileCommon";
416 else
417 retType = "System.Web.Profile.DefaultProfile";
418 InternalCreatePageProperty (retType, "Profile", "Profile");
419 }
420
421 protected virtual void AddInterfaces ()
422 {
423 if (parser.Interfaces == null)
424 return;
425
426 foreach (object o in parser.Interfaces) {
427 if (o is string)
428 mainClass.BaseTypes.Add (new CodeTypeReference ((string) o));
429 }
430 }
431
432 protected virtual void AddClassAttributes ()
433 {
434 }
435
436 protected virtual void AddApplicationAndSessionObjects ()
437 {
438 }
439
440 /* Utility methods for <object> stuff */
441 protected void CreateApplicationOrSessionPropertyForObject (Type type,
442 string propName,
443 bool isApplication,
444 bool isPublic)
445 {
446 /* if isApplication this generates (the 'cachedapp' field is created earlier):
447 private MyNS.MyClass app {
448 get {
449 if ((this.cachedapp == null)) {
450 this.cachedapp = ((MyNS.MyClass)
451 (this.Application.StaticObjects.GetObject("app")));
452 }
453 return this.cachedapp;
454 }
455 }
456
457 else, this is for Session:
458 private MyNS.MyClass ses {
459 get {
460 return ((MyNS.MyClass) (this.Session.StaticObjects.GetObject("ses")));
461 }
462 }
463
464 */
465
466 CodeExpression result = null;
467
468 CodeMemberProperty prop = new CodeMemberProperty ();
469 prop.Type = new CodeTypeReference (type);
470 prop.Name = propName;
471 if (isPublic)
472 prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
473 else
474 prop.Attributes = MemberAttributes.Private | MemberAttributes.Final;
475
476 CodePropertyReferenceExpression p1;
477 if (isApplication)
478 p1 = new CodePropertyReferenceExpression (thisRef, "Application");
479 else
480 p1 = new CodePropertyReferenceExpression (thisRef, "Session");
481
482 CodePropertyReferenceExpression p2;
483 p2 = new CodePropertyReferenceExpression (p1, "StaticObjects");
484
485 CodeMethodReferenceExpression getobject;
486 getobject = new CodeMethodReferenceExpression (p2, "GetObject");
487
488 CodeMethodInvokeExpression invoker;
489 invoker = new CodeMethodInvokeExpression (getobject,
490 new CodePrimitiveExpression (propName));
491
492 CodeCastExpression cast = new CodeCastExpression (prop.Type, invoker);
493
494 if (isApplication) {
495 CodeFieldReferenceExpression field;
496 field = new CodeFieldReferenceExpression (thisRef, "cached" + propName);
497
498 CodeConditionStatement stmt = new CodeConditionStatement();
499 stmt.Condition = new CodeBinaryOperatorExpression (field,
500 CodeBinaryOperatorType.IdentityEquality,
501 new CodePrimitiveExpression (null));
502
503 CodeAssignStatement assign = new CodeAssignStatement ();
504 assign.Left = field;
505 assign.Right = cast;
506 stmt.TrueStatements.Add (assign);
507 prop.GetStatements.Add (stmt);
508 result = field;
509 } else {
510 result = cast;
511 }
512
513 prop.GetStatements.Add (new CodeMethodReturnStatement (result));
514 mainClass.Members.Add (prop);
515 }
516
517 protected string CreateFieldForObject (Type type, string name)
518 {
519 string fieldName = "cached" + name;
520 CodeMemberField f = new CodeMemberField (type, fieldName);
521 f.Attributes = MemberAttributes.Private;
522 mainClass.Members.Add (f);
523 return fieldName;
524 }
525
526 protected void CreatePropertyForObject (Type type, string propName, string fieldName, bool isPublic)
527 {
528 CodeFieldReferenceExpression field = new CodeFieldReferenceExpression (thisRef, fieldName);
529 CodeMemberProperty prop = new CodeMemberProperty ();
530 prop.Type = new CodeTypeReference (type);
531 prop.Name = propName;
532 if (isPublic)
533 prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
534 else
535 prop.Attributes = MemberAttributes.Private | MemberAttributes.Final;
536
537 CodeConditionStatement stmt = new CodeConditionStatement();
538 stmt.Condition = new CodeBinaryOperatorExpression (field,
539 CodeBinaryOperatorType.IdentityEquality,
540 new CodePrimitiveExpression (null));
541
542 CodeObjectCreateExpression create = new CodeObjectCreateExpression (prop.Type);
543 stmt.TrueStatements.Add (new CodeAssignStatement (field, create));
544 prop.GetStatements.Add (stmt);
545 prop.GetStatements.Add (new CodeMethodReturnStatement (field));
546
547 mainClass.Members.Add (prop);
548 }
549 /******/
550
551 void CheckCompilerErrors (CompilerResults results)
552 {
553 if (results.NativeCompilerReturnValue == 0)
554 return;
555
556 string fileText = null;
557 CompilerErrorCollection errors = results.Errors;
558 CompilerError ce = (errors != null && errors.Count > 0) ? errors [0] : null;
559 string inFile = (ce != null) ? ce.FileName : null;
560
561 if (inFile != null && File.Exists (inFile)) {
562 using (StreamReader sr = File.OpenText (inFile)) {
563 fileText = sr.ReadToEnd ();
564 }
565 } else {
566 StringWriter writer = new StringWriter();
567 provider.CreateGenerator().GenerateCodeFromCompileUnit (unit, writer, null);
568 fileText = writer.ToString ();
569 }
570 throw new CompilationException (parser.InputFile, errors, fileText);
571 }
572
573 protected string DynamicDir ()
574 {
575 return AppDomain.CurrentDomain.SetupInformation.DynamicBase;
576 }
577
578 internal static CodeDomProvider CreateProvider (string lang)
579 {
580 CompilerParameters par;
581 string tempdir;
582
583 return CreateProvider (HttpContext.Current, lang, out par, out tempdir);
584 }
585
586 internal static CodeDomProvider CreateProvider (string lang, out string compilerOptions, out int warningLevel, out string tempdir)
587 {
588 return CreateProvider (HttpContext.Current, lang, out compilerOptions, out warningLevel, out tempdir);
589 }
590
591 internal static CodeDomProvider CreateProvider (HttpContext context, string lang, out string compilerOptions, out int warningLevel, out string tempdir)
592 {
593 CodeDomProvider ret;
594 CompilerParameters par;
595
596 ret = CreateProvider (context, lang, out par, out tempdir);
597 if (par != null){
598 warningLevel = par.WarningLevel;
599 compilerOptions = par.CompilerOptions;
600 } else {
601 warningLevel = 2;
602 compilerOptions = String.Empty;
603 }
604
605 return ret;
606 }
607
608 internal static CodeDomProvider CreateProvider (HttpContext context, string lang, out CompilerParameters par, out string tempdir)
609 {
610 CodeDomProvider ret = null;
611 par = null;
612
613 CompilationSection config = (CompilationSection) WebConfigurationManager.GetWebApplicationSection ("system.web/compilation");
614 Compiler comp = config.Compilers[lang];
615
616 if (comp == null) {
617 CompilerInfo info = CodeDomProvider.GetCompilerInfo (lang);
618 if (info != null && info.IsCodeDomProviderTypeValid) {
619 ret = info.CreateProvider ();
620 par = info.CreateDefaultCompilerParameters ();
621 }
622 } else {
623 Type t = HttpApplication.LoadType (comp.Type, true);
624 ret = Activator.CreateInstance (t) as CodeDomProvider;
625
626 par = new CompilerParameters ();
627 par.CompilerOptions = comp.CompilerOptions;
628 par.WarningLevel = comp.WarningLevel;
629 }
630 tempdir = config.TempDirectory;
631
632 return ret;
633 }
634
635 [MonoTODO ("find out how to extract the warningLevel and compilerOptions in the <system.codedom> case")]
636 public virtual Type GetCompiledType ()
637 {
638 Type type = CachingCompiler.GetTypeFromCache (parser.InputFile);
639 if (type != null)
640 return type;
641
642 ConstructType ();
643 string lang = parser.Language;
644 string tempdir;
645 string compilerOptions;
646 int warningLevel;
647
648 Provider = CreateProvider (parser.Context, lang, out compilerOptions, out warningLevel, out tempdir);
649 if (Provider == null)
650 throw new HttpException ("Configuration error. Language not supported: " +
651 lang, 500);
652
653 CompilerParameters parameters = CompilerParameters;
654 parameters.IncludeDebugInformation = parser.Debug;
655 parameters.CompilerOptions = compilerOptions + " " + parser.CompilerOptions;
656 parameters.WarningLevel = warningLevel;
657
658 bool keepFiles = (Environment.GetEnvironmentVariable ("MONO_ASPNET_NODELETE") != null);
659
660 if (tempdir == null || tempdir == "")
661 tempdir = DynamicDir ();
662
663 TempFileCollection tempcoll = new TempFileCollection (tempdir, keepFiles);
664 parameters.TempFiles = tempcoll;
665 string dllfilename = Path.GetFileName (tempcoll.AddExtension ("dll", true));
666 parameters.OutputAssembly = Path.Combine (DynamicDir (), dllfilename);
667
668 CompilerResults results = CachingCompiler.Compile (this);
669 CheckCompilerErrors (results);
670 Assembly assembly = results.CompiledAssembly;
671 if (assembly == null) {
672 if (!File.Exists (parameters.OutputAssembly)) {
673 results.TempFiles.Delete ();
674 throw new CompilationException (parser.InputFile, results.Errors,
675 "No assembly returned after compilation!?");
676 }
677
678 assembly = Assembly.LoadFrom (parameters.OutputAssembly);
679 }
680
681 results.TempFiles.Delete ();
682 Type mainClassType = assembly.GetType (MainClassType, true);
683
684 if (parser.IsPartial) {
685 // With the partial classes, we need to make sure we
686 // don't have any methods that should have not been
687 // created (because they are accessible from the base
688 // types). We cannot do this normally because the
689 // codebehind file is actually a partial class and we
690 // have no way of identifying the partial class' base
691 // type until now.
692 if (!isRebuilding && CheckPartialBaseType (mainClassType)) {
693 isRebuilding = true;
694 parser.RootBuilder.ResetState ();
695 return GetCompiledType ();
696 }
697 }
698
699 return mainClassType;
700 }
701
702 internal string MainClassType {
703 get {
704 if (mainClassExpr == null)
705 return null;
706
707 return mainClassExpr.Type.BaseType;
708 }
709 }
710
711 internal bool IsRebuildingPartial
712 {
713 get { return isRebuilding; }
714 }
715
716 internal bool CheckPartialBaseType (Type type)
717 {
718 // Get the base type. If we don't have any (bad thing), we
719 // don't need to replace ourselves. Also check for the
720 // core file, since that won't have any either.
721 Type baseType = type.BaseType;
722 if (baseType == null || baseType == typeof(System.Web.UI.Page))
723 return false;
724
725 bool rebuild = false;
726
727 if (CheckPartialBaseFields (type, baseType))
728 rebuild = true;
729
730 if (CheckPartialBaseProperties (type, baseType))
731 rebuild = true;
732
733 return rebuild;
734 }
735
736 internal bool CheckPartialBaseFields (Type type, Type baseType)
737 {
738 bool rebuild = false;
739
740 foreach (FieldInfo baseInfo in baseType.GetFields (replaceableFlags)) {
741 if (baseInfo.IsPrivate)
742 continue;
743
744 FieldInfo typeInfo = type.GetField (baseInfo.Name, replaceableFlags);
745
746 if (typeInfo != null && typeInfo.DeclaringType == type) {
747 partialNameOverride [typeInfo.Name] = true;
748 rebuild = true;
749 }
750 }
751
752 return rebuild;
753 }
754
755 internal bool CheckPartialBaseProperties (Type type, Type baseType)
756 {
757 bool rebuild = false;
758
759 foreach (PropertyInfo baseInfo in baseType.GetProperties ()) {
760 PropertyInfo typeInfo = type.GetProperty (baseInfo.Name);
761
762 if (typeInfo != null && typeInfo.DeclaringType == type) {
763 partialNameOverride [typeInfo.Name] = true;
764 rebuild = true;
765 }
766 }
767
768 return rebuild;
769 }
770
771 internal CodeDomProvider Provider {
772 get { return provider; }
773 set { provider = value; }
774 }
775
776 internal ICodeCompiler Compiler {
777 get { return compiler; }
778 set { compiler = value; }
779 }
780
781 internal CompilerParameters CompilerParameters {
782 get {
783 if (compilerParameters == null)
784 compilerParameters = new CompilerParameters ();
785
786 return compilerParameters;
787 }
788
789 set { compilerParameters = value; }
790 }
791
792 internal CodeCompileUnit CompileUnit {
793 get { return unit; }
794 }
795
796 internal CodeTypeDeclaration DerivedType {
797 get { return mainClass; }
798 }
799
800 internal CodeTypeDeclaration BaseType {
801 get {
802 if (partialClass == null)
803 return DerivedType;
804 return partialClass;
805 }
806 }
807
808 internal TemplateParser Parser {
809 get { return parser; }
810 }
811 }
812 }
813
git-svn mirror of mcs