internal void Commit() { try { // non-greedy so they are all reset if (!Prefixes.HasChanges(true) & !Suffixes.HasChanges(true) & !Transpilers.HasChanges(true) & !PostTranspilers.HasChanges(true)) { return; } Revert(); if (Prefixes.Count == 0 && Suffixes.Count == 0 && Transpilers.Count == 0 && PostTranspilers.Count == 0) { return; } _log.Log(PrintMsil ? LogLevel.Info : LogLevel.Debug, $"Begin patching {_method.DeclaringType?.FullName}#{_method.Name}({string.Join(", ", _method.GetParameters().Select(x => x.ParameterType.Name))})"); var patch = ComposePatchedMethod(); _revertAddress = AssemblyMemory.GetMethodBodyStart(_method); var newAddress = AssemblyMemory.GetMethodBodyStart(patch); _revertData = AssemblyMemory.WriteJump(_revertAddress, newAddress); _pinnedPatch = GCHandle.Alloc(patch); _log.Log(PrintMsil ? LogLevel.Info : LogLevel.Debug, $"Done patching {_method.DeclaringType?.FullName}#{_method.Name}({string.Join(", ", _method.GetParameters().Select(x => x.ParameterType.Name))})"); } catch (Exception exception) { _log.Fatal(exception, $"Error patching {_method.DeclaringType?.FullName}#{_method}"); throw; } }
public Language Read() { var sw = new Stopwatch(); sw.Start(); _orthography = ReadOrthography(); Debug.Print($"orthograpy: {sw.ElapsedMilliseconds} ms"); sw.Restart(); Morphotactics morphotactics = ReadMorphotactics(); Debug.Print($"morphotactics: {sw.ElapsedMilliseconds} ms"); sw.Restart(); MorphemeSurfaceDictionary <Root> roots = ReadRoots(); Debug.Print($"roots: {sw.ElapsedMilliseconds} ms"); sw.Restart(); Suffixes suffixes = ReadSuffixes(); Debug.Print($"suffixes: {sw.ElapsedMilliseconds} ms"); sw.Restart(); int index = _dirPath.LastIndexOf("\\", StringComparison.Ordinal); string langCode = index > -1 ? _dirPath.Substring(index + 1) : _dirPath; return(new Language(langCode, morphotactics, roots, suffixes)); }
private void GetAppFromDirectory(string path, List <Program> list, int depth) { if (MaxDepth != -1 && depth > MaxDepth) { return; } try { foreach (var file in Directory.GetFiles(path)) { if (Suffixes.Any(o => file.EndsWith("." + o))) { var p = CreateEntry(file); p.Source = this; list.Add(p); } } foreach (var subDirectory in Directory.GetDirectories(path)) { GetAppFromDirectory(subDirectory, list, depth + 1); } } catch (Exception e) { var woxPluginException = new WoxPluginException("Program", $"GetAppFromDirectory failed: {path}", e); Log.Exception(woxPluginException); } }
/// <summary> /// Default constructor. /// </summary> public NameParser() { // Populate CorpIDs list. CorpIDs.Add("&"); CorpIDs.Add(" Corp."); CorpIDs.Add(" Corporation"); CorpIDs.Add(" Llc."); CorpIDs.Add(" Llp."); CorpIDs.Add(" Limited"); CorpIDs.Add(" Co."); CorpIDs.Add(" Company"); CorpIDs.Add("Firm"); CorpIDs.Add("Associates"); // Populate Suffixes list. Suffixes.Add("I"); Suffixes.Add("II"); Suffixes.Add("III"); Suffixes.Add("Jr."); Suffixes.Add("Sr."); // Populate Titles list. Titles.Add("Dr."); Titles.Add("Miss"); Titles.Add("Mrs."); Titles.Add("Mr."); Titles.Add("Ms."); Titles.Add("Prof."); }
public void AddSuffix(string text, Color color) { if (Suffixes.Contains(text)) { throw new Exception($"Suffix with name '{text}' already exists!"); } Suffixes.Add(text, new Title(text, color)); VisibleItems++; }
public void RemoveSuffix(string text) { if (!Suffixes.Contains(text)) { return; } Suffixes.Remove(text); VisibleItems--; }
/// <summary> /// Determines whether <see cref="piece"/> is a given name component as opposed to an affix, initial or title. /// </summary> /// <param name="piece">A single word from a name</param> /// <returns>False if <see cref="piece"/> is a prefix (de, abu, bin), suffix (jr, iv, cpa), title (mr, pope), or initial (x, e.); true otherwise</returns> private static bool IsRootname(string piece) { var lcPiece = piece.ToLower().Replace(".", string.Empty); return(!Suffixes.Contains(lcPiece) && !Prefixes.Contains(lcPiece) && !Titles.Contains(lcPiece) && !IsAnInitial(piece)); }
internal Language(string code, Morphotactics morphotactics, MorphemeSurfaceDictionary <Root> roots, Suffixes suffixes) { _code = code; Morphotactics = morphotactics; _roots = roots; _suffixes = suffixes; }
void LoadTags(XmlNode root) { foreach (XmlNode node in root.ChildNodes) { if (node is XmlComment) { continue; } Suffixes.Add(node.Attributes["name"].Value); } }
/// <summary> /// Produz o nome completo da versão, na forma: /// - X.X.X-sufixoX_rX /// Ou apenas a parte escolhida. /// Sendo: /// - X /// Um número qualquer. /// - X.X.X /// Obrigatório. /// Número de versão do aplicativo. /// - sufixoX /// Opcional. /// O nome da versão, como alfa, beta, trunk, etc. /// Seguido opcionalmente de um número de revisão do sufixo. /// - rX /// Opcional. /// O número de revisão no repositório de código fonte. /// </summary> /// <param name="parts"> /// As partes extras de versão escolhidas. /// </param> public string ToString(Suffixes parts) { var text = string.Join(".", Major, Minor, Patch); if (parts.HasFlag(Suffixes.PreRelease) && PreRelease != null) { text += $"-{PreRelease}"; } if (parts.HasFlag(Suffixes.Revision) && Revision > 0) { text += $"_r{Revision}"; } return text; }
/// <summary> /// Produz o nome completo da versão, na forma: /// - X.X.X-sufixoX_rX /// Ou apenas a parte escolhida. /// Sendo: /// - X /// Um número qualquer. /// - X.X.X /// Obrigatório. /// Número de versão do aplicativo. /// - sufixoX /// Opcional. /// O nome da versão, como alfa, beta, trunk, etc. /// Seguido opcionalmente de um número de revisão do sufixo. /// - rX /// Opcional. /// O número de revisão no repositório de código fonte. /// </summary> /// <param name="parts"> /// As partes extras de versão escolhidas. /// </param> public string ToString(Suffixes parts) { var text = FormattedNumber; if (parts.HasFlag(Suffixes.PreRelease)) { text += FormattedPreRelease; } if (parts.HasFlag(Suffixes.Revision)) { text += FormattedRevision; } return(text); }
public TestClass() { AccModTest = new AccessModifierTest(); ArrTest = new ArrayTest(); ETest = new EnumTest(); IdentTest = new IdentifierTest(); MethTest = new MethodTest(); SpecExpTest = new SpecialExpressionsTest(); AssignTest = new AssignmentTest(); OpEqTest = new OpEqTest(); Suffixes = new Suffixes(); Constants = new TermConstants(); Override = new OverrideTest(); OpOver1 = new OpOverload(); OpOver2 = new OpOverload(); }
public override async Task Initialize() { FirstName = Prospect.FirstName; LastName = Prospect.LastName; MiddleName = Prospect.MiddleName; NickName = Prospect.NickName; StreetAddress = Prospect.StreetAddress == null ? new StreetAddress() : Prospect.StreetAddress.ShallowCopy(); FollowUpSettings = Prospect.FollowUpSettings.ShallowCopy(); MobilePhone = Prospect.MobilePhoneNumber == null ? new PhoneNumber() : Prospect.MobilePhoneNumber.ShallowCopy(); WorkPhone = Prospect.WorkPhoneNumber == null ? new PhoneNumber() : Prospect.WorkPhoneNumber.ShallowCopy(); HomePhone = Prospect.HomePhoneNumber == null ? new PhoneNumber() : Prospect.HomePhoneNumber.ShallowCopy(); Email = Prospect.Email == null ? new Email() : Prospect.Email.ShallowCopy(); _originalProspect = Prospect.ShallowCopy(); _originalProspect.FollowUpSettings = FollowUpSettings.ShallowCopy(); _originalProspect.StreetAddress = StreetAddress.ShallowCopy(); _originalProspect.MobilePhoneNumber = MobilePhone.ShallowCopy(); _originalProspect.WorkPhoneNumber = WorkPhone.ShallowCopy(); _originalProspect.HomePhoneNumber = HomePhone.ShallowCopy(); _originalProspect.Email = Email.ShallowCopy(); Prefixes = (await _userDefinedCodeService.GetPrefixUserDefinedCodes()).ToObservableCollection(); ActivePrefix = Prefixes.FirstOrDefault(p => p.Description1 == Prospect.NamePrefix); Suffixes = (await _userDefinedCodeService.GetSuffixUserDefinedCodes()).ToObservableCollection(); ActiveSuffix = Suffixes.FirstOrDefault(p => p.Description1 == Prospect.NameSuffix); ContactPreferences = (await _userDefinedCodeService.GetContactPreferenceUserDefinedCodes()).ToObservableCollection(); ActiveContactPreference = ContactPreferences.FirstOrDefault(p => p.Description1 == Prospect.FollowUpSettings.PreferredContactMethod); ExcludeReasons = (await _userDefinedCodeService.GetExcludeReasonUserDefinedCodes()).ToObservableCollection(); ActiveExcludeReason = ExcludeReasons.FirstOrDefault(p => p.Code == Prospect.FollowUpSettings.ExcludeReason); States = (await _userDefinedCodeService.GetStateUserDefinedCodes()).ToObservableCollection(); ActiveState = Prospect.StreetAddress != null?States.FirstOrDefault(p => p.Code == Prospect.StreetAddress.State) : null; Countries = (await _userDefinedCodeService.GetCountryUserDefinedCodes()).ToObservableCollection(); ActiveCountry = Prospect.StreetAddress != null?Countries.FirstOrDefault(p => p.Code == Prospect.StreetAddress.Country) : null; TrafficSources = (await _trafficSourceService.GetTrafficSourcesByDivision(Prospect.ProspectCommunity.Division)).ToObservableCollection(); ActiveTrafficSource = TrafficSources.FirstOrDefault(t => t.TrafficSourceDetails.Any(td => td.CodeId == Prospect.TrafficSourceCodeId)); if (ActiveTrafficSource != null) { ActiveTrafficSourceDetail = ActiveTrafficSource.TrafficSourceDetails.First(td => td.CodeId == Prospect.TrafficSourceCodeId); } }
/// <summary> /// Обновляет сборку. /// </summary> /// <param name="location">Новый путь.</param> /// <param name="number">Номер сборки.</param> /// <param name="releaseNumber">Номер релиза.</param> /// <param name="updatedSuffixes">Новые суффиксы.</param> /// <param name="changeDate">Дата изменения сборки.</param> public void Update(string location, VersionNumber releaseNumber, VersionNumber number, IList <string> updatedSuffixes, DateTime changeDate) { location.ThrowIsNullOrWhiteSpace(new UpdateBuildException("Location is null or empty.")); number.ThrowIfNull(new UpdateBuildException("Number must not be null")); ValidateReleaseNumber(releaseNumber, number, location); IList <string> newSuffixes = Suffixes.ToHashSet().SetEquals(updatedSuffixes) ? Suffixes : updatedSuffixes; if (location == Location && newSuffixes.SequenceEqual(Suffixes)) { return; } Apply(new BuildUpdated(location, number, releaseNumber, newSuffixes, CreateMetadata(changeDate))); UpdateArtifactState(ArtifactState.Updated); }
public override List <Program> LoadPrograms() { List <Program> list = new List <Program>(); foreach (var Folder in Directory.GetDirectories(BaseDirectory)) { list.Add(CreateEntry(Folder)); } foreach (string file in Directory.GetFiles(base.BaseDirectory)) { if (Suffixes.Any(o => file.EndsWith("." + o))) { list.Add(CreateEntry(file)); } } return(list); }
public override async Task Initialize() { _user = await _userService.GetLoggedInUser(); _originalCobuyer = Cobuyer.ShallowCopy(); _originalCobuyer.StreetAddress = StreetAddress.ShallowCopy(); _originalCobuyer.MobilePhoneNumber = MobilePhone.ShallowCopy(); _originalCobuyer.WorkPhoneNumber = WorkPhone.ShallowCopy(); _originalCobuyer.HomePhoneNumber = HomePhone.ShallowCopy(); _originalCobuyer.Email = Email.ShallowCopy(); Prefixes = (await _userDefinedCodeService.GetPrefixUserDefinedCodes()).ToObservableCollection(); ActivePrefix = Prefixes.FirstOrDefault(p => p.Description1 == Cobuyer.NamePrefix); Suffixes = (await _userDefinedCodeService.GetSuffixUserDefinedCodes()).ToObservableCollection(); ActiveSuffix = Suffixes.FirstOrDefault(p => p.Description1 == Cobuyer.NameSuffix); States = (await _userDefinedCodeService.GetStateUserDefinedCodes()).ToObservableCollection(); ActiveState = Cobuyer.StreetAddress != null?States.FirstOrDefault(p => p.Code == Cobuyer.StreetAddress.State) : null; Countries = (await _userDefinedCodeService.GetCountryUserDefinedCodes()).ToObservableCollection(); ActiveCountry = Cobuyer.StreetAddress != null?Countries.FirstOrDefault(p => p.Code == Cobuyer.StreetAddress.Country) : null; }
/// <summary> /// Tests to see if the string is a suffix and returns true if it is. In addition, /// it will provide a Formatted Version of a suffix for abbreviations. /// </summary> /// <param name="s">String to test.</param> /// <param name="formattedSuffix">String reference to pass formatted suffix.</param> /// <returns>True if string is a suffix; false if not.</returns> private bool isSuffix(string s, out string formattedSuffix) { foreach (string suffix in SimpleSuffixes) { if (s.ToUpper() == suffix.ToUpper()) { formattedSuffix = suffix; return(true); } } for (int x = 0; x <= Suffixes.GetUpperBound(0); x++) { if (s.ToUpper().Replace(".", string.Empty) == Suffixes[x, 0]) { formattedSuffix = Suffixes[x, 1]; return(true); } } formattedSuffix = s; return(false); }
public string Generate(uint modelId, string source) { var split = PreGenerate(modelId, source); if (split == null) { return(null); } split = Process(split); if (split == null) { return(null); } var last = split.Last(); if (Suffixes.Any(t => t.Equals(last)) == true) { split = Trim(split); } return(PostProcess(split)); }
private static bool IsSuffix(string piece) { return(Suffixes.Contains(piece.Replace(".", string.Empty).ToLower()) && !IsAnInitial(piece)); }
public void AddSuffixCodes(string suffix, params TypeCode[] codes) { SuffixTypeCodes.Add(suffix, codes); Suffixes.Add(suffix); }
public override void Execute() { College = new College(ProgID).Object; string[] suffixes = Suffixes.Split(','); List <LocationWrapper> locs = new List <LocationWrapper>(); double total = College.Locations.Count; double count = 0; foreach (var loc in College.Locations) { Progress = (int)Math.Round(100.0 * ++count / total); var suffix = suffixes.FirstOrDefault(s => loc.Name.EndsWith(s)); if (suffix != null) { locs.Add(new LocationWrapper(loc, suffix)); } } count = 0; foreach (var loc in College.Locations) { Progress = (int)Math.Round(100.0 * ++count / total); string name = loc.Name; if (locs.Any(l => l.NamePart == name)) { locs.Add(new LocationWrapper(loc, "")); } } Func <string, dynamic> findLoc = part => { string parentName = string.IsNullOrEmpty(MergeInto) ? part : locs.First(l => l.NamePart == part && l.Suffix == MergeInto).Name; var pLocs = College.Locations.Find(null, parentName); if (pLocs.Count == 0) { var zloc = locs.FirstOrDefault(l => l.NamePart == part && !l.HostKey.StartsWith("#")); if (zloc == null) { zloc = locs.FirstOrDefault(l => l.NamePart == part); } pLocs = College.Locations.Find(null, zloc.Name); } return(pLocs[1]); }; total = College.Activities.Count; count = 0; foreach (var act in College.Activities) { Progress = (int)Math.Round(100.0 * ++count / total); if (act.SchedulingStatus != 0) { continue; } var res = act.GetResourceAllocation(1); var resList = ToList(res); bool change = false; foreach (var loc in resList) { string locName = loc.Name; var tl = locs.FirstOrDefault(l => l.Name == locName); if (tl == null) { continue; } var parentLoc = findLoc(tl.NamePart); if (parentLoc.ObjectId == loc.ObjectId) { continue; } change = true; res.Remove(loc); res.Add(parentLoc); } if (!change) { continue; } var setting = College.CreateSchedulingResourceSetting(); setting.UseLocation = true; var reqType = act.GetLocationRequirementType; act.UnscheduleSpecialMany(setting); act.SetResourceRequirement(1, 1, res.Count, res); act.ScheduleSpecialMany(setting); if ((int)reqType != 1) { act.SetResourceRequirement(1, 2, res.Count, res); } //Log.Add(Description, "Reschedule", act); } total = College.Activities.Count; count = 0; foreach (var act in College.Activities) { Progress = (int)Math.Round(100.0 * ++count / total); if (act.GetResourceRequirementType(1) != 1) { continue; } var res = act.GetResourceRequirement(1); var resList = ToList(res); bool change = false; foreach (var loc in resList) { string locName = loc.Name; var tl = locs.FirstOrDefault(l => l.Name == locName); if (tl == null) { continue; } var parentLoc = findLoc(tl.NamePart); if (loc.ObjectId == parentLoc.ObjectId) { continue; } change = true; res.Remove(loc); res.Add(parentLoc); } if (!change) { continue; } //Log.Add(Description, "ChangePreset", act); act.SetResourceRequirement(1, 1, res.Count, res); } total = locs.Count; count = 0; foreach (var loc in locs) { Progress = (int)Math.Round(100.0 * ++count / total); var zloc = locs.FirstOrDefault(l => l.NamePart == loc.NamePart && !l.Name.EndsWith(")")); if (zloc == null) { zloc = locs.First(l => l.NamePart == loc.NamePart); } if (DeleteOthers && ((MergeInto != null && loc.Suffix != MergeInto) || (MergeInto == null && loc != zloc))) { College.DeleteLocation(loc.Location); } else if (RemoveSuffix) { loc.Location.Name = loc.NamePart; } } }
internal bool HasChanged() { return(Prefixes.HasChanges() || Suffixes.HasChanges() || Transpilers.HasChanges() || PostTranspilers.HasChanges()); }
public void AddSuffix(string suffix, params TypeCode[] typeCodes) { SuffixTypeCodes.Add(suffix, typeCodes); Suffixes.Add(suffix); }
private IEnumerable <MsilInstruction> EmitPatched(Func <Type, bool, MsilLocal> declareLocal) { var methodBody = _method.GetMethodBody(); Debug.Assert(methodBody != null, "Method body is null"); foreach (var localVar in methodBody.LocalVariables) { Debug.Assert(localVar.LocalType != null); declareLocal(localVar.LocalType, localVar.IsPinned); } var instructions = new List <MsilInstruction>(); var specialVariables = new Dictionary <string, MsilLocal>(); var labelAfterOriginalContent = new MsilLabel(); var labelSkipMethodContent = new MsilLabel(); Type returnType = _method is MethodInfo meth ? meth.ReturnType : typeof(void); MsilLocal resultVariable = null; if (returnType != typeof(void)) { if (Prefixes.Concat(Suffixes).SelectMany(x => x.GetParameters()).Any(x => x.Name == RESULT_PARAMETER) || Prefixes.Any(x => x.ReturnType == typeof(bool))) { resultVariable = declareLocal(returnType, false); } } if (resultVariable != null) { instructions.AddRange(resultVariable.SetToDefault()); } MsilLocal prefixSkippedVariable = null; if (Prefixes.Count > 0 && Suffixes.Any(x => x.GetParameters() .Any(y => y.Name.Equals(PREFIX_SKIPPED_PARAMETER)))) { prefixSkippedVariable = declareLocal(typeof(bool), false); specialVariables.Add(PREFIX_SKIPPED_PARAMETER, prefixSkippedVariable); } if (resultVariable != null) { specialVariables.Add(RESULT_PARAMETER, resultVariable); } // Create special variables foreach (var m in Prefixes.Concat(Suffixes)) { foreach (var param in m.GetParameters()) { if (param.Name.StartsWith(LOCAL_PARAMETER)) { var requiredType = param.ParameterType.IsByRef ? param.ParameterType.GetElementType() : param.ParameterType; if (specialVariables.TryGetValue(param.Name, out var existingParam)) { if (existingParam.Type != requiredType) { throw new ArgumentException( $"Trying to use injected local {param.Name} for {m.DeclaringType?.FullName}#{m.ToString()} with type {requiredType} but a local with the same name already exists with type {existingParam.Type}", param.Name); } } else { specialVariables.Add(param.Name, declareLocal(requiredType, false)); } } } } foreach (MethodInfo prefix in Prefixes) { instructions.AddRange(EmitMonkeyCall(prefix, specialVariables)); if (prefix.ReturnType == typeof(bool)) { instructions.Add(new MsilInstruction(OpCodes.Brfalse).InlineTarget(labelSkipMethodContent)); } else if (prefix.ReturnType != typeof(void)) { throw new Exception( $"Prefixes must return void or bool. {prefix.DeclaringType?.FullName}.{prefix.Name} returns {prefix.ReturnType}"); } } instructions.AddRange(MethodTranspiler.Transpile(_method, (x) => declareLocal(x, false), Transpilers, labelAfterOriginalContent)); instructions.Add(new MsilInstruction(OpCodes.Nop).LabelWith(labelAfterOriginalContent)); if (resultVariable != null) { instructions.Add(new MsilInstruction(OpCodes.Stloc).InlineValue(resultVariable)); } var notSkip = new MsilLabel(); instructions.Add(new MsilInstruction(OpCodes.Br).InlineTarget(notSkip)); instructions.Add(new MsilInstruction(OpCodes.Nop).LabelWith(labelSkipMethodContent)); if (prefixSkippedVariable != null) { instructions.Add(new MsilInstruction(OpCodes.Ldc_I4_1)); instructions.Add(new MsilInstruction(OpCodes.Stloc).InlineValue(prefixSkippedVariable)); } instructions.Add(new MsilInstruction(OpCodes.Nop).LabelWith(notSkip)); foreach (MethodInfo suffix in Suffixes) { instructions.AddRange(EmitMonkeyCall(suffix, specialVariables)); if (suffix.ReturnType != typeof(void)) { throw new Exception($"Suffixes must return void. {suffix.DeclaringType?.FullName}.{suffix.Name} returns {suffix.ReturnType}"); } } if (resultVariable != null) { instructions.Add(new MsilInstruction(OpCodes.Ldloc).InlineValue(resultVariable)); } instructions.Add(new MsilInstruction(OpCodes.Ret)); var result = MethodTranspiler.Transpile(_method, instructions, (x) => declareLocal(x, false), PostTranspilers, null).ToList(); if (result.Last().OpCode != OpCodes.Ret) { result.Add(new MsilInstruction(OpCodes.Ret)); } return(result); }
public void AddSuffix(string s) => Suffixes.Add(s);
/// <summary> /// Takes a string and find out whether that's a suffix. /// </summary> /// <param name="suffix">String to analyze.</param> /// <returns>Boolean indicating whether it's a suffix or not.</returns> protected bool IsSuffix(string suffix) { suffix = suffix.ToLower(CultureInfo.InvariantCulture); return(Suffixes.Cast <object>().Any(t => t.ToString().ToLower(CultureInfo.InvariantCulture) == suffix)); }
public bool RemoveSuffix(string s) => Suffixes.Remove(s);