649 lines
16 KiB
C#
649 lines
16 KiB
C#
/***************************************************************************
|
|
* ScriptCompiler.cs
|
|
* -------------------
|
|
* begin : May 1, 2002
|
|
* copyright : (C) The RunUO Software Team
|
|
* email : info@runuo.com
|
|
*
|
|
* $Id$
|
|
*
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
***************************************************************************/
|
|
|
|
using System;
|
|
using System.CodeDom;
|
|
using System.CodeDom.Compiler;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Reflection;
|
|
using System.Security.Cryptography;
|
|
using Microsoft.CSharp;
|
|
using Microsoft.VisualBasic;
|
|
using System.Diagnostics;
|
|
|
|
namespace Server
|
|
{
|
|
public static class ScriptCompiler
|
|
{
|
|
private static Assembly[] m_Assemblies;
|
|
|
|
public static Assembly[] Assemblies
|
|
{
|
|
get
|
|
{
|
|
return m_Assemblies;
|
|
}
|
|
set
|
|
{
|
|
m_Assemblies = value;
|
|
}
|
|
}
|
|
|
|
private static List<string> m_AdditionalReferences = new List<string>();
|
|
|
|
public static string[] GetReferenceAssemblies()
|
|
{
|
|
List<string> list = new List<string>();
|
|
|
|
string path = Path.Combine( Core.BaseDirectory, "Data/Config/Assemblies.cfg" );
|
|
|
|
if( File.Exists( path ) )
|
|
{
|
|
using( StreamReader ip = new StreamReader( path ) )
|
|
{
|
|
string line;
|
|
|
|
while( (line = ip.ReadLine()) != null )
|
|
{
|
|
if( line.Length > 0 && !line.StartsWith( "#" ) )
|
|
list.Add( line );
|
|
}
|
|
}
|
|
}
|
|
|
|
list.Add( Core.ExePath );
|
|
|
|
list.AddRange( m_AdditionalReferences );
|
|
|
|
return list.ToArray();
|
|
}
|
|
|
|
public static string GetDefines()
|
|
{
|
|
StringBuilder sb = null;
|
|
|
|
#if MONO
|
|
AppendDefine( ref sb, "/d:MONO" );
|
|
#endif
|
|
|
|
//These two defines are legacy, ie, depreciated.
|
|
if( Core.Is64Bit )
|
|
AppendDefine( ref sb, "/d:x64" );
|
|
|
|
AppendDefine( ref sb, "/d:Framework_2_0" );
|
|
|
|
#if Framework_4_0
|
|
AppendDefine( ref sb, "/d:Framework_4_0" );
|
|
#endif
|
|
|
|
return (sb == null ? null : sb.ToString());
|
|
}
|
|
|
|
public static void AppendDefine( ref StringBuilder sb, string define )
|
|
{
|
|
if( sb == null )
|
|
sb = new StringBuilder();
|
|
else
|
|
sb.Append( ' ' );
|
|
|
|
sb.Append( define );
|
|
}
|
|
|
|
private static byte[] GetHashCode( string compiledFile, string[] scriptFiles, bool debug )
|
|
{
|
|
using( MemoryStream ms = new MemoryStream() )
|
|
{
|
|
using( BinaryWriter bin = new BinaryWriter( ms ) )
|
|
{
|
|
FileInfo fileInfo = new FileInfo( compiledFile );
|
|
|
|
bin.Write( fileInfo.LastWriteTimeUtc.Ticks );
|
|
|
|
foreach( string scriptFile in scriptFiles )
|
|
{
|
|
fileInfo = new FileInfo( scriptFile );
|
|
|
|
bin.Write( fileInfo.LastWriteTimeUtc.Ticks );
|
|
}
|
|
|
|
bin.Write( debug );
|
|
bin.Write( Core.Version.ToString() );
|
|
|
|
ms.Position = 0;
|
|
|
|
using( SHA1 sha1 = SHA1.Create() )
|
|
{
|
|
return sha1.ComputeHash( ms );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool CompileCSScripts( out Assembly assembly )
|
|
{
|
|
return CompileCSScripts( false, true, out assembly );
|
|
}
|
|
|
|
public static bool CompileCSScripts( bool debug, out Assembly assembly )
|
|
{
|
|
return CompileCSScripts( debug, true, out assembly );
|
|
}
|
|
|
|
public static bool CompileCSScripts( bool debug, bool cache, out Assembly assembly )
|
|
{
|
|
Console.Write( "Scripts: Compiling C# scripts..." );
|
|
string[] files = GetScripts( "*.cs" );
|
|
|
|
if( files.Length == 0 )
|
|
{
|
|
Console.WriteLine( "no files found." );
|
|
assembly = null;
|
|
return true;
|
|
}
|
|
|
|
if( File.Exists( "Scripts/Output/Scripts.CS.dll" ) )
|
|
{
|
|
if( cache && File.Exists( "Scripts/Output/Scripts.CS.hash" ) )
|
|
{
|
|
try
|
|
{
|
|
byte[] hashCode = GetHashCode( "Scripts/Output/Scripts.CS.dll", files, debug );
|
|
|
|
using( FileStream fs = new FileStream( "Scripts/Output/Scripts.CS.hash", FileMode.Open, FileAccess.Read, FileShare.Read ) )
|
|
{
|
|
using( BinaryReader bin = new BinaryReader( fs ) )
|
|
{
|
|
byte[] bytes = bin.ReadBytes( hashCode.Length );
|
|
|
|
if( bytes.Length == hashCode.Length )
|
|
{
|
|
bool valid = true;
|
|
|
|
for( int i = 0; i < bytes.Length; ++i )
|
|
{
|
|
if( bytes[i] != hashCode[i] )
|
|
{
|
|
valid = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( valid )
|
|
{
|
|
assembly = Assembly.LoadFrom( "Scripts/Output/Scripts.CS.dll" );
|
|
|
|
if( !m_AdditionalReferences.Contains( assembly.Location ) )
|
|
{
|
|
m_AdditionalReferences.Add( assembly.Location );
|
|
}
|
|
|
|
Console.WriteLine( "done (cached)" );
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
DeleteFiles( "Scripts.CS*.dll" );
|
|
|
|
using ( CSharpCodeProvider provider = new CSharpCodeProvider() )
|
|
{
|
|
string path = GetUnusedPath( "Scripts.CS" );
|
|
|
|
CompilerParameters parms = new CompilerParameters( GetReferenceAssemblies(), path, debug );
|
|
|
|
string defines = GetDefines();
|
|
|
|
if( defines != null )
|
|
parms.CompilerOptions = defines;
|
|
|
|
if( Core.HaltOnWarning )
|
|
parms.WarningLevel = 4;
|
|
|
|
#if !MONO
|
|
CompilerResults results = provider.CompileAssemblyFromFile( parms, files );
|
|
#else
|
|
parms.CompilerOptions = String.Format( "{0} /nowarn:169,219,414 /recurse:Scripts/*.cs", parms.CompilerOptions );
|
|
CompilerResults results = provider.CompileAssemblyFromFile( parms, files );
|
|
#endif
|
|
m_AdditionalReferences.Add( path );
|
|
|
|
Display( results );
|
|
|
|
#if !MONO
|
|
if( results.Errors.Count > 0 )
|
|
{
|
|
assembly = null;
|
|
return false;
|
|
}
|
|
#else
|
|
if( results.Errors.Count > 0 ) {
|
|
foreach( CompilerError err in results.Errors ) {
|
|
if ( !err.IsWarning ) {
|
|
assembly = null;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
if( cache && Path.GetFileName( path ) == "Scripts.CS.dll" )
|
|
{
|
|
try
|
|
{
|
|
byte[] hashCode = GetHashCode( path, files, debug );
|
|
|
|
using( FileStream fs = new FileStream( "Scripts/Output/Scripts.CS.hash", FileMode.Create, FileAccess.Write, FileShare.None ) )
|
|
{
|
|
using( BinaryWriter bin = new BinaryWriter( fs ) )
|
|
{
|
|
bin.Write( hashCode, 0, hashCode.Length );
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
assembly = results.CompiledAssembly;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public static void Display( CompilerResults results )
|
|
{
|
|
if( results.Errors.Count > 0 )
|
|
{
|
|
Dictionary<string, List<CompilerError>> errors = new Dictionary<string, List<CompilerError>>( results.Errors.Count, StringComparer.OrdinalIgnoreCase );
|
|
Dictionary<string, List<CompilerError>> warnings = new Dictionary<string, List<CompilerError>>( results.Errors.Count, StringComparer.OrdinalIgnoreCase );
|
|
|
|
foreach( CompilerError e in results.Errors )
|
|
{
|
|
string file = e.FileName;
|
|
|
|
// Ridiculous. FileName is null if the warning/error is internally generated in csc.
|
|
if ( string.IsNullOrEmpty( file ) ) {
|
|
Console.WriteLine( "ScriptCompiler: {0}: {1}", e.ErrorNumber, e.ErrorText );
|
|
continue;
|
|
}
|
|
|
|
Dictionary<string, List<CompilerError>> table = (e.IsWarning ? warnings : errors);
|
|
|
|
List<CompilerError> list = null;
|
|
table.TryGetValue( file, out list );
|
|
|
|
if( list == null )
|
|
table[file] = list = new List<CompilerError>();
|
|
|
|
list.Add( e );
|
|
}
|
|
|
|
if( errors.Count > 0 )
|
|
Console.WriteLine( "failed ({0} errors, {1} warnings)", errors.Count, warnings.Count );
|
|
else
|
|
Console.WriteLine( "done ({0} errors, {1} warnings)", errors.Count, warnings.Count );
|
|
|
|
string scriptRoot = Path.GetFullPath( Path.Combine( Core.BaseDirectory, "Scripts" + Path.DirectorySeparatorChar ) );
|
|
Uri scriptRootUri = new Uri( scriptRoot );
|
|
|
|
Utility.PushColor( ConsoleColor.Yellow );
|
|
|
|
if( warnings.Count > 0 )
|
|
Console.WriteLine( "Warnings:" );
|
|
|
|
foreach( KeyValuePair<string, List<CompilerError>> kvp in warnings )
|
|
{
|
|
string fileName = kvp.Key;
|
|
List<CompilerError> list = kvp.Value;
|
|
|
|
string fullPath = Path.GetFullPath( fileName );
|
|
string usedPath = Uri.UnescapeDataString( scriptRootUri.MakeRelativeUri( new Uri( fullPath ) ).OriginalString );
|
|
|
|
Console.WriteLine( " + {0}:", usedPath );
|
|
|
|
Utility.PushColor( ConsoleColor.DarkYellow );
|
|
|
|
foreach( CompilerError e in list )
|
|
Console.WriteLine( " {0}: Line {1}: {3}", e.ErrorNumber, e.Line, e.Column, e.ErrorText );
|
|
|
|
Utility.PopColor();
|
|
}
|
|
|
|
Utility.PopColor();
|
|
|
|
Utility.PushColor( ConsoleColor.Red );
|
|
|
|
if( errors.Count > 0 )
|
|
Console.WriteLine( "Errors:" );
|
|
|
|
foreach( KeyValuePair<string, List<CompilerError>> kvp in errors )
|
|
{
|
|
string fileName = kvp.Key;
|
|
List<CompilerError> list = kvp.Value;
|
|
|
|
string fullPath = Path.GetFullPath( fileName );
|
|
string usedPath = Uri.UnescapeDataString( scriptRootUri.MakeRelativeUri( new Uri( fullPath ) ).OriginalString );
|
|
|
|
Console.WriteLine( " + {0}:", usedPath );
|
|
|
|
Utility.PushColor( ConsoleColor.DarkRed );
|
|
|
|
foreach( CompilerError e in list )
|
|
Console.WriteLine( " {0}: Line {1}: {3}", e.ErrorNumber, e.Line, e.Column, e.ErrorText );
|
|
|
|
Utility.PopColor();
|
|
}
|
|
|
|
Utility.PopColor();
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine( "done (0 errors, 0 warnings)" );
|
|
}
|
|
}
|
|
|
|
public static string GetUnusedPath( string name )
|
|
{
|
|
string path = Path.Combine( Core.BaseDirectory, String.Format( "Scripts/Output/{0}.dll", name ) );
|
|
|
|
for( int i = 2; File.Exists( path ) && i <= 1000; ++i )
|
|
path = Path.Combine( Core.BaseDirectory, String.Format( "Scripts/Output/{0}.{1}.dll", name, i ) );
|
|
|
|
return path;
|
|
}
|
|
|
|
public static void DeleteFiles( string mask )
|
|
{
|
|
try
|
|
{
|
|
string[] files = Directory.GetFiles( Path.Combine( Core.BaseDirectory, "Scripts/Output" ), mask );
|
|
|
|
foreach( string file in files )
|
|
{
|
|
try { File.Delete( file ); }
|
|
catch { }
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
private delegate CompilerResults Compiler( bool debug );
|
|
|
|
public static bool Compile()
|
|
{
|
|
return Compile( false );
|
|
}
|
|
|
|
public static bool Compile( bool debug )
|
|
{
|
|
return Compile( debug, true );
|
|
}
|
|
|
|
public static bool Compile( bool debug, bool cache )
|
|
{
|
|
EnsureDirectory( "Scripts/" );
|
|
EnsureDirectory( "Scripts/Output/" );
|
|
|
|
if( m_AdditionalReferences.Count > 0 )
|
|
m_AdditionalReferences.Clear();
|
|
|
|
List<Assembly> assemblies = new List<Assembly>();
|
|
|
|
Assembly assembly;
|
|
|
|
if( CompileCSScripts( debug, cache, out assembly ) )
|
|
{
|
|
if( assembly != null )
|
|
{
|
|
assemblies.Add( assembly );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( assemblies.Count == 0 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_Assemblies = assemblies.ToArray();
|
|
|
|
Console.Write( "Scripts: Verifying..." );
|
|
|
|
Stopwatch watch = Stopwatch.StartNew();
|
|
|
|
Core.VerifySerialization();
|
|
|
|
watch.Stop();
|
|
|
|
Console.WriteLine("done ({0} items, {1} mobiles) ({2:F2} seconds)", Core.ScriptItems, Core.ScriptMobiles, watch.Elapsed.TotalSeconds);
|
|
|
|
return true;
|
|
}
|
|
|
|
public static void Invoke( string method )
|
|
{
|
|
List<MethodInfo> invoke = new List<MethodInfo>();
|
|
|
|
for( int a = 0; a < m_Assemblies.Length; ++a )
|
|
{
|
|
Type[] types = m_Assemblies[a].GetTypes();
|
|
|
|
for( int i = 0; i < types.Length; ++i )
|
|
{
|
|
MethodInfo m = types[i].GetMethod( method, BindingFlags.Static | BindingFlags.Public );
|
|
|
|
if( m != null )
|
|
invoke.Add( m );
|
|
}
|
|
}
|
|
|
|
invoke.Sort( new CallPriorityComparer() );
|
|
|
|
for( int i = 0; i < invoke.Count; ++i )
|
|
invoke[i].Invoke( null, null );
|
|
}
|
|
|
|
private static Dictionary<Assembly, TypeCache> m_TypeCaches = new Dictionary<Assembly, TypeCache>();
|
|
private static TypeCache m_NullCache;
|
|
|
|
public static TypeCache GetTypeCache( Assembly asm )
|
|
{
|
|
if( asm == null )
|
|
{
|
|
if( m_NullCache == null )
|
|
m_NullCache = new TypeCache( null );
|
|
|
|
return m_NullCache;
|
|
}
|
|
|
|
TypeCache c = null;
|
|
m_TypeCaches.TryGetValue( asm, out c );
|
|
|
|
if( c == null )
|
|
m_TypeCaches[asm] = c = new TypeCache( asm );
|
|
|
|
return c;
|
|
}
|
|
|
|
public static Type FindTypeByFullName( string fullName )
|
|
{
|
|
return FindTypeByFullName( fullName, true );
|
|
}
|
|
|
|
public static Type FindTypeByFullName( string fullName, bool ignoreCase )
|
|
{
|
|
Type type = null;
|
|
|
|
for( int i = 0; type == null && i < m_Assemblies.Length; ++i )
|
|
type = GetTypeCache( m_Assemblies[i] ).GetTypeByFullName( fullName, ignoreCase );
|
|
|
|
if( type == null )
|
|
type = GetTypeCache( Core.Assembly ).GetTypeByFullName( fullName, ignoreCase );
|
|
|
|
return type;
|
|
}
|
|
|
|
public static Type FindTypeByName( string name )
|
|
{
|
|
return FindTypeByName( name, true );
|
|
}
|
|
|
|
public static Type FindTypeByName( string name, bool ignoreCase )
|
|
{
|
|
Type type = null;
|
|
|
|
for( int i = 0; type == null && i < m_Assemblies.Length; ++i )
|
|
type = GetTypeCache( m_Assemblies[i] ).GetTypeByName( name, ignoreCase );
|
|
|
|
if( type == null )
|
|
type = GetTypeCache( Core.Assembly ).GetTypeByName( name, ignoreCase );
|
|
|
|
return type;
|
|
}
|
|
|
|
public static void EnsureDirectory( string dir )
|
|
{
|
|
string path = Path.Combine( Core.BaseDirectory, dir );
|
|
|
|
if( !Directory.Exists( path ) )
|
|
Directory.CreateDirectory( path );
|
|
}
|
|
|
|
public static string[] GetScripts( string filter )
|
|
{
|
|
List<string> list = new List<string>();
|
|
|
|
GetScripts( list, Path.Combine( Core.BaseDirectory, "Scripts" ), filter );
|
|
|
|
return list.ToArray();
|
|
}
|
|
|
|
public static void GetScripts( List<string> list, string path, string filter )
|
|
{
|
|
foreach( string dir in Directory.GetDirectories( path ) )
|
|
GetScripts( list, dir, filter );
|
|
|
|
list.AddRange( Directory.GetFiles( path, filter ) );
|
|
}
|
|
}
|
|
|
|
public class TypeCache
|
|
{
|
|
private Type[] m_Types;
|
|
private TypeTable m_Names, m_FullNames;
|
|
|
|
public Type[] Types { get { return m_Types; } }
|
|
public TypeTable Names { get { return m_Names; } }
|
|
public TypeTable FullNames { get { return m_FullNames; } }
|
|
|
|
public Type GetTypeByName( string name, bool ignoreCase )
|
|
{
|
|
return m_Names.Get( name, ignoreCase );
|
|
}
|
|
|
|
public Type GetTypeByFullName( string fullName, bool ignoreCase )
|
|
{
|
|
return m_FullNames.Get( fullName, ignoreCase );
|
|
}
|
|
|
|
public TypeCache( Assembly asm )
|
|
{
|
|
if( asm == null )
|
|
m_Types = Type.EmptyTypes;
|
|
else
|
|
m_Types = asm.GetTypes();
|
|
|
|
m_Names = new TypeTable( m_Types.Length );
|
|
m_FullNames = new TypeTable( m_Types.Length );
|
|
|
|
Type typeofTypeAliasAttribute = typeof( TypeAliasAttribute );
|
|
|
|
for( int i = 0; i < m_Types.Length; ++i )
|
|
{
|
|
Type type = m_Types[i];
|
|
|
|
m_Names.Add( type.Name, type );
|
|
m_FullNames.Add( type.FullName, type );
|
|
|
|
if( type.IsDefined( typeofTypeAliasAttribute, false ) )
|
|
{
|
|
object[] attrs = type.GetCustomAttributes( typeofTypeAliasAttribute, false );
|
|
|
|
if( attrs != null && attrs.Length > 0 )
|
|
{
|
|
TypeAliasAttribute attr = attrs[0] as TypeAliasAttribute;
|
|
|
|
if( attr != null )
|
|
{
|
|
for( int j = 0; j < attr.Aliases.Length; ++j )
|
|
m_FullNames.Add( attr.Aliases[j], type );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class TypeTable
|
|
{
|
|
private Dictionary<string, Type> m_Sensitive, m_Insensitive;
|
|
|
|
public void Add( string key, Type type )
|
|
{
|
|
m_Sensitive[key] = type;
|
|
m_Insensitive[key] = type;
|
|
}
|
|
|
|
public Type Get( string key, bool ignoreCase )
|
|
{
|
|
Type t = null;
|
|
|
|
if( ignoreCase )
|
|
m_Insensitive.TryGetValue( key, out t );
|
|
else
|
|
m_Sensitive.TryGetValue( key, out t );
|
|
|
|
return t;
|
|
}
|
|
|
|
public TypeTable( int capacity )
|
|
{
|
|
m_Sensitive = new Dictionary<string, Type>( capacity );
|
|
m_Insensitive = new Dictionary<string, Type>( capacity, StringComparer.OrdinalIgnoreCase );
|
|
}
|
|
}
|
|
}
|