public void LoadDataIdiorm(DataGridView dtgvThanhNgu)
{
Idioms source = new Idioms();
dtgvThanhNgu.DataSource = source.GetDataIdiorm();
dtgvThanhNgu.Columns[0].Visible = false;
}
public new void Add(string key, WordInfoOnce value)
{
if (ContainsKey(key))
{
//$"{name}已存在键：{key}。".WriteWarningLine();
return;//已有
}
if (name == "默认")
{
var w = value;
if (w.p?.StartsWith("i", StringComparison.OrdinalIgnoreCase) == true)
{
Idioms.Add(w.w, w); //成语词典
}
else if (w.p?.StartsWith("nr", StringComparison.OrdinalIgnoreCase) == true)
{
PersonNames.Add(w.w, w); //人名词典
}
else if (w.p?.StartsWith("ns", StringComparison.OrdinalIgnoreCase) == true)
{
PlaceNames.Add(w.w, w); //地
}
else
{
TempWords.Add(key, value);
}
}
else
{
base.Add(key, value);
}
}
public LoopTransformer(JsTransformer transformer, StatementSyntax loop, int loopDepth, StatementSyntax body)
{
this.transformer = transformer;
idioms = transformer.idioms;
this.loopDepth = loopDepth;
this.body = body;
loopNode = loop;
}
void LoadDatabase(DataGridView dtgv)
{
Idioms idiorm = new Idioms();
var source = idiorm.GetAllIdiormInDatabase();
dtgv.DataSource = source;
dtgv.Columns[0].Visible = false;
}
void OnAddItemClicked(object sender, EventArgs e)
{
var idioms = new Idioms()
{
Id = Guid.NewGuid().ToString()
};
//Blank and open Item View
//::TODO:: - noted by trongan93
}
public BaseStateGenerator(Func <BaseStateGenerator, JsTransformer> transformer, CSharpSyntaxNode node, JsBlockStatement stateMachineBody, Idioms idioms, IMethodSymbol method, Action <BaseStateGenerator, JsTransformer> nodeAcceptor = null)
{
if (nodeAcceptor == null)
{
nodeAcceptor = (stateGenerator, jsTransformer) => node.Accept(stateGenerator);
}
this.transformer = transformer(this);
this.node = node;
this.stateMachineBody = stateMachineBody;
this.method = method;
this.idioms = idioms;
this.nodeAcceptor = nodeAcceptor;
}
public override int GetHashCode()
{
unchecked
{
var hashCode = Number;
hashCode = (hashCode * 397) ^ Priority;
hashCode = (hashCode * 397) ^ (Logograph != null ? Logograph.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Pronunciation != null ? Pronunciation.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (ReviewTime != null ? ReviewTime.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Definitions != null ? Definitions.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Usages != null ? Usages.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Phrases != null ? Phrases.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Idioms != null ? Idioms.GetHashCode() : 0);
return(hashCode);
}
}
public async Task Compile()
{
projectName = project.AssemblyName;
Compilation compilation = await Profiler.Time("Getting initial project compilation", async() => await project.GetCompilationAsync());
Context.Update(project.Solution, project, compilation, new ReflectionCache(project, compilation));
// If this is the runtime prjoect, declare the array to hold all the GetAssembly functions (this .js file
// will be loaded first, and we only want to bother creating the array once.)
if (projectName == "mscorlib")
{
var global = new JsBlockStatement();
jsCompilationUnit.Global = global;
var assemblies = Js.Variable(SpecialNames.Assemblies, Js.Array());
global.Local(assemblies);
// This ensures that Function.$typeName returns `Function` -- this is important when using
// a type function as a generic argument, since otherwise when we try to get a
// unique key for the permuatation of type args including a type function, we would get
// an empty string for that arg, which would break the cache.
jsCompilationUnit.Body.Assign(Js.Reference("Function").Member(SpecialNames.TypeName), Js.Primitive("Function"));
}
// Declare assembly variable
var assemblyVariable = Js.Variable("$" + projectName.MaskSpecialCharacters() + "$Assembly", Js.Null());
jsCompilationUnit.Body.Local(assemblyVariable);
// Declare array to store all anonymous types
var anonymousTypes = Js.Variable(compilation.Assembly.GetAssemblyAnonymousTypesArray(), Js.Array());
jsCompilationUnit.Body.Local(anonymousTypes);
// Declare array to store all the type functions in the assembly
var assemblyTypes = Js.Variable(compilation.Assembly.GetAssemblyTypesArray(), Js.Array());
jsCompilationUnit.Body.Local(assemblyTypes);
// Build $GetAssemblyMethod, which lazily creates a new Assembly instance
var globalIdioms = new Idioms(null);
var getAssembly = Js.Function();
getAssembly.Body.If(
assemblyVariable.GetReference().EqualTo(Js.Null()),
assemblyVariable.GetReference().Assign(globalIdioms.CreateAssembly(compilation.Assembly, assemblyTypes.GetReference()))
);
getAssembly.Body.Return(assemblyVariable.GetReference());
jsCompilationUnit.Body.Assign(
Js.Reference(compilation.Assembly.GetAssemblyMethodName()),
getAssembly);
// Declare $assembly variable
jsCompilationUnit.Body.Local(SpecialNames.Assembly, Js.Reference(compilation.Assembly.GetAssemblyMethodName()));
jsCompilationUnit.Body.Assign(Js.Reference(SpecialNames.Assembly).Member(SpecialNames.AssemblyTypesArray), assemblyTypes.GetReference());
// Add $GetAssemblyMethod to global assemblies array
jsCompilationUnit.Body.Express(Js.Reference(SpecialNames.Assemblies).Member("push").Invoke(Js.Reference(SpecialNames.Assembly)));
// Builds out all the namespace objects. Types live inside namepsaces, which are represented as
// nested Javascript objects. For example, System.Text.StringBuilder is represented (in part) as:
//
// System = {};
// System.Text = {};
// System.Text.StringBuilder = function() { ... }
//
// This allows access to classes using dot notation in the expected way.
Profiler.Time("Transforming namespaces", () =>
{
var namespaceTransformer = new NamespaceTransformer(jsCompilationUnit.Body);
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var compilationUnit = (CompilationUnitSyntax)syntaxTree.GetRoot();
compilationUnit.Accept(namespaceTransformer);
}
});
var actions = new List <Tuple <INamedTypeSymbol, Action> >();
Profiler.Time("Get diagnostics", () =>
{
var diagnostics = compilation.GetDiagnostics();
foreach (var diagnostic in diagnostics)
{
if (diagnostic.Severity == DiagnosticSeverity.Error)
{
Console.WriteLine("// " + diagnostic);
}
}
});
// Check for partial classes
Profiler.Time("Reassemble partial classes", () =>
{
var partialClassReassembler = new PartialClassReassembler(project, compilation);
compilation = partialClassReassembler.UnifyPartialTypes();
});
/*
* // Write out all type functions in inheritance order. This allows for complex references between types and
* // nested types.
* Profiler.Time("Write out type function declarations", () =>
* {
* var allTypeDeclarations = new List<INamedTypeSymbol>();
* foreach (var syntaxTree in compilation.SyntaxTrees)
* {
* var semanticModel = compilation.GetSemanticModel(syntaxTree);
* var compilationUnit = (CompilationUnitSyntax)syntaxTree.GetRoot();
* var typeDeclarations = GetTypeDeclarations(compilationUnit);
* var types = typeDeclarations.Select(x => semanticModel.GetDeclaredSymbol(x)).ToArray();
* allTypeDeclarations.AddRange(types);
* }
* SweepSort(allTypeDeclarations, x => x);
*
* jsCompilationUnit.Body.Express(Js.Reference(Context.Instance.SymbolNames[classType.ContainingNamespace, classType.ContainingNamespace.GetFullName()]).Member(classType.GetShortTypeName()),
* Js.Reference(SpecialNames.Define).Invoke(Js.Primitive(displayName), baseType));
* jsCompilationUnit.Assign(Js.Reference(Context.Instance.SymbolNames[classType.ContainingNamespace, classType.ContainingNamespace.GetFullName()]).Member(classType.GetShortTypeName()),
* Js.Reference(SpecialNames.Define).Invoke(Js.Primitive(displayName), baseType));
* });
*/
// Scan all syntax trees for anonymous type creation expressions. We transform them into class
// declarations with a series of auto implemented properties.
Profiler.Time("Running AnonymousTypeTransformer", () =>
{
var anonymousTypeTransformer = new AnonymousTypeTransformer(jsCompilationUnit.Body, actions);
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var compilationUnit = (CompilationUnitSyntax)syntaxTree.GetRoot();
compilationUnit.Accept(anonymousTypeTransformer);
}
});
// Iterate through all the syntax trees and add entries into `actions` that correspond to type
// declarations.
Profiler.Time("Preparing for core transformation process", () =>
{
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var compilationUnit = (CompilationUnitSyntax)syntaxTree.GetRoot();
var transformer = new JsTransformer(syntaxTree, semanticModel, jsCompilationUnit);
var typeCollector = new TypeCollector();
compilationUnit.Accept(typeCollector);
var typeDeclarations = typeCollector.TypeDeclarations.Where(x => x.GetContainingTypeDeclaration() == null);
var delegateDeclarations = typeCollector.DelegateDeclarations.Where(x => x.GetContainingTypeDeclaration() == null);
foreach (var type in typeDeclarations)
{
var _type = type;
var typeSymbol = semanticModel.GetDeclaredSymbol(type);
Action action = () =>
{
var statements = (JsBlockStatement)_type.Accept(transformer);
jsCompilationUnit.Body.Aggregate(statements);
};
actions.Add(Tuple.Create(typeSymbol, action));
}
foreach (var type in delegateDeclarations)
{
var _type = type;
Action action = () =>
{
var statements = (JsBlockStatement)_type.Accept(transformer);
jsCompilationUnit.Body.Aggregate(statements);
};
actions.Add(Tuple.Create((INamedTypeSymbol)ModelExtensions.GetDeclaredSymbol(semanticModel, type), action));
}
}
});
// Sort all the type declarations such that base types always come before subtypes.
Profiler.Time("Sorting transformers", () => SweepSort(actions, x => x.Item1));
var transformationActions = actions.Select(x => x.Item2).ToArray();
Profiler.Time("Applying core transformation", () =>
{
foreach (var item in transformationActions)
{
item();
}
});
// Create cultures based on installed .NET cultures. Presumably this is the same regardless
// of the platform that compiled this assembly. Only do this for the standard library.
if (projectName == "mscorlib" && !Context.Instance.Compilation.Assembly.IsCultureInfoExportDisabled())
{
foreach (var culture in CultureInfo.GetCultures(CultureTypes.AllCultures))
{
JsExpression target = new JsVariableReferenceExpression(Context.Instance.CultureInfo.GetTypeName()).Invoke().Member("RegisterCulture");
jsCompilationUnit.Body.Add(target.Invoke(new[]
{
Js.Literal(culture.Name),
Js.Literal(culture.DateTimeFormat.ShortDatePattern),
Js.Literal(culture.DateTimeFormat.LongDatePattern),
Js.Literal(culture.DateTimeFormat.ShortTimePattern),
Js.Literal(culture.DateTimeFormat.LongTimePattern),
Js.Literal(culture.DateTimeFormat.FullDateTimePattern),
Js.Literal(culture.DateTimeFormat.YearMonthPattern),
Js.Array(culture.DateTimeFormat.MonthNames.Select(x => Js.Literal(x)).ToArray()),
Js.Array(culture.DateTimeFormat.AbbreviatedMonthNames.Select(x => Js.Literal(x)).ToArray()),
Js.Array(culture.DateTimeFormat.DayNames.Select(x => Js.Literal(x)).ToArray())
}).Express());
}
}
// If the project type is a console application, then invoke the Main method at the very
// end of the file.
var entryPoint = Context.Instance.Compilation.GetEntryPoint(CancellationToken.None);
if (entryPoint != null)
{
jsCompilationUnit.Body.Express(globalIdioms.InvokeStatic(entryPoint));
}
// Test minification
// var minifier = new JsMinifier();
// jsCompilationUnit.Accept(minifier);
}
public AsyncExpressionDecomposer(AsyncStateGenerator stateGenerator, Idioms idioms) : base(idioms)
{
this.stateGenerator = stateGenerator;
}
public AsyncStateGenerator(Idioms idioms, JsBlockStatement stateMachineBody, CSharpSyntaxNode node, IMethodSymbol method, Action <BaseStateGenerator, JsTransformer> nodeAcceptor = null) :
base(x => new AsyncExpressionDecomposer((AsyncStateGenerator)x, idioms), node, stateMachineBody, idioms, method, nodeAcceptor)
{
}
// public const string current = "$current";
public YieldStateGenerator(Func <BaseStateGenerator, JsTransformer> transformer, CSharpSyntaxNode node, JsBlockStatement stateMachineBody, Idioms idioms, IMethodSymbol method) : base(transformer, node, stateMachineBody, idioms, method)
{
}
public ExpressionTreeTransformer(SemanticModel model, Idioms idioms)
{
this.model = model;
this.idioms = idioms;
this.parameterVariables = new Dictionary <string, string>();
}
public async Task <Tuple <string, Project> > Compile(string projectFile)
{
var projectFileInfo = new FileInfo(projectFile);
var projectFolder = projectFileInfo.Directory.FullName;
// These two lines are just a weird hack because you get no files back from compilation.SyntaxTrees
// if the user file isn't modified. Not sure why that's happening.
var projectUserFile = projectFolder + "\\" + projectFileInfo.Name + ".user";
if (File.Exists(projectUserFile))
{
File.SetLastWriteTime(projectUserFile, DateTime.Now);
}
var project = await MSBuildWorkspace.Create().OpenProjectAsync(projectFile);
var projectName = project.AssemblyName;
Compilation compilation = await project.GetCompilationAsync();
Context.Update(project.Solution, project, compilation);
// Check for yield
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var compilationUnit = (CompilationUnitSyntax)syntaxTree.GetRoot();
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var yieldGenerator = new YieldGenerator(compilation, syntaxTree, semanticModel);
compilationUnit = (CompilationUnitSyntax)compilationUnit.Accept(yieldGenerator);
compilation = compilation.ReplaceSyntaxTree(syntaxTree, SyntaxFactory.SyntaxTree(compilationUnit, syntaxTree.FilePath));
}
compilation = compilation.Clone();
Context.Update(project.Solution, project, compilation);
// After the basic transformation happens, we need to fix up some references afterward
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var compilationUnit = (CompilationUnitSyntax)syntaxTree.GetRoot();
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var yieldFixer = new YieldGeneratorFixer(compilation, syntaxTree, semanticModel);
compilationUnit = (CompilationUnitSyntax)compilationUnit.Accept(yieldFixer);
compilation = compilation.ReplaceSyntaxTree(syntaxTree, SyntaxFactory.SyntaxTree(compilationUnit, syntaxTree.FilePath));
}
Context.Update(project.Solution, project, compilation);
// Check for async
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var compilationUnit = (CompilationUnitSyntax)syntaxTree.GetRoot();
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var asyncGenerator = new AsyncGenerator(compilation, syntaxTree, semanticModel);
compilationUnit = (CompilationUnitSyntax)compilationUnit.Accept(asyncGenerator);
compilation = compilation.ReplaceSyntaxTree(syntaxTree, SyntaxFactory.SyntaxTree(compilationUnit, syntaxTree.FilePath));
}
Context.Update(project.Solution, project, compilation);
var jsCompilationUnit = new JsCompilationUnit {
UseStrict = true
};
// If this is the runtime prjoect, declare the array to hold all the GetAssembly functions (this .js file
// will be loaded first, and we only want to bother creating the array once.
if (projectName == "mscorlib")
{
var assemblies = Js.Variable(SpecialNames.Assemblies, Js.Array());
jsCompilationUnit.Body.Local(assemblies);
// This ensures that Function.$typeName returns `Function` -- this is important when using
// a type function as a generic argument, since otherwise when we try to assembly a
// unique key for the permuatation of type args including a type function, we would get
// an empty string for that arg, which would break the cache.
jsCompilationUnit.Body.Assign(Js.Reference("Function").Member(SpecialNames.TypeName), Js.Primitive("Function"));
}
// Declare assembly variable
var assemblyVariable = Js.Variable("$" + projectName.MaskSpecialCharacters() + "$Assembly", Js.Null());
jsCompilationUnit.Body.Local(assemblyVariable);
// Declare array to store all anonymous types
var anonymousTypes = Js.Variable(compilation.Assembly.GetAssemblyAnonymousTypesArray(), Js.Array());
jsCompilationUnit.Body.Local(anonymousTypes);
// Declare array to store all the type functions in the assembly
var assemblyTypes = Js.Variable(compilation.Assembly.GetAssemblyTypesArray(), Js.Array());
jsCompilationUnit.Body.Local(assemblyTypes);
// Build $GetAssemblyMethod, which lazily creates a new Assembly instance
var globalIdioms = new Idioms(null);
var getAssembly = Js.Function();
getAssembly.Body.If(
assemblyVariable.GetReference().EqualTo(Js.Null()),
assemblyVariable.GetReference().Assign(globalIdioms.CreateAssembly(compilation.Assembly, assemblyTypes.GetReference()))
);
getAssembly.Body.Return(assemblyVariable.GetReference());
jsCompilationUnit.Body.Assign(
Js.Reference(compilation.Assembly.GetAssemblyMethodName()),
getAssembly);
// Add $GetAssemblyMethod to global assemblies array
jsCompilationUnit.Body.Express(Js.Reference("$assemblies").Member("push").Invoke(Js.Reference(compilation.Assembly.GetAssemblyMethodName())));
// Builds out all the namespace objects. Types live inside namepsaces, which are represented as
// nested Javascript objects. For example, System.Text.StringBuilder is represented (in part) as:
//
// System = {};
// System.Text = {};
// System.Text.StringBuilder = function() { ... }
//
// This allows access to classes using dot notation in the expected way.
var namespaceTransformer = new NamespaceTransformer(jsCompilationUnit.Body);
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var compilationUnit = (CompilationUnitSyntax)syntaxTree.GetRoot();
compilationUnit.Accept(namespaceTransformer);
}
var actions = new List <Tuple <INamedTypeSymbol, Action> >();
// Scan all syntax trees for anonymous type creation expressions. We transform them into class
// declarations with a series of auto implemented properties.
var anonymousTypeTransformer = new AnonymousTypeTransformer(jsCompilationUnit.Body, actions);
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var compilationUnit = (CompilationUnitSyntax)syntaxTree.GetRoot();
compilationUnit.Accept(anonymousTypeTransformer);
}
var diagnostics = compilation.GetDiagnostics();
foreach (var diagnostic in diagnostics)
{
Console.WriteLine("// " + diagnostic);
}
// Iterate through all the syntax trees and add entries into `actions` that correspond to type
// declarations.
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var compilationUnit = (CompilationUnitSyntax)syntaxTree.GetRoot();
var transformer = new JsTransformer(syntaxTree, semanticModel);
var typeDeclarations = GetTypeDeclarations(compilationUnit);
foreach (var type in typeDeclarations)
{
Action action = () =>
{
var statements = (JsBlockStatement)type.Accept(transformer);
jsCompilationUnit.Body.Aggregate(statements);
};
actions.Add(Tuple.Create((INamedTypeSymbol)ModelExtensions.GetDeclaredSymbol(semanticModel, type), action));
}
var delegateDeclarations = GetDelegates(compilationUnit);
foreach (var type in delegateDeclarations)
{
Action action = () =>
{
var statements = (JsBlockStatement)type.Accept(transformer);
jsCompilationUnit.Body.Aggregate(statements);
};
actions.Add(Tuple.Create((INamedTypeSymbol)ModelExtensions.GetDeclaredSymbol(semanticModel, type), action));
}
}
// Sort all the type declarations such that base types always come before subtypes.
SweepSort(actions);
foreach (var item in actions)
{
item.Item2();
}
// If the project type is a console application, then invoke the Main method at the very
// end of the file.
var entryPoint = compilation.GetEntryPoint(CancellationToken.None);
if (entryPoint != null)
{
jsCompilationUnit.Body.Express(globalIdioms.InvokeStatic(entryPoint));
}
// Test minification
// var minifier = new JsMinifier();
// jsCompilationUnit.Accept(minifier);
// Write out the compiled Javascript file to the target location.
var renderer = new JsRenderer();
jsCompilationUnit.Accept(renderer);
return(Tuple.Create(renderer.Output, project));
}
public AnonymousTypeTransformer(JsBlockStatement body, List <Tuple <INamedTypeSymbol, Action> > actions)
{
this.body = body;
this.actions = actions;
this.idioms = new Idioms(null);
}
public override void VisitTryStatement(TryStatementSyntax node)
{
var afterTry = GetNextState();
var newTryStatement = Js.Try();
var tryState = NewSubstate();
GotoState(tryState);
// Keep track of exception, if any, so we can rethrow
var exceptionIdentifier = HoistVariable(new LiftedVariableKey("$ex"));
var exceptionVariable = UniqueName("$caughtex");
State finallyState = node.Finally == null ? null : GetNextState();
// Declare a block to store all the catch statements the try statement's only catch clause. (No
// type-specific catch clauses in Javascript
var catchBlock = Js.Block();
// Make sure that the exception is stored in a variable accessible to the entire state machine.
catchBlock.Express(exceptionIdentifier.GetReference().Assign(Js.Reference(exceptionVariable)));
foreach (var catchClause in node.Catches)
{
// Get the symbol that represents the exception declaration (identifier and type)
var symbol = Transformer.Model.GetDeclaredSymbol(catchClause.Declaration);
var exceptionType = symbol == null ? null : symbol.Type;
if (exceptionType == null && catchClause.Declaration != null && catchClause.Declaration.Type != null)
{
exceptionType = (ITypeSymbol)Transformer.Model.GetSymbolInfo(catchClause.Declaration.Type).Symbol;
}
// True if it is actually declaring the variable (as opposed to a catch clause that specifies
// merely an exception type
var hasDeclaration = catchClause.Declaration.Identifier.Kind() != SyntaxKind.None;
// A variable to store the new unique identifier to store the exception
IJsDeclaration newIdentifier;
// Hoist the variable into a field
if (hasDeclaration)
{
newIdentifier = HoistVariable(new LiftedVariableKey(catchClause.Declaration.Identifier, symbol));
}
else
{
newIdentifier = HoistVariable(new LiftedVariableKey(SyntaxFactory.Identifier("ex")));
}
// Collect all the catch statements into the catchState by making that state current
var catchState = GetNextState();
CurrentState = catchState;
AcceptStatement(catchClause.Block);
// Add onto the catch state some commands to go to the next state.
if (finallyState != null)
{
GotoState(finallyState);
}
else
{
GotoState(afterTry);
}
// Create the statements that will live in the actual catch handler, which directs the logic
// to the actual catch state and also stores the exception in the correct identifier.
var thisCatchStatements = Js.Block();
thisCatchStatements.Express(newIdentifier.SetReference().Assign(exceptionIdentifier.GetReference()));
// Apply filter if present
if (catchClause.Filter != null)
{
var filter = (JsExpression)catchClause.Filter.FilterExpression.Accept(Transformer);
thisCatchStatements.Add(Js.If(filter, Js.Block(GotoStateStatements(catchState))));
}
else
{
thisCatchStatements.AddRange(GotoStateStatements(catchState));
}
// Only do the above if the current exception is of the type expected by the catch handler.
var condition = Idioms.Is(exceptionIdentifier.GetReference(), exceptionType);
catchBlock.Add(Js.If(condition, thisCatchStatements));
}
if (node.Finally != null)
{
// Collect the statements of the finally block into the finally state
CurrentState = finallyState;
AcceptStatement(node.Finally.Block);
// If the exception object is not null, then rethrow it. In other words, if this is a finally
// clause that has responded to an exception, we need to propagate the exception rather than
// continue after the try statement. Otherwise, go to the code after the try block.
CurrentState.Add(Js.If(exceptionIdentifier.GetReference().NotEqualTo(Js.Null()),
Js.Throw(exceptionIdentifier.GetReference()),
Js.Block(GotoStateStatements(afterTry))));
// Finally, at the very end of the catch clause (and we can only get here if the logic didn't break
// out as it would with the logic in the catch handlers) go to the finally state.
catchBlock.AddRange(GotoStateStatements(finallyState).ToArray());
}
catchBlock.Add(Js.Throw(exceptionIdentifier.GetReference()));
newTryStatement.Catch = Js.Catch(Js.Variable(exceptionVariable));
newTryStatement.Catch.Body = catchBlock;
tryState.Wrap = switchStatement =>
{
newTryStatement.Body = Js.Block(switchStatement);
return(newTryStatement);
};
StartSubstate(tryState);
AcceptStatement(node.Block);
if (node.Finally != null)
{
GotoState(finallyState);
}
else
{
GotoState(afterTry);
}
EndSubstate();
CurrentState = afterTry;
}
private void StreamReaderAll(StreamReader sr)
{
//$"{name}数据量比较大{sr.BaseStream.Length}BS，初始化数据需要一些时间，请耐心等待".WriteInfoLine(ConsoleColor.Cyan);
long lineCount = 0;
var dt0 = DateTime.Now;
while (!sr.EndOfStream)
{
var line = sr.ReadLine();
if (line == "")
{
continue; //空行
}
lineCount++;
WordInfoOnce w = null;
string[] keys = new string[0];
if (line.StartsWith("{"))
{
w = JsonConvert.DeserializeObject <WordInfoOnce>(line);
}
else
{
if (line.IndexOf('\t') > 0)
{
keys = line.Split('\t');
}
else
{
keys = line.Split(' ');
}
if (keys.Length >= 8)
{
//sw.WriteLine($"{w.w}\t{w.f}\t{w.p}\t{w.l}\t{w.o}\t{w.py}\t{w.isp}\t{w.pt}");
w = new WordInfoOnce()
{
w = keys[0],
f = string.IsNullOrEmpty(keys[1]) ? 0 : double.Parse(keys[1]),
p = keys[2],
l = keys[3],
o = string.IsNullOrEmpty(keys[4]) ? null : (byte?)byte.Parse(keys[4]),
py = keys[5],
isp = string.IsNullOrEmpty(keys[4]) ? null : (bool?)bool.Parse(keys[6]),
pt = keys[7],
};
}
else if (keys.Length > 3)
{
w = new WordInfoOnce()
{
w = string.Join(" ", keys.Take(keys.Length - 2)),
p = keys[keys.Length - 1],
};
double d = 0;
var b = double.TryParse(keys[keys.Length - 2], out d);
if (!b)
{
b = double.TryParse(keys[1], out d);
}
w.f = d;
}
else if (keys.Length == 3)
{
w = new WordInfoOnce()
{
w = keys[0],
p = keys[2],
};
double d = 0;
var b = double.TryParse(keys[1], out d);
w.f = d;
}
else if (keys.Length == 2)
{
w = new WordInfoOnce()
{
w = keys[0],
};
double d = 0;
var b = double.TryParse(keys[1], out d);
w.f = d;
}
else
{
w = new WordInfoOnce()
{
w = keys[0],
};
}
}
//分文件
if (name == "词典" || name == "临时")
{
//Console.Write($"{name}.");
if (name != ("成语") && w.p?.StartsWith("i", StringComparison.OrdinalIgnoreCase) == true)
{
Idioms.AddNew(w.w, w); //成语词典
}
else if (name != ("人名") && w.p?.StartsWith("nr", StringComparison.OrdinalIgnoreCase) == true)
{
PersonNames.AddNew(w.w, w); //人名词典
}
else if (name != ("地名") && w.p?.StartsWith("ns", StringComparison.OrdinalIgnoreCase) == true)
{
PlaceNames.AddNew(w.w, w); //地名词典
}
else//词典或临时
{
if (!base.ContainsKey(w.w))
{
base.Add(w.w, w);
}
else if (!base.ContainsKey(w.Key))
{
var item = base[w.w];
if (item.p != w.p)
{
base.Add(w.Key, w.SetKeyType(KeyType.Key));
}
}
}
}
else
{
if (!base.ContainsKey(w.w))
{
base.Add(w.w, w);
}
else if (!base.ContainsKey(w.Key))
{
var item = base[w.w];
if (item.p != w.p)
{
base.Add(w.Key, w.SetKeyType(KeyType.Key));
}
}
}
//3秒提醒
if (lineCount % 1000 == 0 && DateTime.Now.AddSeconds(-3) > dt0)
{
dt0 = DateTime.Now;
$"{name}已完成{lineCount}".WriteInfoLine(ConsoleColor.Cyan);
}
}
if (this.Count != lineCount)
{
savetimes++; //保存
}
}
