From 824d8b5f30239b6520d303b9f5b351b6a631434d Mon Sep 17 00:00:00 2001 From: Dimitar Dobrev Date: Wed, 2 Oct 2013 19:31:58 +0300 Subject: [PATCH 1/6] Rewrote the generating of properties to additionaly handle property overrides and read-only properties. Signed-off-by: Dimitar Dobrev --- src/AST/Class.cs | 2 +- src/AST/Property.cs | 36 + src/Generator/Driver.cs | 1 + .../Generators/CSharp/CSharpTextTemplate.cs | 96 +- src/Generator/Passes/FindSymbolsPass.cs | 2 +- .../GenerateAbstractImplementationsPass.cs | 5 +- .../Passes/GetterSetterToPropertyPass.cs | 239 +- .../Passes/MultipleInheritancePass.cs | 12 +- src/Generator/Passes/RenamePass.cs | 12 +- src/Generator/Passes/verbs.txt | 8828 +++++++++++++++++ tests/Basic/Basic.Tests.cs | 10 +- tests/VTables/VTables.Tests.cs | 13 +- 12 files changed, 9130 insertions(+), 126 deletions(-) create mode 100644 src/Generator/Passes/verbs.txt diff --git a/src/AST/Class.cs b/src/AST/Class.cs index 04a136ae..30c4adaf 100644 --- a/src/AST/Class.cs +++ b/src/AST/Class.cs @@ -231,7 +231,7 @@ namespace CppSharp.AST public Property GetRootBaseProperty(Property @override, bool onlyFirstBase = false) { return (from @base in Bases - where !onlyFirstBase || !@base.Class.IsInterface + where (!onlyFirstBase || !@base.Class.IsInterface) && @base.IsClass let baseProperty = ( from property in @base.Class.Properties where diff --git a/src/AST/Property.cs b/src/AST/Property.cs index 50a34440..bad67004 100644 --- a/src/AST/Property.cs +++ b/src/AST/Property.cs @@ -28,6 +28,42 @@ namespace CppSharp.AST public QualifiedType QualifiedType { get; set; } + public bool IsStatic + { + get + { + return (GetMethod != null && GetMethod.IsStatic) || + (SetMethod != null && SetMethod.IsStatic); + } + } + + public bool IsPure + { + get + { + return (GetMethod != null && GetMethod.IsPure) || + (SetMethod != null && SetMethod.IsPure); + } + } + + public bool IsVirtual + { + get + { + return (GetMethod != null && GetMethod.IsVirtual) || + (SetMethod != null && SetMethod.IsVirtual); + } + } + + public bool IsOverride + { + get + { + return (GetMethod != null && GetMethod.IsOverride) || + (SetMethod != null && SetMethod.IsOverride); + } + } + public Method GetMethod { get; set; } public Method SetMethod { get; set; } diff --git a/src/Generator/Driver.cs b/src/Generator/Driver.cs index a700b2db..deca3f22 100644 --- a/src/Generator/Driver.cs +++ b/src/Generator/Driver.cs @@ -158,6 +158,7 @@ namespace CppSharp TranslationUnitPasses.AddPass(new MultipleInheritancePass()); TranslationUnitPasses.AddPass(new ParamTypeToInterfacePass()); } + TranslationUnitPasses.AddPass(new GetterSetterToPropertyPass()); } public void ProcessCode() diff --git a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs index 84ca66c6..984c1194 100644 --- a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs +++ b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs @@ -784,7 +784,6 @@ namespace CppSharp.Generators.CSharp { PushBlock(CSharpBlockKind.Method); WriteLine("set"); - WriteStartBraceIndent(); var param = new Parameter { @@ -801,7 +800,14 @@ namespace CppSharp.Generators.CSharp if (decl is Function) { var function = decl as Function; + if (function.IsPure && Driver.Options.GenerateAbstractImpls) + { + Write("; "); + PopBlock(NewLineKind.BeforeNextBlock); + return; + } + WriteStartBraceIndent(); if (function.Parameters.Count == 0) throw new NotSupportedException("Expected at least one parameter in setter"); @@ -810,16 +816,32 @@ namespace CppSharp.Generators.CSharp var method = function as Method; if (method != null && method.OperatorKind == CXXOperatorKind.Subscript) { - GenerateIndexerSetter(returnType, method); + if (method.IsOverride && method.IsSynthetized) + { + GenerateVirtualTableFunctionCall(function, @class); + } + else + { + if (method.OperatorKind == CXXOperatorKind.Subscript) + { + GenerateIndexerSetter(returnType, method); + } + else + { + var parameters = new List { param }; + GenerateInternalFunctionCall(function, parameters); + } + } } else { var parameters = new List { param }; - GenerateInternalFunctionCall(function, parameters); + GenerateInternalFunctionCall(function, parameters); } } else if (decl is Field) { + WriteStartBraceIndent(); var field = decl as Field; WriteLine("var {0} = (Internal*){1}.ToPointer();", @@ -865,22 +887,39 @@ namespace CppSharp.Generators.CSharp where T : Declaration, ITypedDecl { PushBlock(CSharpBlockKind.Method); - WriteLine("get"); - WriteStartBraceIndent(); + Write("get"); if (decl is Function) { var function = decl as Function; - bool isPrimitiveIndexer = function.OperatorKind == CXXOperatorKind.Subscript && - function.ReturnType.Type.IsPointerToPrimitiveType(); - if (isPrimitiveIndexer) - TypePrinter.PushContext(CSharpTypePrinterContextKind.PrimitiveIndexer); - GenerateInternalFunctionCall(function); - if (isPrimitiveIndexer) - TypePrinter.PopContext(); + if (function.IsPure && Driver.Options.GenerateAbstractImpls) + { + Write("; "); + PopBlock(NewLineKind.BeforeNextBlock); + return; + } + WriteLine(""); + WriteStartBraceIndent(); + Method method = function as Method; + if (method != null && method.IsOverride && method.IsSynthetized) + { + GenerateVirtualTableFunctionCall(function, @class); + } + else + { + bool isPrimitiveIndexer = function.OperatorKind == CXXOperatorKind.Subscript && + function.ReturnType.Type.IsPointerToPrimitiveType(); + if (isPrimitiveIndexer) + TypePrinter.PushContext(CSharpTypePrinterContextKind.PrimitiveIndexer); + GenerateInternalFunctionCall(function); + if (isPrimitiveIndexer) + TypePrinter.PopContext(); + } } else if (decl is Field) { + WriteLine(""); + WriteStartBraceIndent(); var field = decl as Field; WriteLine("var {0} = (Internal*){1}.ToPointer();", @@ -905,6 +944,8 @@ namespace CppSharp.Generators.CSharp } else if (decl is Variable) { + WriteLine(""); + WriteStartBraceIndent(); var @var = decl as Variable; var libSymbol = GetDeclarationLibrarySymbol(@var); @@ -990,10 +1031,22 @@ namespace CppSharp.Generators.CSharp type = ((PointerType) prop.Type).Pointee; if (prop.ExplicitInterfaceImpl == null) - WriteLine("{0}{1} {2}", Helpers.GetAccess(prop.Access), - type, GetPropertyName(prop)); + { + Write(Helpers.GetAccess(prop.Access)); + if (prop.IsStatic) + Write("static "); + if (prop.IsOverride) + Write("override "); + else if (prop.IsPure && Driver.Options.GenerateAbstractImpls) + Write("abstract "); + else if (prop.IsVirtual) + Write("virtual "); + WriteLine("{0} {1}", type, GetPropertyName(prop)); + } else + { WriteLine("{0} {1}.{2}", type, prop.ExplicitInterfaceImpl.Name, GetPropertyName(prop)); + } WriteStartBraceIndent(); if (prop.Field != null) @@ -1044,7 +1097,9 @@ namespace CppSharp.Generators.CSharp public void GenerateVTable(Class @class) { var entries = VTables.GatherVTableMethodEntries(@class); - entries = entries.Where(entry => !entry.Method.Ignore).ToList(); + entries = entries.Where(e => !e.Method.Ignore || + @class.Properties.Any(p => !p.Ignore && + (p.GetMethod == e.Method || p.SetMethod == e.Method))).ToList(); if (entries.Count == 0) return; @@ -1203,7 +1258,16 @@ namespace CppSharp.Generators.CSharp if (hasReturn) Write("var _ret = "); - WriteLine("target.{0}({1});", SafeIdentifier(method.Name), string.Join(", ", marshals)); + if (method.IsGenerated) + { + WriteLine("target.{0}({1});", SafeIdentifier(method.Name), string.Join(", ", marshals)); + } + else + { + var name = ((Class) method.Namespace).Properties.First( + p => p.GetMethod == method || p.SetMethod == method).Name; + WriteLine("target.{0};", name); + } // TODO: Handle hidden structure return types. diff --git a/src/Generator/Passes/FindSymbolsPass.cs b/src/Generator/Passes/FindSymbolsPass.cs index e7146d08..36d5ad51 100644 --- a/src/Generator/Passes/FindSymbolsPass.cs +++ b/src/Generator/Passes/FindSymbolsPass.cs @@ -12,7 +12,7 @@ namespace CppSharp.Passes var mangledDecl = decl as IMangledDecl; var method = decl as Method; - if (mangledDecl != null && !(method != null && method.IsPure) && + if (mangledDecl != null && !(method != null && (method.IsPure || method.IsSynthetized)) && !VisitMangledDeclaration(mangledDecl)) { decl.ExplicityIgnored = true; diff --git a/src/Generator/Passes/GenerateAbstractImplementationsPass.cs b/src/Generator/Passes/GenerateAbstractImplementationsPass.cs index a15d2c3d..81e2eb4a 100644 --- a/src/Generator/Passes/GenerateAbstractImplementationsPass.cs +++ b/src/Generator/Passes/GenerateAbstractImplementationsPass.cs @@ -57,7 +57,8 @@ namespace CppSharp.Passes { Name = abstractMethod.Name + "Delegate", QualifiedType = abstractMethod.GetFunctionType(), - IgnoreFlags = abstractMethod.IgnoreFlags + IgnoreFlags = abstractMethod.IgnoreFlags, + Namespace = internalImpl }; internalImpl.Typedefs.Add(@delegate); } @@ -79,7 +80,7 @@ namespace CppSharp.Passes var internalImpl = new Class { Name = @class.Name + "Internal", - Access = AccessSpecifier.Private, + Access = @class.Access, Namespace = @class.Namespace }; var @base = new BaseClassSpecifier { Type = new TagType(@class) }; diff --git a/src/Generator/Passes/GetterSetterToPropertyPass.cs b/src/Generator/Passes/GetterSetterToPropertyPass.cs index 3ad2ebbd..6e591fac 100644 --- a/src/Generator/Passes/GetterSetterToPropertyPass.cs +++ b/src/Generator/Passes/GetterSetterToPropertyPass.cs @@ -1,5 +1,8 @@ using System; +using System.Collections.Generic; +using System.IO; using System.Linq; +using System.Reflection; using CppSharp.AST; namespace CppSharp.Passes @@ -10,6 +13,12 @@ namespace CppSharp.Passes /// public class GetterSetterToPropertyPass : TranslationUnitPass { + private readonly List setters = new List(); + private readonly List setMethods = new List(); + private readonly List nonSetters = new List(); + private readonly HashSet getters = new HashSet(); + private readonly HashSet verbs = new HashSet(); + public GetterSetterToPropertyPass() { Options.VisitClassFields = false; @@ -21,123 +30,169 @@ namespace CppSharp.Passes Options.VisitNamespaceVariables = false; Options.VisitFunctionParameters = false; Options.VisitTemplateArguments = false; + using (var resourceStream = Assembly.GetExecutingAssembly() + .GetManifestResourceStream("CppSharp.Generator.Passes.verbs.txt")) + { + using (StreamReader streamReader = new StreamReader(resourceStream)) + while (!streamReader.EndOfStream) + verbs.Add(streamReader.ReadLine()); + } } - static bool IsSetter(Function method) + public override bool VisitTranslationUnit(TranslationUnit unit) { - var isRetVoid = method.ReturnType.Type.IsPrimitiveType( - PrimitiveType.Void); - - var isSetter = method.OriginalName.StartsWith("set", - StringComparison.InvariantCultureIgnoreCase); - - return isRetVoid && isSetter && method.Parameters.Count == 1; + bool result = base.VisitTranslationUnit(unit); + GenerateProperties(); + return result; } - static bool IsGetter(Function method) + public override bool VisitMethodDecl(Method method) { - var isRetVoid = method.ReturnType.Type.IsPrimitiveType( - PrimitiveType.Void); - - var isGetter = method.OriginalName.StartsWith("get", - StringComparison.InvariantCultureIgnoreCase); - - return !isRetVoid && isGetter && method.Parameters.Count == 0; + if (!method.IsConstructor && !method.IsDestructor && !method.IsOperator && + !method.Ignore) + DistributeMethod(method); + return base.VisitMethodDecl(method); } - Property GetOrCreateProperty(Class @class, string name, QualifiedType type) + public void GenerateProperties() { - var prop = @class.Properties.FirstOrDefault(property => property.Name == name - && property.QualifiedType.Equals(type)); - - var prop2 = @class.Properties.FirstOrDefault(property => property.Name == name); - - if (prop == null && prop2 != null) - Driver.Diagnostics.EmitWarning(DiagnosticId.PropertySynthetized, - "Property {0}::{1} already exist with type {2}", @class.Name, name, type.Type.ToString()); - - if (prop != null) - return prop; - - prop = new Property + GenerateProperties(setters, false); + GenerateProperties(setMethods, true); + + foreach (Method getter in + from getter in getters + where getter.IsGenerated && + ((Class) getter.Namespace).Methods.All(m => m == getter || m.Name != getter.Name) + select getter) { - Name = name, - Namespace = @class, - QualifiedType = type - }; - - @class.Properties.Add(prop); - return prop; + // Make it a read-only property + GenerateProperty(getter.Namespace, getter); + } } - public override bool VisitMethodDecl(Method method) + private void GenerateProperties(IEnumerable settersToUse, bool readOnly) { - if (AlreadyVisited(method)) - return false; - - if (ASTUtils.CheckIgnoreMethod(method)) - return false; - - var @class = method.Namespace as Class; - - if (@class == null || @class.IsIncomplete) - return false; - - if (IsGetter(method)) + foreach (var group in settersToUse.GroupBy(m => m.Namespace)) { - var name = method.Name.Substring("get".Length); - var prop = GetOrCreateProperty(@class, name, method.ReturnType); - prop.GetMethod = method; - prop.Access = method.Access; - - // Do not generate the original method now that we know it is a getter. - method.IsGenerated = false; - - Driver.Diagnostics.EmitMessage(DiagnosticId.PropertySynthetized, - "Getter created: {0}::{1}", @class.Name, name); - - return false; + foreach (var setter in group) + { + Class type = (Class) setter.Namespace; + string afterSet = setter.Name.Substring(3); + foreach (var getter in nonSetters.Where(m => m.Namespace == type)) + { + if (string.Compare(getter.Name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 && + getter.ReturnType == setter.Parameters[0].QualifiedType && + !type.Methods.Any( + m => + m != getter && + string.Compare(getter.Name, m.Name, StringComparison.OrdinalIgnoreCase) == 0)) + { + GenerateProperty(getter.Namespace, getter, readOnly ? null : setter); + goto next; + } + } + Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = afterSet }); + if (!type.IsInterface && baseVirtualProperty != null) + { + bool isReadOnly = baseVirtualProperty.SetMethod == null; + GenerateProperty(setter.Namespace, baseVirtualProperty.GetMethod, + readOnly || isReadOnly ? null : setter); + } + next: + ; + } } - - if (IsSetter(method) && IsValidSetter(method)) + foreach (Method nonSetter in nonSetters) { - var name = method.Name.Substring("set".Length); - - var type = method.Parameters[0].QualifiedType; - var prop = GetOrCreateProperty(@class, name, type); - prop.SetMethod = method; - prop.Access = method.Access; + Class type = (Class) nonSetter.Namespace; + string name = nonSetter.Name; + if (GetFirstWord(name) == "get") + name = name.Substring(3); + Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = name }); + if (!type.IsInterface && baseVirtualProperty != null) + { + bool isReadOnly = baseVirtualProperty.SetMethod == null; + if (readOnly == isReadOnly) + { + GenerateProperty(nonSetter.Namespace, nonSetter, + readOnly ? null : baseVirtualProperty.SetMethod); + } + } + } + } - // Ignore the original method now that we know it is a setter. - method.IsGenerated = false; + private static void GenerateProperty(DeclarationContext context, Method getter, Method setter = null) + { + Class type = (Class) context; + if (type.Properties.All( + p => string.Compare(getter.Name, p.Name, StringComparison.OrdinalIgnoreCase) != 0 || + p.ExplicitInterfaceImpl != getter.ExplicitInterfaceImpl)) + { + Property property = new Property(); + property.Name = getter.Name.Substring(GetFirstWord(getter.Name) == "get" ? 3 : 0); + property.Namespace = type; + property.QualifiedType = getter.ReturnType; + if (getter.IsOverride || (setter != null && setter.IsOverride)) + { + Property baseVirtualProperty = type.GetRootBaseProperty(property); + if (baseVirtualProperty.SetMethod == null) + setter = null; + foreach (Method method in type.Methods.Where(m => m.Name == property.Name && m.Parameters.Count > 0)) + method.Name = "Get" + method.Name; + } + property.GetMethod = getter; + property.SetMethod = setter; + property.ExplicitInterfaceImpl = getter.ExplicitInterfaceImpl; + if (property.ExplicitInterfaceImpl == null && setter != null) + { + property.ExplicitInterfaceImpl = setter.ExplicitInterfaceImpl; + } + // TODO: add comments + type.Properties.Add(property); + getter.IsGenerated = false; + if (setter != null) + setter.IsGenerated = false; + } + } - Driver.Diagnostics.EmitMessage(DiagnosticId.PropertySynthetized, - "Setter created: {0}::{1}", @class.Name, name); - return false; + private void DistributeMethod(Method method) + { + if (GetFirstWord(method.Name) == "set" && + method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void)) + { + if (method.Parameters.Count == 1) + setters.Add(method); + else + setMethods.Add(method); + } + else + { + if (IsGetter(method)) + getters.Add(method); + if (method.Parameters.Count == 0) + nonSetters.Add(method); } - - return false; } - // Check if a matching getter exist or no other setter exists. - private bool IsValidSetter(Method method) + private bool IsGetter(Method method) { - var @class = method.Namespace as Class; - var name = method.Name.Substring("set".Length); - - if (method.Parameters.Count == 0) + if (method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void) || + method.Parameters.Count > 0 || method.IsDestructor) return false; + var result = GetFirstWord(method.Name); + return result == "get" || result == "is" || result == "has" || + (result != "to" && result != "new" && !verbs.Contains(result)); + } - var type = method.Parameters[0].Type; - - var getter = @class.Methods.FirstOrDefault(m => m.Name == "Get" + name && m.Type.Equals(type)); - - var otherSetter = @class.Methods.FirstOrDefault(m => m.Name == method.Name - && m.Parameters.Count == 1 - && !m.Parameters[0].Type.Equals(type)); - - return getter != null || otherSetter == null; + private static string GetFirstWord(string name) + { + List firstVerb = new List + { + char.ToLowerInvariant(name[0]) + }; + firstVerb.AddRange(name.Skip(1).TakeWhile(char.IsLower)); + return new string(firstVerb.ToArray()); } } } diff --git a/src/Generator/Passes/MultipleInheritancePass.cs b/src/Generator/Passes/MultipleInheritancePass.cs index 4651ab83..59199062 100644 --- a/src/Generator/Passes/MultipleInheritancePass.cs +++ b/src/Generator/Passes/MultipleInheritancePass.cs @@ -66,9 +66,15 @@ namespace CppSharp.Passes let i = GetInterface(@base, b.Class) select new BaseClassSpecifier { Type = new TagType(i) }); - @interface.Methods.AddRange(@base.Methods.Where( - m => !m.IsConstructor && !m.IsDestructor && !m.IsStatic && !m.Ignore)); - @interface.Properties.AddRange(@base.Properties.Where(p => !p.Ignore)); + @interface.Methods.AddRange( + from m in @base.Methods + where !m.IsConstructor && !m.IsDestructor && !m.IsStatic && !m.Ignore + select new Method(m) { Namespace = @interface }); + + @interface.Properties.AddRange( + from property in @base.Properties + where !property.Ignore + select new Property(property) { Namespace = @interface }); if (@interface.Bases.Count == 0) { diff --git a/src/Generator/Passes/RenamePass.cs b/src/Generator/Passes/RenamePass.cs index fa180548..df5ba64b 100644 --- a/src/Generator/Passes/RenamePass.cs +++ b/src/Generator/Passes/RenamePass.cs @@ -39,6 +39,7 @@ namespace CppSharp.Passes if (decl is Enumeration) return true; if (decl is Property) return true; if (decl is Event) return true; + if (decl is TypedefDecl) return true; return false; } @@ -125,6 +126,14 @@ namespace CppSharp.Passes return base.VisitProperty(property); } + public override bool VisitTypedefDecl(TypedefDecl typedef) + { + if (!Targets.HasFlag(RenameTargets.Delegate)) + return false; + + return base.VisitTypedefDecl(typedef); + } + public override bool VisitMethodDecl(Method method) { if (!Targets.HasFlag(RenameTargets.Method)) @@ -173,7 +182,8 @@ namespace CppSharp.Passes EnumItem = 1 << 6, Event = 1 << 7, Property = 1 << 8, - Any = Function | Method | Parameter | Class | Field | Enum | EnumItem | Event | Property, + Delegate = 1 << 9, + Any = Function | Method | Parameter | Class | Field | Enum | EnumItem | Event | Property | Delegate, } /// diff --git a/src/Generator/Passes/verbs.txt b/src/Generator/Passes/verbs.txt new file mode 100644 index 00000000..b5a441c9 --- /dev/null +++ b/src/Generator/Passes/verbs.txt @@ -0,0 +1,8828 @@ +Africanize +Afrikanerize +Americanise +Americanize +Anglicise +Anglicize +Anglify +Aryanise +Aryanize +Atticise +Atticize +Australianize +Baalize +Babelise +Babelize +Balkanise +Balkanize +Bolshevize +Canadianize +Cannulate +Christianise +Christianize +Egyptianise +Egyptianize +Europeanise +Europeanize +Fletcherise +Fletcherize +Fordize +Frenchify +Gallicise +Gallicize +Germanise +Germanize +Gnosticise +Gnosticize +Gothicise +Gothicize +Graecise +Graecize +Grecise +Grecize +Harveyize +Hebraise +Hebraize +Hellenise +Hellenize +Hibernicise +Hibernicize +Hinduize +Hispanicise +Hispanicize +Indianise +Indianize +Iricise +Iricize +Irishise +Irishize +Islamise +Islamize +Italianise +Italianize +Jacobinise +Jacobinize +Jesuitise +Jesuitize +Judaise +Judaize +Latinise +Latinize +Listerise +Listerize +Magyarize +Mohammedanize +Nazify +Negritise +Negritize +Negroise +Negroize +Newmanise +Newmanize +Normanize +Northernise +OK'd +Occidentalise +Occidentalize +Orientalise +Orientalize +Pelagianize +Platonise +Platonize +Polonize +Prussianize +Romanise +Romanize +Russianise +Russianize +Sanforize +Sinicize +Sinify +Sovietise +Tanglewood +Teutonise +Teutonize +Yankeefy +abase +abash +abate +abbreviate +abdicate +abduce +abduct +abet +abhor +abide +abirritate +abjure +ablactate +ablate +abnegate +abnormalise +abnormalize +abolish +abolitionise +abolitionize +abominate +abort +abought +abound +abrade +abrase +abreact +abridge +abrogate +abscind +abscise +abscond +absent +absolve +absorb +absquatulate +abstain +absterge +abut +aby +abye +academise +academize +accede +accelerate +accentuate +accept +accessorize +acclimate +acclimatise +acclimatize +accommodate +accompany +accomplish +accouter +accoutre +accredit +accrete +accroach +accrue +acculturate +acculturize +accumulate +accuse +accustom +acerbate +acetify +acetylate +acetylize +achieve +achromatise +achromatize +acidify +acidize +acidulate +acierate +acknowledge +acquaint +acquiesce +acquire +acquit +acronymize +activate +activize +actualise +actualize +actuate +acuminate +acylate +adapt +add +addle +addrest +adduce +adduct +adffroze +adffrozen +adfreeze +adhere +adhibit +adjoin +adjourn +adjudge +adjudicate +adjure +adjust +admeasure +administer +administrate +admire +admit +admix +admonish +adopt +adore +adorn +adrenalectomize +adsorb +adulate +adulterate +adumbrate +advertise +advertize +advise +aerate +aerify +aerosolize +aestivate +affirm +afflict +afford +afforest +affranchise +affreight +agatize +agenize +agglutinate +aggrade +aggrandise +aggrandize +aggravate +aggress +aggrieve +aggroup +agist +agitate +agnise +agnize +agonise +agonize +agree +airmail +airproof +albumenise +albumenize +albuminise +albuminize +alchemise +alchemize +alcoholise +alcoholize +alienate +alight +align +aline +alit +alkalify +alkalinise +alkalinize +alkalise +alkalize +allay +allege +allegorise +allegorize +alleviate +alligate +alliterate +allocate +allomerize +allot +allow +allude +alphabetise +alphabetize +alter +altercate +aluminise +aluminize +amalgamate +amass +amate +ambrocate +ambulate +ameliorate +amend +amerce +americanize +amidate +aminate +ammonify +ammonolyze +amortise +amortize +amplify +amputate +amuse +anaesthetize +anagrammatise +anagrammatize +analogise +analogize +analyse +analyze +anastomose +anathematise +anathematize +anathemize +anatomise +anatomize +anchylose +ancylose +anele +anesthesize +anesthetize +anglicise +anglicize +angulate +animadvert +animalise +animalize +animate +animize +ankylose +annihilate +annotate +announce +annoy +annul +annunciate +anodize +anoint +antagonise +antagonize +antecede +antevert +anthologise +anthologize +anthropomorphise +anthropomorphize +anticipate +antiquate +antisepticise +antisepticize +aphorise +aphorize +apocopate +apologise +apologize +apostatise +apostatize +apostrophise +apostrophize +apotheose +apotheosise +apotheosize +appal +appall +appear +appease +append +apperceive +appertain +applaud +appliquad +apply +appoint +apportion +appose +appraise +appreciate +apprehend +apprise +apprize +approbate +appropriate +approve +approximate +arbitrate +arborise +arborize +archaise +archaize +argue +argufy +arise +arisen +aromatise +aromatize +arose +arouse +arraign +arrange +arride +arrive +arrogate +arterialise +arterialize +articulate +artificialize +arylate +ascend +ascertain +ascribe +asexualise +asexualize +ask +asperse +asphyxiate +aspire +assail +assassinate +assemble +assert +assess +asseverate +assibilate +assibiliate +assimilate +assoil +assort +assuage +assume +assure +astonish +astound +astrict +astringe +astrogate +atomise +atomize +atone +attacca +attain +attemper +attend +attenuate +attest +attitudinise +attitudinize +attorn +attract +attrite +attune +aurify +auscultate +auspicate +austemper +austenitize +authenticate +authorise +authorize +autolyse +autolyze +automate +automatize +autotomise +autotomize +avenge +aver +avert +avianise +avianize +aviate +avoid +avouch +avow +avulse +await +awake +awaken +awoke +azotise +azotize +backbit +backbite +backbitten +backcomb +backdate +backpedal +backslap +backslid +backslidden +backslide +backstab +backtrack +backwind +bacterise +bacterize +badmouth +bald +balkanize +balladise +balladize +ballocks +ballyrag +bamboozle +bandfile +bandies +bandsawn +banish +baptise +baptize +bar +barbarianize +barbarise +barbarize +bare +barf +barhop +barnstorm +baronetise +baronetize +baronize +bartend +basiate +basify +bask +bastardise +bastardize +batfowl +battologise +battologize +beatify +beautify +becalm +became +bechance +becharm +beclasp +becloud +become +becrawl +becripple +bedabble +bedamn +bedash +bedaub +bedaze +bedazzle +bedeck +bedevil +bedew +bedight +bedim +bedizen +bedlamise +bedlamize +bedrabble +bedraggle +bedrench +been +beestride +befall +befallen +befell +befit +beflag +befog +befool +befoul +befriend +befuddle +began +begat +begem +beget +begild +begin +begird +begirt +begot +begotten +begrime +begrudge +beguile +begun +behave +behead +beheld +behold +behoove +behove +bejewel +belabor +belabour +belaud +beleaguer +belie +believe +belittle +bellylaugh +belong +belove +bemaul +bemean +bemire +bemoan +bemock +bemuddle +bemuse +bename +benday +beneficiate +benempt +benight +benumb +benzoylate +bepaint +bequeath +berascal +berate +bereareft +bereave +berhyme +berime +bescreen +bescribble +beseech +beseem +beset +beshrew +besiege +besmear +besmirch +besot +besought +bespake +bespangle +bespatter +bespeak +bespeckle +bespoken +bespot +bespread +besprinkle +bestead +bestialise +bestialize +bestir +bestow +bestraddle +bestrew +bestrewn +bestrid +bestridden +bestride +bestrode +bestrow +bestrown +bestud +betake +betaken +bete +bethink +bethought +betide +betoken +betook +betray +betroth +bewail +beware +beweep +bewhisker +bewilder +bewitch +bewray +bewwept +bidden +bide +bifurcate +bind +birdnest +birdwatch +birle +birthe +bisect +bist +bitten +bituminise +bituminize +blacken +blacklead +blackwash +blanch +blanco +blandish +blaspheme +blast +blat +blate +blear +blench +blent +bless +blest +blew +blither +bloodiest +bloody +blown +blub +blunge +blunt +blurt +bode +bodge +bodies +bodypaint +boggle +bogue +bollix +bollocks +bolshevise +bolshevize +bombilate +bombinate +bonderize +bonk +boo +boohoos +bootlick +boresight +born +borne +boswellize +botanise +botanize +bother +bought +boult +boun +bouse +bowdlerise +bowdlerize +bown +bowse +bowstrung +boxhaul +brachiate +braille +brainwash +braise +bravo +braze +brazen +break +breathalyse +breathalyze +breathe +brecciate +brei +brey +brighten +brisk +brisken +broaden +broddle +broider +broke +broken +bromise +bromize +brought +browbeat +browbeaten +brutalise +brutalize +brutify +buckjump +bugger +build +built +bulldoze +bulletproof +bully +bullyrag +bureaucratize +burglarise +burglarize +burgle +buries +burke +burnt +bury +bushwhack +busy +buttle +butylate +ca' +cabble +cachinnate +cackel +cagmag +cajole +calcify +calcine +calculate +calibrate +call +callous +calorize +calumniate +calve +camphorate +can +canalise +canalize +cancerate +cannibalise +cannibalize +cannot +canonise +canonize +canoodle +canst +cantillate +capacitate +capitalise +capitalize +capitulate +caponise +caponize +capsize +capsulize +captivate +caramelise +caramelize +carbolise +carbolize +carbonise +carbonize +carbonylate +carburet +carburise +carburize +carjack +carnalize +carnify +carny +carries +cartelize +carve +carven +caseate +casefy +caseharden +castigate +catabolize +catalyse +catalyze +catechise +catechize +categorise +categorize +catenate +catenulate +cater +cathect +catheterise +catheterize +catholicise +catholicize +caught +caulk +cauterise +cauterize +cave +cavort +cede +ceil +celebrate +cellulate +cense +centerpunch +centralise +centralize +centrifugalise +centrifugalize +centuple +cerebrate +certify +chackle +chainstitch +channelize +chaptalize +characterise +characterize +chassad +chasse +chasten +chastise +chastize +cheapen +check +checkmate +cheerlead +cheezit +chelp +chemisorb +cherish +chevies +chevvy +chiack +chide +chinse +chirk +chitter +chivvy +chloridize +chlorinate +chondrify +choose +choreograph +christen +christmas +chromatograph +chromeplate +chronologize +chunter +chyack +cicatrise +cicatrize +cinchonise +cinchonize +cinematize +circularise +circularize +circulate +circumambulate +circumcise +circumfuse +circumnavigate +circumnutate +circumrotate +circumscribe +circumstantiate +circumvallate +circumvent +circumvolute +circumvolve +cite +citify +civilise +civilize +clad +clangour +clapperclaw +clapt +clarify +clart +claspt +classicise +classicize +classify +claucht +claught +claver +claxon +cleanse +clearstarch +cleave +clem +clepe +clept +clipt +clitter +clomb +clone +close +closest +clothe +cloven +cloy +clubhaul +clung +clype +coact +coalesce +coapt +coarsen +cocainise +cocainize +cockbill +cockneyfy +codify +coedit +coerce +coexist +coextend +coff +coft +coggle +cogitate +cognise +cognize +cohabit +cohere +cohobate +coiffe +coincide +coinsure +coldcock +coldcream +collaborate +collate +collectivise +collectivize +collide +colligate +collimate +collocate +collogue +collude +colonialise +colonialize +colonise +colonize +combust +come +cometh +commandeer +commeasure +commemorate +commence +commend +commentate +commercialise +commercialize +comminate +commingle +comminute +commisce +commiserate +commit +commix +commove +communalise +communalize +communicate +communise +communize +commutate +commute +compart +compartmentalise +compartmentalize +compassionate +compel +compensate +compete +compile +complain +compleat +complect +complete +complexify +complicate +comply +comport +compose +comprehend +comprise +comprize +computerize +concatenate +concave +conceal +concede +conceive +concelebrate +concenter +concentre +conceptualise +conceptualize +concertise +concertize +conciliate +concinnate +conclude +concoct +concorporate +concretize +concur +concuss +condemn +condense +condescend +condole +condone +conduce +confabulate +confect +confer +confess +confide +configure +confirm +confiscate +conflate +conform +confound +confront +confuse +confute +conge +congeal +congest +conglobate +conglobe +conglutinate +congratulate +congregate +conjoin +conjure +connect +connive +connote +conquer +consecrate +consider +consign +consist +consolidate +consonantalize +consonantise +consonantize +conspire +constellate +conster +consternate +constipate +constitute +constitutionalize +constrain +constrict +constringe +consubstantiate +consult +consume +consummate +contact +contain +containerize +contaminate +contemn +contemplate +contemporise +contemporize +contend +content +contextualize +continue +contort +contradict +contradistinguish +contraindicate +contrapose +contravene +contribute +contrive +controvert +contuse +convalesce +convect +convene +conventionalise +conventionalize +converge +convex +convey +conveyorize +convince +convoke +convolute +convolve +convulse +coo +cooccur +cooee +cooperate +coopt +copolymerise +copolymerize +copperbottom +coprecipitate +copulate +copyedit +copyread +coquet +corelate +coronate +corrade +correct +correspond +corroborate +corrode +corrugate +corrupt +coruscate +cosher +cosmopolitanise +cosmopolitanize +cosponsor +could +couldst +counteract +counterchallenge +counterchange +counterlit +counterpose +counterreplies +countersank +counterstrike +countersunk +countervail +counterweigh +covet +cower +cowk +cozen +cranch +craunch +crave +create +cremate +crenelate +crenellate +creolize +crepitate +crept +cribble +cries +criminalize +criminate +crimple +crispen +criticise +criticize +crizzle +cronk +crucify +cryptanalyze +crystalize +crystallise +crystallize +cuckoo +cuitle +cuittle +culminate +cultivate +cumulate +curarize +curdle +curr +curst +curtail +customise +customize +cutinise +cutinize +cybernate +cyclize +dabble +dacker +daggle +daiker +dally +dam +damaskeen +damn +damnify +dampen +dampproof +dandify +dandle +daresay +darken +darkle +darn +dartle +dash +datemark +daunt +daut +dawdle +dawt +deaccession +deacetylate +deactivate +deaden +deaerate +deafen +dealt +deaminate +deaminize +deave +debag +debar +debark +debase +debeak +debilitate +debone +debrief +debruise +debunk +deburr +debus +decaffeinate +decalcify +decamp +decancellate +decant +decapitate +decarbonate +decarbonise +decarbonylate +decarboxylate +decarburise +decarburize +decartelize +decasualise +decasualize +deceive +decelerate +decenter +decentralise +decentralize +decentre +decern +decertify +dechloridize +decide +decimalise +decimalize +decimate +decipher +declaim +declare +declass +declassify +declaw +declutch +decoct +decode +decoke +decollate +decolonise +decolonize +decolor +decolorise +decolorize +decolourise +decolourize +decommission +decompose +decompound +decompress +deconcentrate +decongest +deconsecrate +deconstruct +decontaminate +decontrol +decorate +decorticate +decouple +decrepitate +decriminalize +decry +decrypt +decussate +dedicate +dedifferentiate +dedolomitize +deduce +deduct +deek +deem +deemphasize +deepen +deescalate +deface +defalcate +defame +defang +defecate +defeminise +defeminize +defend +defer +defervesce +defibrillate +defies +define +definitise +definitize +deflagrate +deflate +deflect +deflocculate +deflower +defoliate +deforce +deform +defraud +defray +defrock +defrost +defuse +defuze +defy +degas +degauss +deglamorize +deglutinate +deglycerolize +degold +degrade +degrease +degum +degust +dehisce +dehorn +dehort +dehumanise +dehumanize +dehumidify +dehydrate +dehydroffroze +dehydroffrozen +dehydrofreeze +dehydrogenate +dehydrogenise +dehydrogenize +dehypnotize +deice +deify +deign +deionize +deject +delabialize +delaminate +delapidate +delate +delead +delectate +delegalize +delete +deliberate +delimit +delimitate +delineate +deliquesce +delist +deliver +delocalise +delocalize +delouse +delude +delve +demagnetise +demarcate +demark +demasculinise +demasculinize +dematerialise +dematerialize +demean +dement +demilitarise +demilitarize +demineralize +demist +demit +demobilise +demobilize +democratise +democratize +demodulate +demolish +demonetise +demonetize +demonise +demonize +demonstrate +demoralise +demoralize +demote +demothball +demount +demulsify +demystify +demythologise +demythologize +denasalize +denationalise +denationalize +denaturalise +denaturalize +denature +denaturise +denaturize +denazify +denicotinize +denigrate +denitrate +denitrify +denominate +denote +denounce +densify +dentalise +dentalize +denuclearize +denudate +denude +denunciate +deny +deodorise +deodorize +deoxidise +deoxidize +deoxygenate +deoxygenize +depaint +depart +departmentalise +departmentalize +depasture +depend +depeople +deperm +depersonalise +depersonalize +depict +depicture +depilate +deplane +deplete +deplore +deploy +deplumate +deplume +depolarise +depolarize +depoliticize +depolymerize +depone +depopulate +deport +depose +deprave +deprecate +depreciate +depredate +depress +depressurize +deprive +depurate +depute +deputise +deputize +deracinate +deraign +derange +derate +deration +deratize +derecognize +deregister +deregulate +derestrict +deride +derive +dern +derogate +derust +desalinate +desalinize +desalt +descale +descend +deschool +describe +descry +deseam +desecrate +desegregate +desensitize +deserve +desex +desexualize +desicate +desiccate +desiderate +designate +desilt +desilver +desilverize +desist +desolate +desorb +despise +despoil +despumate +desquamate +dessicate +destabilize +desterilize +destine +destool +destress +destroy +desulfur +desulfurate +desulfurise +desulfurize +desulphurate +desulphurise +desulphurize +desynchronize +detach +detain +detect +deter +deterge +deteriorate +determine +detest +dethrone +detonate +detoxify +detract +detrain +detransitivize +detribalize +detrude +detruncate +detusk +deuterate +devaluate +devalue +devastate +develop +develope +devest +devilize +devitalise +devitalize +devitrify +devocalise +devocalize +devoice +devolatilise +devolatilize +devolve +devote +devour +dewater +diabolise +diabolize +diagnose +diagnosticate +diagonalize +dialogize +dialyse +dialyze +diazotize +dib +dichotomise +dichotomize +did +didder +diddle +didst +dieselize +differ +differentiate +diffract +diffuse +dight +digitalize +digitise +digitize +dignify +digress +dilacerate +dilapidate +dilate +dillydally +dilute +dim +dimerize +dimidiate +diminish +dine +dingdong +dink +diosmose +diphthongise +diphthongize +dipt +direct +dirl +dirty +disable +disabuse +disaccredit +disaccustom +disaffect +disaffiliate +disaffirm +disafforest +disagree +disallow +disambiguate +disannul +disanoint +disappear +disappoint +disapprove +disarm +disarrange +disarticulate +disassemble +disassociate +disavow +disband +disbar +disbelieve +disbosom +disbowel +disbranch +disbud +disburden +disburse +disburthen +discase +discept +discern +discerp +disclaim +disclose +discolor +discolorize +discolour +discombobulate +discommend +discommode +discommon +discompose +disconcert +disconnect +disconsider +discontinue +discourage +discover +discreate +discriminate +discrown +discuss +disembargo +disembark +disembarrass +disembody +disembogue +disembosom +disembowel +disembroil +disenable +disenchant +disencumber +disendow +disenfranchise +disengage +disentangle +disenthral +disenthrall +disenthrone +disentitle +disentomb +disentrance +disentwine +disestablish +disfeature +disfigure +disforest +disfranchise +disfrock +disfurnish +disgavel +disgorge +disgregate +disgruntle +dishabituate +dishallow +disharmonise +disharmonize +dishearten +dishelm +disherit +dishevel +dishonour +disillusionise +disillusionize +disimprison +disincarnate +disincline +disinfect +disinfest +disinflate +disinherit +disinhume +disintegrate +disinter +disinvolve +disject +disjoin +disjoint +diskjockey +dislimn +dislocate +dislodge +dismantle +dismast +dismember +dismiss +disnature +disobey +disoblige +disocclude +disorganise +disorganize +disorient +disorientate +disown +disparage +dispart +dispauper +dispel +dispend +dispense +dispeople +disperse +dispirit +displace +displant +displease +displode +displume +dispossess +dispread +disprize +disproportionate +disprove +disqualify +disrate +disremember +disrobe +disroot +disrupt +dissassociate +dissatisfy +disseat +dissect +disseise +disseize +dissemble +disseminate +dissert +dissertate +disserve +dissever +dissimilate +dissimulate +dissipate +dissociate +disspread +dissuade +dissyllabise +dissyllabize +distain +distend +distil +distill +distinguish +distort +distract +distrain +distribute +disturb +disunify +disunite +disyllabize +disyoke +divagate +divaricate +diverge +diversify +divert +divest +divinise +divinize +divulgate +divulge +divulse +divvies +dizen +dizzy +doat +does +doest +doeth +doff +dogmatise +dogmatize +dolomitise +dolomitize +domesticate +domesticize +domiciliate +dominate +domineer +donate +done +dost +dote +doth +doublethought +dought +dow +download +drabble +draggle +dramatise +dramatize +drank +drave +dreamt +dree +dreigh +drest +drew +driech +driegh +driven +dropforge +dropt +drouk +drown +drumble +drydock +dulcify +dulcorate +dull +dumbfound +dumfound +dup +dure +durst +dwelt +dwindle +dwine +dynamize +earn +easternize +easy +eat +eaten +eavesdrop +ebonise +ebonize +eche +economise +economize +ectropionize +edify +editorialize +educate +educe +edulcorate +eff +efface +effectuate +effeminise +effeminize +effervesce +effigiate +effloresce +effulge +effuse +egest +egotrip +eject +eke +elaborate +elapse +elasticate +elasticize +elate +electrify +electrocute +electroform +electrolyse +electrolyze +electropolish +elegise +elegize +elevate +elicit +elide +eliminate +elinguate +eloign +elongate +elope +elucidate +elude +elute +elutriate +eluviate +emaciate +email +emanate +emancipate +emasculate +embalm +embank +embar +embark +embarrass +embattle +embay +embellish +embezzle +embitter +emblaze +emblazon +emblematise +emblematize +embody +embolden +embosk +embosom +emboss +embow +embowel +embower +embrangle +embrittle +embrocate +embroider +embroil +embrown +embrue +embrute +embus +emend +emendate +emerge +emerize +emigrate +emit +emmarble +emote +emotionalise +emotionalize +empale +empanel +empathize +emphasise +emphasize +emplace +emplane +empoison +empolder +empoverish +empower +empt +empurple +emulate +emulsify +enable +enact +enamor +enamour +encage +encamp +encapsulate +encapsule +encarnalise +encarnalize +encase +encash +enchain +enchant +enchase +encipher +encircle +enclasp +enclose +enclothe +encode +encompass +encore +encourage +encrimson +encroach +encrypt +enculturate +encumber +encyst +end +endamage +endanger +enddamage +endear +endorse +endow +endue +endure +energise +energize +enervate +enface +enfeeble +enfeoff +enfetter +enflame +enfold +enforce +enfranchise +enfranchize +enfuriate +engage +engarland +engender +engild +engird +engirdle +engirt +englut +engorge +engraft +engrail +engrain +engrave +engross +engulf +enhance +enhearten +enigmatize +enisle +enjoin +enjoy +enkindle +enlace +enlarge +enlighten +enlist +enliven +enmarble +enmesh +ennoble +enolize +enounce +enplane +enquire +enrage +enrapture +enravish +enregister +enrich +enrobe +enrol +enroll +enroot +ensanguine +ensconce +enscroll +ensepulcher +ensheathe +enshrine +enshroud +ensile +ensky +enslave +ensnare +ensnarl +ensoul +ensphere +enspirit +ensue +enswathe +entangle +enter +entertain +enthral +enthrall +enthrone +enthronise +enthronize +enthuse +entice +entitle +entoil +entomb +entomologise +entomologize +entrain +entrammel +entrap +entreasure +entreat +entrench +entrust +entwine +entwist +enucleate +enumerate +enunciate +enure +envelop +envenom +environ +envisage +envision +enweave +enwind +enwomb +enwove +enwrap +enwreath +enwreathe +enwwove +enwwoven +epigrammatise +epigrammatize +epilate +epimerise +epimerize +epiphanise +epiphanize +episcopise +episcopize +epistolise +epistolize +epitomise +epitomize +equalise +equalize +equate +equilibrate +equilibrize +equip +equiponderate +equivocate +eradiate +eradicate +erase +erect +erode +err +eruct +eructate +erupt +escalate +eschew +escribe +espouse +espy +essentialize +establish +esterify +estivate +estop +estrange +etch +eternalise +eternalize +eternise +eternize +etherealise +etherealize +etherialise +etherialize +etherify +etherize +ethicize +etiolate +etymologise +etymologize +euhemerise +euhemerize +eulogise +eulogize +eunuchise +eunuchize +euphemise +euphemize +euphonise +euphonize +europeanize +evacuate +evade +evaginate +evaluate +evanesce +evangelise +evangelize +evanish +eventuate +evert +evict +evince +eviscerate +evite +evoke +evolve +ewound +exacerbate +exact +exaggerate +exalt +examine +exasperate +excavate +excecate +excel +except +excide +excite +exclaim +exclude +excogitate +excoriate +excorticate +excrete +excruciate +exculpate +excuss +exec +execrate +execute +exemplify +exenterate +exert +exeunt +exfoliate +exhale +exhilarate +exhort +exhume +exist +exit +exonerate +exorcise +exorcize +expand +expatiate +expect +expectorate +expeditate +expedite +expel +expend +experimentalize +expertize +expiate +expire +expiscate +explain +explicate +explode +explore +exposit +expostulate +expound +expropriate +expunge +expurgate +exsanguinate +exscind +exsect +exsert +exsiccate +exsolve +extemporise +extemporize +extend +extenuate +exteriorise +exteriorize +exterminate +extermine +externalise +externalize +extinguish +extirpate +extol +extort +extradite +extrapolate +extravagate +extricate +extrude +exuberate +exude +exult +exuviate +fabricate +facilitate +factorise +factorize +fadge +faff +fainaigue +fallen +falsify +familiarise +familiarize +famish +fanaticise +fanaticize +fancy +fankle +fantasize +faradise +faradize +fascinate +fast +fasten +fatigate +fatten +fax +faze +fecit +fecundate +federalise +federalize +federate +feign +felicitate +fellate +feminise +feminize +fenagle +fertilise +fertilize +festinate +fet +feudalise +feudalize +fictionalize +fictionise +fictionize +fidge +fiercen +filch +filiate +filmset +fimbriate +finagle +finalize +finedraw +finest +fingerpaint +finick +finish +finnick +firefang +fireproof +fishmouth +fistulize +fitcher +fixate +fixt +flabbergast +flatten +flay +fledge +flee +flench +flense +fletch +fley +flichter +flighter +flitter +flocculate +flog +floodlit +floreat +floruit +flout +flown +fluctuate +fluidise +fluidize +flummox +flung +fluoresce +fluoridate +fluoridise +fluoridize +fluorinate +flusterate +flustrate +flyblew +flyfish +flyte +focalise +focalize +focus +foist +foliate +foment +fondle +foolproof +footslog +forbade +forbbore +forbborne +forbid +forbore +forborne +fordid +fordo +fordone +forebode +foreclose +foredate +foredid +foredo +foredone +foredoom +forefend +foreffelt +foregather +forego +forejudge +foreknew +foreknow +foreknown +foreordain +foreordinate +foreran +forereach +forerun +foresaw +foresee +foreseen +foreshadow +foreshorten +foreshow +foreshown +forespeak +forestall +foreswear +foretell +foretold +forewarn +forewent +forfend +forgat +forgather +forgave +forget +forgive +forgiven +forgo +forgone +forgot +forgotten +forjudge +formalise +formalize +formicate +formulaize +formularise +formularize +formulate +formulise +formulize +formylate +fornicate +forsake +forsaken +forsook +forspeak +forswear +forswore +forsworn +fortify +forwent +fossick +fossilise +fossilize +foster +fought +fowent +foxhunt +fractionate +fractionise +fractionize +frag +fragmentise +fragmentize +frames +frap +fraternise +fraternize +fraze +freeboot +freeload +freest +frenchify +frequent +freshen +fress +frig +frighten +frivol +frizzes +froze +frozen +fructify +frustrate +ftp +fub +fuck +fudge +fugle +fulfil +fulfill +fulgurate +fulmine +fumigate +fundraise +furbish +furcate +furnish +further +fustigate +gainsaid +gainsay +galavant +gallivant +galumph +galvanise +gan +gasify +gastrulate +gaup +gave +gawp +gee +gelatinate +gelatinise +gelatinize +geminate +gemmate +generalise +generalize +generate +genuflect +geologize +geometrise +geometrize +germinate +gestate +gesticulate +get +ghettoize +ghostwrite +ghostwritten +ghostwrote +giddy +gie +giftwrap +gimblet +gimme +girt +glaca +glace +glaciate +gladden +glamorize +glamourise +glamourize +glean +glom +glorify +glory +glottalize +glug +gluttonise +gluttonize +glycerolize +gnar +gnawn +gobble +goldplate +gollop +golly +gone +gonna +goofproof +gorgonise +gorgonize +goster +got +gotta +gotten +gourmandize +govern +grabble +gradate +grangerise +grangerize +granitize +granulate +graphitize +gratify +gratinate +gratulate +graven +gravitate +grav~ing +greaten +grew +grieve +gript +grok +grovel +grow +gruntle +gufought +gunkhole +guttle +gutturalise +gutturalize +guzzle +gwine +gyrate +habilitate +habituate +had +hadst +hae +haemagglutinate +haen +hagride +hail +hale +hallo +hallow +hallucinate +halogenate +halt +halve +hamshackle +handbuild +handcolor +handpick +handsew +handstamp +handwash +handwrite +hanker +happen +harass +hark +harken +harmonise +harmonize +harrumph +harry +harshen +has +hast +hasten +hath +haw +headquarter +heal +hear +hearken +hearten +heathenise +heathenize +hebetate +hedgehop +heeze +heighten +heize +held +help +hemagglutinate +henpeck +heparinize +hepatectomize +hepatise +hepatize +herbarize +herborize +herry +hesitate +het +heterodyne +hew +hewn +hibernate +hiccough +hid +hide +hie +hierarchise +hierarchize +higgle +hight +hightail +hinder +hirsle +hiss +hitchhike +hoarsen +hobnob +hocus +hogtie +hoick +hoise +hoke +holden +hollo +holp +holpen +homogenize +homologate +homologise +homologize +hoodwink +hooray +hoot +hoover +hornswoggle +horrify +horripilate +hospitalize +hotfoot +hotter +hottest +housebreak +housebroke +housebroken +houseclean +housekeep +housekkept +hove +hum +humanise +humanize +humble +humidify +humiliate +hung +hurrah +hurries +hurtle +hush +huzzah +hyalinize +hybridise +hybridize +hydrogenise +hydrogenize +hydrolise +hydrolize +hydrolyse +hydrolyze +hygienize +hyperbolize +hyperdeify +hyperemphasize +hyperimmunize +hyperoxygenate +hyperoxygenize +hyperrealize +hypersensitise +hypersensitize +hyperventilate +hypervitalize +hyphenate +hyphenise +hyphenize +hypnotise +hypnotize +hypocopy +hypophysectomise +hypophysectomize +hyposensitize +hypostasise +hypostasize +hypostatise +hypostatize +hypothecate +hypothesise +hypothesize +hysterectomize +iarovize +idealise +idealize +identify +ideologise +ideologize +idiotise +idiotize +idle +idolatrise +idolatrize +idolise +idolize +ignite +ignore +illegalise +illegalize +illegitimatise +illegitimatize +illiberalise +illiberalize +illude +illume +illumine +illustrate +illuviate +imagine +imbalm +imbark +imbibe +imbitter +imbody +imbolden +imbosom +imbower +imbrangle +imbricate +imbrown +imbrue +imbrute +imbue +imitate +immaterialise +immaterialize +immerge +immerse +immesh +immigrate +immingle +immix +immobilise +immobilize +immolate +immoralise +immoralize +immortalise +immortalize +immunise +immunize +immure +impair +impale +impanel +imparadise +impark +imparl +impart +impassion +impaste +impawn +impeach +impearl +impede +impel +impend +imperialise +imperialize +imperil +impersonalise +impersonalize +impersonate +impetrate +impignorate +impinge +implead +implicate +implode +implore +imply +impolder +impone +importune +impose +impound +impoverish +impower +imprecate +impregnate +imprison +impropriate +improvise +impugn +impute +inactivate +inarch +inarm +inaugurate +inbreathe +incage +incandesce +incapacitate +incapsulate +incarcerate +incardinate +incarnadine +incarnalise +incarnalize +incarnate +incase +incept +inchoate +incinerate +incise +incite +inclasp +inclose +include +incommode +incorporate +incrassate +incriminate +incrust +incubate +inculcate +inculpate +incumber +incur +incurvate +indagate +indebt +indemnify +indicate +indict +indispose +indite +individualise +individualize +individuate +indoctrinate +indoctrinize +indorse +induce +induct +indue +indulge +indurate +industrialise +industrialize +indwell +indwelt +inearth +infamize +infect +infeoff +infer +infest +infibulate +infinitize +inflame +inflate +inflect +inflict +infold +inform +infract +infringe +infuriate +infuscate +infuse +ingather +ingeminate +ingenerate +ingest +ingraft +ingratiate +ingulf +ingurgitate +inhabit +inhale +inhere +inherit +inhibit +inhume +initialize +inject +injure +inlace +inlaw +inmesh +innervate +innerve +innoculate +innovate +inoculate +inosculate +inoxidize +inquiet +inquire +insalivate +inscribe +inscroll +insculp +inseminate +insheathe +inshrine +insinuate +insist +insnare +insolate +insolubilize +insoul +inspan +inspect +insphere +inspire +inspirit +inspissate +instal +install +instantiate +instate +instigate +instil +instill +institutionalise +institutionalize +instruct +instrumentate +insufflate +insularize +insulate +insulinize +insure +insurrectionise +insurrectionize +inswathe +integrate +intellectualise +intellectualize +intend +intenerate +intensify +inter +interaccuse +interact +interagglutinate +interagree +interanimate +interarch +interassure +interblend +interblent +intercalate +intercede +interchaff +interchain +intercharge +interchase +intercheck +interchoke +intercircle +intercirculate +interclasp +intercloud +intercolonize +intercombine +intercommon +intercommunicate +intercompare +interconfound +interconnect +interconvert +intercorrelate +intercreate +intercrust +intercurl +intercut +interdebate +interdepend +interdetermine +interdevour +interdifferentiate +interdiffuse +interdigitate +interdistinguish +interembrace +interentangle +interfere +interfile +interfiltrate +interflow +interfold +interfuse +intergossip +intergraft +intergrapple +interhybridize +interindicate +interinfluence +interinsert +interinvolve +interiorise +interiorize +interjaculate +interject +interjectionalise +interjectionalize +interjoin +interknit +interknot +interlace +interlaid +interlain +interlaminate +interlap +interlard +interleave +interlibel +interlie +interline +interlineate +interlocate +interlope +interlot +intermarry +intermat +intermaze +intermeasure +intermeddle +intermeet +intermelt +intermention +intermesh +intermigrate +intermingle +intermit +intermix +intermmet +internalise +internalize +internationalise +internationalize +interoscillate +interosculate +interpage +interpave +interpeal +interpellate +interpenetrate +interpermeate +interpervade +interplait +interplant +interplead +interpledge +interplight +interpolate +interpolish +interpollinate +interpose +interpour +interpret +interproduce +interquarrel +interradiate +interran +interreceive +interreflect +interreign +interrelate +interresist +interrhyme +interrogate +interrule +interrun +intersalute +interscribe +intersect +interseminate +interset +intershade +intershock +intershoot +intersituate +intersoil +intersole +intersperse +intersprinkle +intersqueeze +intersshot +interstimulate +interstratify +interstreak +interstrive +interstriven +interstrove +intertalk +intertangle +intertinge +intertouch +intertrace +intervary +intervein +intervene +intervisit +intervolve +interwar +interweld +interwhiff +interwhistle +interwind +interwork +interwound +interwove +interwoven +interwrap +interwreathe +interwwrought +inthral +inthrall +inthrone +intimidate +intitle +intitule +intomb +intonate +intone +intort +intoxicate +intransitivize +intreat +intrench +introduce +intromit +introspect +intrude +intrust +intubate +intuit +intumesce +intussuscept +intwine +intwist +inundate +inure +inurn +invade +invaginate +invalidate +inveigh +inveigle +invent +invest +investigate +invigilate +invigorate +invocate +invoke +involve +inweave +inwind +inwrap +inwreathe +iodinate +iodise +ionate +ionise +ionize +iridectomise +iridectomize +iridesce +iridize +irk +ironize +irradiate +irrate +irrationalise +irrationalize +irrigate +irritate +irrupt +is +isochronize +isolate +isomerize +italicize +itemize +iterate +itinerate +iwound +jactitate +jaculate +jampack +jargonise +jargonize +jarovize +jarp +jauk +jaywalk +jee +jellify +jemmies +jeopardise +jeopardize +jigsawn +jinglejangle +join +jollify +journalise +journalize +joypop +jubilate +jugulate +jump +jumpstart +justify +justle +juxtapose +kaolinise +kaolinize +katalyze +keelhaul +kep +keppen +kept +keratinize +keypunch +kibbitz +kibitz +kidnap +kindle +kippen +kithe +kittle +kittler +kittlest +knead +knelt +knew +kvetch +kyanise +kyanize +kyoodle +kythe +labialise +labialize +labilize +labiovelarise +labiovelarize +lacerate +lactonize +lade +laden +ladyfy +laicise +laicize +laid +laik +lain +lall +lallygag +lambast +lambaste +landslid +landslidden +languish +laparotomize +lapidate +lapidify +largen +larn +larrup +laryngectomize +lase +latensify +latinise +latinize +lave +laveer +lavish +leant +leapt +learn +learnt +legalise +legalize +legendize +legislate +legitimate +legitimatise +legitimatize +legitimise +legitimize +lend +lengthen +lenify +lenticulate +lessen +lethargise +lethargize +letterspace +levigate +levitate +lexicalize +liaise +liberalise +liberalize +liberate +librate +lichenise +lichenize +ligate +lighten +lignify +liken +limn +linearise +linearize +linger +lionise +lionize +lipread +liquate +liquefy +liquesce +liquidate +liquidise +liquidize +liquify +listen +literalise +literalize +litigate +live +liven +lixiviate +load +loathe +localise +localize +locate +locomote +logicise +logicize +login +logroll +loiter +lollop +lollygag +loosen +loosest +lose +louden +lour +lowe +lowse +lubricate +lucubrate +lumine +luminesce +lustrate +luteinize +luxate +luxuriate +lynch +lyophilize +lyricise +lyricize +lyse +macadamize +macerate +machicolate +machinate +macrame +maculate +mad +madden +made +maffick +maffle +magnetise +magnetize +magnify +mainline +maintain +make +maladminister +maledict +malign +malinger +malleablize +malleate +maltreat +mammer +man +manducate +manent +manet +manhandle +manipulate +manouevre +manumit +marage +marbelize +marbleize +marginate +marinate +maringue +marry +marsupialise +marsupialize +martemper +martyrise +martyrize +masculinize +masticate +masturbate +materialise +materialize +maternalise +maternalize +matronize +maturate +mature +maun +maunder +maximize +mayest +mayst +meant +mechanize +meddle +mediate +mediatise +mediatize +medicate +meditate +melanize +mellow +melodize +melodramatise +melodramatize +memorialise +memorialize +memorize +menstruate +meow +mercerize +mercurate +mercurialise +mercurialize +mercurify +merge +meseems +mesmerize +met +metabolise +metabolize +metallise +metallize +metamorphose +metaphysicize +metastasize +metathesize +methinks +methodise +methodize +methought +metricate +metricise +metricize +metrify +metrize +miaou +miaul +mibound +miche +micrify +microminiaturize +micturate +migrate +milden +mildewproof +militarise +militarize +militate +mimeo +mineralise +mineralize +mingle +miniate +miniaturise +miniaturize +minify +minimise +minimize +misact +misadapt +misadd +misaddress +misaddrest +misadjust +misadvise +misadvize +misallege +misallot +misally +misalphabetize +misanalyze +misapply +misappoint +misappraise +misapprehend +misappropriate +misarticulate +misassert +misassign +misauthorize +misaver +misaward +misbecame +misbecome +misbehave +misbelieve +misbestow +misbill +misbind +misbrand +misbrew +misbuild +misbuilt +miscalculate +miscall +miscarry +miscast +miscategorize +misce +miscegenate +miscensure +mischaracterize +mischarge +mischoose +misclaim +misclass +misclassify +miscoin +miscompute +misconceive +misconjecture +misconjugate +misconstrue +miscounsel +miscreate +miscut +misdealt +misdeem +misdefine +misdeliver +misdemean +misderive +misdescribe +misdid +misdirect +misdivide +misdo +misdone +misdoubt +misdraw +misdrawn +misdrew +misedit +miseducate +misemphasize +misesteem +misfield +misfile +misfocus +misform +misframe +misfunction +misgauge +misgave +misgive +misgiven +misgovern +misgrade +misgraft +misguage +misguide +mishandle +mishear +misidentify +misinfer +misinform +misinstruct +misintend +misinterpret +misjoin +misjudge +misknew +misknow +misknown +mislabel +mislaid +mislay +mislead +mislearn +mislocate +mismade +mismake +mismanage +mismarry +mismate +mismeasure +mismount +misname +misnarrate +misnavigate +misnumber +misoccupy +misorganize +mispage +misparse +mispatch +misperceive +misperform +misphrase +misplace +misplant +misplead +mispresent +misprise +misprize +misproduce +mispronounce +mispropose +misprovoke +mispunctuate +mispurchase +misqualify +misquote +misrate +misread +misrecollect +misrefer +misreflect +misreform +misregulate +misrehearse +misrelate +misrely +misremember +misrender +misrepresent +misreprint +misreward +missample +missang +misseat +misseem +missend +missent +misship +missort +missound +misspace +misspeak +misspell +misspend +misspoke +misspoken +misstart +misstate +missteer +misstyle +missung +missuppose +missyllabify +mistaught +misteach +misterm +misthread +misthrew +misthrow +misthrown +mistime +mistitle +mistook +mistrace +mistranscribe +mistranslate +mistreat +mistryst +mistune +mistutor +mistype +misunderstand +misvalue +miswire +misword +misworship +miswrite +miswritten +miswrote +miszone +mitch +mithridatise +mithridatize +mitigate +mittatur +mixt +mobilise +mobilize +modernise +modernize +modge +modify +modulate +moisten +moisturize +moither +molest +mollify +molten +monetize +mongrelise +mongrelize +monologuize +monophthongize +monopolise +monopolize +monotonize +monumentalise +monumentalize +moo +mooch +moos +moralise +moralize +mortify +mosey +mosh +mothproof +motivate +motorise +motorize +mourn +mown +mudcap +mudwrestle +multigraph +multiply +mumm +mummify +mump +munch +mundify +municipalise +municipalize +munite +murdabad +mure +mussitate +mutate +mutilate +mutualise +mutualize +muzz +mysticize +mystify +mythicise +mythicize +mythify +mythologize +mythopoetise +mythopoetize +nab +namedrop +naphthalise +naphthalize +narcotise +narcotize +narrate +nasale +nasalise +nasalize +nationalize +naturalize +nauseate +navigate +nazify +neaten +nebulise +nebulize +necessitate +necrose +necrotise +necrotize +nectarise +nectarize +negate +negociate +negotiate +neologise +neologize +neoterize +nephrectomise +nephrectomize +nesslerise +nesslerize +netmail +neutralize +nickelise +nickelize +nicotinise +nicotinize +nictate +nictitate +nidificate +nidify +nig +niggardise +niggardize +niggle +nigrify +nill +nitpick +nitrify +nitrogenise +nitrogenize +nix +nobble +nomadise +nomadize +nominalize +nominate +normalise +normalize +nosedive +notarize +notate +notify +nourish +novelise +novelize +nucleate +nullify +numb +numerate +nutate +nutrify +nuzzle +o.d. +obduce +obelise +obelize +obey +obfuscate +objectify +objectivize +objurgate +obligate +oblige +obliterate +obnounce +obnubilate +obsecrate +observe +obsess +obsolesce +obtain +obtest +obtrude +obturate +obumbrate +obvert +obviate +occidentalize +occlude +occupy +occur +odorize +offend +officialize +officiate +offsaddle +oink +ok +omit +onlaid +ontologise +oophorectomize +opacify +opalesce +opalize +ope +open +operate +operatize +opine +oppilate +oppose +oppress +oppugn +opsonize +opt +optimize +orate +orchestrate +ordain +order +organise +organize +orientalize +orientate +originate +orthogonalize +orthographise +orthographize +oscillate +osculate +ossify +ostracize +oufought +oust +out +outact +outambush +outargue +outawe +outbabble +outbake +outbalance +outban +outbanter +outbar +outbargain +outbark +outbarter +outbat +outbatter +outbawl +outbeam +outbeg +outbelch +outbellow +outbend +outbent +outbetter +outbid +outbidden +outblaze +outbleat +outbless +outblew +outbloom +outblossom +outblot +outblow +outblown +outbluff +outblunder +outblush +outbluster +outboast +outbow +outbowl +outbox +outbrag +outbranch +outbrave +outbray +outbrazen +outbreathe +outbribe +outbridge +outbrought +outbud +outbuild +outbuilt +outbulge +outbulk +outbully +outburn +outbustle +outbuzz +outcall +outcant +outcaper +outcarol +outcavil +outcharm +outchase +outchatter +outcheat +outchide +outclamor +outclass +outcompass +outcompliment +outcourt +outcrawl +outcreep +outcrept +outcricket +outcrow +outcull +outcure +outcurse +outcut +outdance +outdare +outdate +outdazzle +outdespatch +outdevil +outdid +outdispatch +outdistance +outdo +outdodge +outdrank +outdraw +outdrawn +outdress +outdrew +outdrink +outdrive +outdriven +outdrove +outdwell +outdwelt +outeat +outeate +outeaten +outecho +outedge +outequivocate +outfable +outface +outfame +outfast +outfawn +outfeast +outfence +outferret +outfight +outfigure +outfish +outflame +outflank +outflare +outflash +outflatter +outflee +outflew +outfloat +outflourish +outflown +outflung +outfly +outfool +outfoot +outfox +outfroth +outfrown +outgabble +outgain +outgallop +outgamble +outgame +outgas +outgaze +outgeneral +outglare +outgleam +outglitter +outgloom +outglow +outgnaw +outgone +outgreen +outgrew +outgrin +outgrow +outgrown +outguess +outgun +outgush +outhammer +outhasten +outhear +outhire +outhiss +outhit +outhorror +outhowl +outhumor +outhunt +outhurl +outhyperbolize +outinvent +outissue +outjest +outjet +outjinx +outjockey +outjourney +outjuggle +outjump +outjut +outkick +outkill +outkiss +outlabor +outlaid +outlance +outlash +outlast +outlaugh +outlaunch +outlead +outleap +outlearn +outlengthen +outlighten +outlimn +outlinger +outlip +outlive +outlove +outluster +outmalaprop +outman +outmaneuver +outmaneuvre +outmanoeuvre +outmarch +outmarry +outmaster +outmatch +outmate +outmeasure +outmode +outmount +outmouth +outmove +outnumber +outpace +outpaint +outpass +outpeep +outpeople +outperform +outpick +outpipe +outpitch +outpity +outplan +outplay +outplease +outplod +outplot +outpoint +outpoison +outpoll +outpop +outpopulate +outpractice +outpraise +outpray +outpreen +outprice +outproduce +outpromise +outpry +outpull +outpurl +outpursue +outpush +outquaff +outquery +outquestion +outquibble +outquote +outrace +outrail +outran +outrang +outrange +outrank +outrant +outrap +outrate +outrave +outread +outreason +outreckon +outredden +outreign +outrhyme +outrib +outrick +outridden +outrig +outrival +outroar +outrode +outrogue +outromance +outroot +outrove +outrow +outrun +outrung +outsaid +outsail +outsaint +outsally +outsang +outsat +outsatisfy +outsavor +outsaw +outsay +outscent +outscold +outscore +outscorn +outscream +outsearch +outsee +outseek +outseen +outsell +outshame +outshape +outshine +outshone +outshoulder +outshout +outshove +outshow +outshower +outshown +outshriek +outshrill +outsift +outsigh +outsin +outsit +outskill +outskip +outskirmish +outslander +outslang +outslid +outslide +outslink +outsmart +outsmell +outsmile +outsnatch +outsnore +outsoar +outsold +outsonet +outsophisticate +outsought +outsound +outsparkle +outspat +outspeak +outspell +outspill +outspin +outspirit +outspit +outsplendor +outspoke +outsport +outsprang +outsprint +outsprue +outspurn +outspurt +outspy +outstagger +outstand +outstank +outstare +outstartle +outstate +outstature +outstay +outsteal +outsteam +outstep +outstink +outstole +outstolen +outstood +outstorm +outstrain +outstream +outstretch +outstridden +outstride +outstrike +outstrip +outstrive +outstriven +outstrode +outstrove +outstruck +outstrut +outstudy +outstung +outstunt +outsuck +outsuffer +outsulk +outsum +outsung +outswagger +outswam +outswarm +outswear +outsweep +outsweeten +outswim +outswindle +outswirl +outswum +outswung +outtalk +outtear +outtease +outtell +outthieve +outthink +outthought +outthreaten +outthrew +outthrob +outthrown +outthunder +outthwack +outtinkle +outtire +outtoil +outtold +outtongue +outtower +outtrade +outtravel +outtrick +outtrot +outtrump +outttore +outttorn +outtyrannize +outvalue +outvanish +outvaunt +outvelvet +outvenom +outvictor +outvie +outvigil +outvociferate +outvoice +outvote +outvoyage +outwait +outwalk +outwallop +outwander +outwar +outwarble +outwaste +outwater +outwave +outwear +outweary +outweave +outweep +outweigh +outwell +outwent +outwhirl +outwiggle +outwile +outwill +outwind +outwish +outwit +outword +outworn +outwrangle +outwrench +outwrestle +outwriggle +outwrite +outwrung +outwwept +outwwove +outwwoven +outyell +outyelp +outyield +ovariectomize +ovenbake +overabound +overabsorb +overabstain +overabuse +overaccelerate +overaccentuate +overaccumulate +overachieve +overact +overactivate +overadorn +overadvance +overaffirm +overafflict +overaggravate +overagitate +overalcoholize +overallegorize +overanalyze +overannotate +overapplaud +overappraise +overarch +overargue +overassert +overassess +overassume +overate +overattenuate +overawe +overbait +overbake +overballast +overbank +overbbore +overbborne +overbear +overbill +overblame +overblanch +overbleach +overblow +overboil +overbook +overborrow +overbought +overbrace +overbrag +overbrake +overbroaden +overbroil +overbrown +overbrowse +overbrush +overbrutalize +overbuild +overbuilt +overcame +overcapitalise +overcapitalize +overcensor +overcentralize +overchafe +overchase +overcherish +overchill +overcivilize +overclaim +overclog +overclothe +overcloud +overcloy +overclutter +overcolor +overcome +overcommend +overcommercialize +overcompensate +overcomplicate +overconcentrate +overcondense +overconsume +overcontract +overcontribute +overcook +overcorrect +overcorrupt +overcredit +overcriticize +overcrop +overcrowd +overcull +overcultivate +overcumber +overdazzle +overdeal +overdebate +overdebilitate +overdecorate +overdedicate +overdeepen +overdeliberate +overdepress +overderide +overdescribe +overdevelop +overdid +overdiffuse +overdigest +overdignify +overdilate +overdilute +overdiscipline +overdiscount +overdiscourage +overdiscuss +overdistend +overdistort +overdiversify +overdo +overdomesticate +overdominate +overdone +overdoubt +overdoze +overdrain +overdramatize +overdraw +overdredge +overdrink +overdriven +overdrove +overdye +overeat +overeate +overeaten +overedit +overeditorialize +overeducate +overelate +overembellish +overembroider +overemotionalize +overemphasize +overemploy +overemulate +overexaggerate +overexcite +overexercise +overexert +overexpand +overexpect +overexpend +overexplain +overexpose +overexpress +overextend +overeye +overfag +overfatigue +overfatten +overfavor +overfeast +overfeel +overfeminize +overfill +overfilter +overfish +overfix +overflatten +overflavor +overflew +overflog +overflood +overflour +overflown +overfly +overfondle +overformalize +overfreight +overfrighten +overfurnish +overgamble +overgarnish +overgarrison +overgeneralise +overgeneralize +overgesticulate +overgild +overgilt +overgird +overglance +overglut +overgoad +overgorge +overgovern +overgrade +overgratify +overgraze +overgrew +overgrieve +overgrow +overgrown +overhand +overhandicap +overhandle +overharass +overharden +overhasten +overheap +overhear +overhonor +overhumanize +overhung +overhunt +overhurry +overidealize +overidentify +overillustrate +overimitate +overimmunize +overimport +overimpose +overimpress +overincline +overindulge +overindustrialize +overinflate +overinfluence +overinhibit +overinsist +overinstruct +overinsure +overintellectualize +overintensify +overinvest +overinvolve +overiodize +overirrigate +overjade +overjoy +overkick +overlactate +overlaid +overlain +overland +overlard +overlather +overlaud +overleap +overlearn +overlegislate +overliberalize +overlie +overlimit +overlinger +overlive +overloan +overlove +overlubricate +overmagnify +overmanage +overmarch +overmaster +overmeddle +overmelt +overmerit +overmill +overmitigate +overmix +overmobilize +overmodernize +overmodify +overmoisten +overmonopolize +overmoralize +overmortgage +overmourn +overmultiply +overmystify +overnationalize +overneglect +overneutralize +overnormalize +overnourish +overnurse +overobject +overobjectify +overoffend +overornament +overoxidize +overpack +overpaid +overpamper +overpark +overpay +overpenalize +overpeople +overpersecute +overpersuade +overpet +overphilosophize +overpictorialize +overpitch +overplant +overplay +overplease +overplow +overply +overpoeticize +overpolice +overpolish +overpollinate +overpopulate +overpower +overpratice +overpreoccupy +overpress +overprice +overprize +overproduce +overpromise +overpronounce +overprotect +overprotract +overprove +overprovide +overprovoke +overprune +overpsychologize +overpublicize +overpunish +overpurchase +overqualify +overrake +overran +overrank +overrate +overrationalize +overreach +overreact +overreduce +overrefine +overregiment +overregulate +overrelax +overrepresent +overrepress +overreprimand +overresist +overrestrain +overrestrict +overreward +overripen +overroast +overromanticize +overrule +oversalt +oversate +oversaturate +oversaw +overscore +overscrub +overscruple +overseason +oversecrete +oversecure +oversee +overseen +oversell +oversensitize +oversentimentalize +overset +oversettle +oversew +oversewn +overshade +overshadow +overshine +overshone +overshorten +overshrink +oversimplify +oversleep +overslept +overslip +overslipt +oversoak +oversoap +oversocialize +oversoften +oversold +oversolidify +overspecialize +overspeculate +overspend +overspice +overspilt +overspread +oversshot +overstaff +overstarch +overstate +overstay +oversteer +overstep +overstiffen +overstimulate +overstir +overstore +overstraighten +overstrengthen +overstress +overstretch +overstridden +overstride +overstrike +overstrive +overstriven +overstrode +overstrove +overstuff +oversubscribe +oversup +oversystematize +overtake +overtask +overtaught +overtax +overteach +overtheorize +overthrong +overtinsel +overtipple +overtire +overtoil +overtook +overtop +overtorture +overtrade +overtrim +overtrouble +overtrump +overtrust +overtwist +overunionize +overurbanize +overurge +overvalue +overvary +overventilate +overwatch +overweary +overween +overweigh +overwet +overwhelm +overwhip +overwind +overwinter +overwore +overworn +overwrite +overwrote +overwwrought +ovewound +oviposit +ovulate +owe +own +oxidate +oxidise +oxidize +oxigenise +oxygenize +ozonize +pacificate +pacify +paganise +paganize +paginate +paid +palatalise +palatalize +palladinize +palladiumize +palladize +palliate +palpate +palpebrate +palpitate +palter +pamper +pamphletize +panegyrize +parabolise +parabolize +paraffinize +parallelise +parallelize +paralyse +paralyze +parasitize +parathyroidectomize +parboil +parch +parchmentize +pardi +pardon +pare +parenthesize +parochialise +parries +parse +partake +partaken +partialise +particularise +particularize +partook +pass +pasteurise +pasteurize +pastoralize +patinate +patinize +patronise +patronize +pauperise +pauperize +pave +pectize +peculate +peculiarise +peculiarize +peddle +pedestrianise +pedestrianize +peduncular +peise +pelorize +penalise +penalize +pend +penetrate +peninsulate +pent +pepsinate +peptize +peptonise +peptonize +perambulate +perceive +perchlorinate +percuss +perdure +peregrinate +perennate +perfectivise +perforate +perform +perfuse +perhydrogenize +perish +peritonealize +perjure +perjurious +permeate +permutate +permute +perorate +peroxidize +perpetrate +perpetuate +perplex +persecute +persevere +persist +personalize +personate +personify +perspire +persuade +pertain +perturb +peruse +pervade +pester +petrify +pettifog +pettle +phagocytize +phagocytose +phenomenalize +phenomenize +philander +philanthropise +philanthropize +philosophise +philosophize +phlebotomise +phlebotomize +phonate +phonemicize +phosphatise +phosphatize +phosphorate +phosphoresce +phosphorise +phosphorylate +photocompose +photoengrave +photosensitize +photoset +photostat +photosynthesize +phrenogrady +piala +pickeer +pictorialise +picturize +pigstick +pilfer +pimproll +pinge +pinkify +pish +pize +placate +plagiarise +plagiarize +planish +plasmolyse +plasticise +plasticize +platinise +platinize +platitudinise +platitudinize +playact +pleach +plead +please +plebeianise +plebeianize +plenish +plim +ploat +plonk +plop +plunk +pluralise +pluralize +poach +podsolize +podzolize +poeticise +poeticize +poetize +poind +polarize +polemicise +polemicize +polemize +politicalize +politicise +politicize +politick +pollinate +pollinize +pollute +polychromatic +polychromize +polymerize +ponder +pop +popple +popularise +popularize +populate +porcelainize +porphyrize +porrect +portend +portray +poss +possess +post +postdate +postheat +postmultiply +postpone +postsign +posturise +posturize +potentiate +powderize +powdery +powerwash +practise +praelect +pray +preabsorb +preaccept +preaccommodate +preaccomplish +preaccount +preaccredit +preaccumulate +preaccuse +preaccustom +preach +preachify +preacknowledge +preacquaint +preacquire +preacquit +preact +preadapt +preadhere +preadjourn +preadjust +preadmire +preadmit +preadmonish +preadopt +preadorn +preadvertise +preadvise +preaffect +preaffirm +preafflict +preage +preaggravate +preagitate +preagree +preallege +preallot +preallow +preallude +prealter +preannex +preannounce +preanticipate +preapply +preappoint +preapprise +preapprize +preapprove +prearm +prearrange +prearrest +preascertain +preassemble +preassert +preassign +preassume +preassure +preattune +preaver +prebade +prebalance +preballot +prebargain +prebelieve +prebenefit +prebeset +prebestow +prebetray +prebill +prebless +preboil +prebreathe +preburn +precalculate +precapture +precast +precchose +precchosen +precede +precelebrate +precensure +precertify +precess +prechallenge +precharge +prechart +prechill +prechloroform +prechoose +precirculate +precite +preclassify +preclean +preclose +preclothe +preclude +precogitate +precognize +precoil +precollapse +precollect +precollude +precombine +precommit +precommune +precommunicate +precompare +precompel +precompensate +precompile +precomplicate +precompound +precomprehend +precompress +preconceal +preconcede +preconceive +preconcentrate +preconcert +preconclude +preconcur +precondemn +precondense +preconduct +preconfer +preconfess +preconfide +preconfigure +preconfine +preconfirm +preconform +preconfound +preconfuse +precongratulate +preconize +preconjecture +preconquer +preconsecrate +preconsider +preconsign +preconsolidate +preconspire +preconstitute +preconstruct +preconsult +preconsume +precontain +precontemn +precontemplate +precontend +precontribute +precontrive +preconvert +preconvey +preconvict +preconvince +precook +precool +precorrect +precorrespond +precorrupt +precover +precredit +precriticize +precultivate +predamn +predate +predeceive +predecide +predeclare +predecline +predecree +prededicate +prededuct +predefend +predefine +predefray +predefy +predeliberate +predelineate +predeliver +predelude +predemand +predemonstrate +predeny +predeplete +predepreciate +predeprive +prederive +predescend +predescribe +predesert +predeserve +predesign +predesignate +predestinate +predestine +predestroy +predetach +predetail +predetain +predetect +predetermine +predevelop +predevise +predevour +predict +predictate +predigest +prediminish +predine +predirect +predisagree +prediscern +prediscipline +predisclose +prediscourage +prediscover +prediscriminate +prediscuss +predismiss +predisperse +predisplace +predispose +predisrupt +predissolve +predissuade +predistinguish +predistribute +predisturb +predivert +predivide +predominate +predonate +predoom +predraw +predrawn +predrew +predrill +predrive +predriven +predrove +predry +preduplicate +predwell +preedit +preeducate +preelect +preeliminate +preembarrass +preembody +preemploy +preemptive +preenable +preenact +preenclose +preencourage +preendorse +preenforce +preengage +preenjoy +preenlarge +preenlighten +preenlist +preenroll +preentail +preenter +preentertain +preentitle +preenumerate +preenvelop +preequip +preerect +preerupt +preestablish +preesteem +preevade +preevaporate +preexact +preexamine +preexcept +preexchange +preexcite +preexclude +preexcuse +preexecute +preexempt +preexhaust +preexist +preexpand +preexpect +preexpend +preexplain +preexplode +preexpose +preexpound +preexpress +preextend +preextinguish +preextract +prefabricate +prefer +prefertilize +preffroze +preffrozen +prefigure +prefinance +preflatter +preforgave +preforgive +preforgiven +preformulate +prefreeze +prefulfill +prefurnish +pregain +pregalvanize +pregather +pregenerate +pregrade +pregratify +pregreet +preguard +preguide +prehandle +preharden +preheal +preheat +prehend +prehesitate +preidentify +preilluminate +preillustrate +preimagine +preimbibe +preimbue +preimitate +preimpair +preimpart +preimpose +preimpress +preimprove +preinaugurate +preincline +preinclude +preincorporate +preindemnify +preindicate +preindispose +preinduce +preindulge +preinfect +preinfer +preinflict +preinform +preinhabit +preinhere +preinherit +preinitial +preinscribe +preinsert +preinsinuate +preinspect +preinspire +preinstall +preinstill +preinstruct +preinsulate +preinsult +preinsure +preintend +preintercede +preinterpret +preintimate +preinvent +preinvest +preinvestigate +preinvite +preinvolve +preisolate +prejudge +prejustify +prekindle +preknew +preknit +preknow +preknown +prelaunch +prelect +preliberate +prelimitate +preliquidate +prelocate +premade +premaintain +premake +premanifest +premanufacture +premarry +premeasure +premedicate +premeditate +premerit +premiate +premillennialise +premillennialize +preminister +premisrepresent +premodel +premodify +premonish +premonopolize +premortify +premuster +prenecessitate +preneglect +prenegotiate +prenominate +prenote +prenotify +preobject +preobligate +preoblige +preobserve +preobstruct +preobtain +preobtrude +preobviate +preoccupy +preoccur +preoffend +preomit +preopen +preoperate +preoppose +preoppress +preordain +preorganize +preoutfit +preoverthrew +preoverthrown +prepackage +prepare +prepartake +prepartaken +prepartook +prepave +prepay +prepenetrate +prepersuade +preperuse +preplace +preplan +preplant +prepledge +preplot +preponderate +preportray +prepossess +prepractice +prepractise +preprice +preprofess +prepromote +prepronounce +preprove +preprovide +preprovoke +prepublish +prepunish +prepurpose +prequalify +prequestion +prequote +prerealize +prereceipt +prereceive +prerecite +prereckon +prerecognize +prerecommend +prereconcile +prerecord +preredeem +prerefer +prerefine +prerefuse +preregister +preregulate +prereject +prerejoice +prerelate +preremit +preremove +preremunerate +prerent +prerepresent +prerequire +preresemble +preresolve +preresort +prerespire +prerestrain +prerestrict +prereveal +prerevise +preroute +presanctify +presatisfy +presaw +prescind +prescribe +prescriptivist +presecure +presee +preseen +presentence +preseparate +preset +presettle +presharpen +preship +preshorten +preshow +preside +presift +presignify +presmooth +presolicit +presolve +prespecialize +prespecify +prespeculate +prespread +presprinkle +prespur +pressurize +prestandardize +presteam +prestimulate +prestraighten +prestrengthen +prestress +prestudy +presubdue +presubject +presubmit +presubordinate +presubscribe +presubsist +presubstitute +presuffer +presuggest +presume +presupervise +presupplicate +presuppose +presuppress +presurround +presuspect +presuspend +presustain +presympathize +pretabulate +pretaught +preteach +pretell +pretempt +pretend +pretermit +pretestify +prethreaten +pretire +pretold +pretorture +pretrain +pretransact +pretranscribe +pretranslate +pretransmit +pretransport +pretry +prettify +pretypify +preunderstand +preunderstood +preundertake +preundertaken +preundertook +preunite +preutilize +prevacate +prevaccinate +prevail +prevalue +prevaricate +prevent +preverify +previolate +previse +prevoid +prewarm +prewarn +preweigh +prewhip +prewire +prewrap +pries +prim +primp +prink +print +prioritize +privatize +proclaim +procrastinate +procreate +procure +profane +profess +professionalise +professionalize +prognosticate +prohibit +proletarianise +proletarise +proletarize +proliferate +prologise +prologize +prologos +prologuise +prologuize +prolong +prolongate +promote +promulgate +promulge +pronate +pronk +pronominalize +pronounce +proofread +propagandise +propagandize +propagate +propel +propend +prophesy +propitiate +propone +proportionate +propose +propound +prorate +prorogue +proscribe +prosect +prosecute +proselytise +proselytize +prosper +prostrate +protect +protract +protrude +protuberate +prove +proven +provide +provoke +prussianise +prussianize +psych +psychoanalyse +psychoanalyze +psychologize +ptyalize +publicise +publicize +publish +pule +pull +pullulate +pulsate +pulverise +pulverize +pummel +punctuate +punish +pupate +purify +purloin +purpurate +pursue +purvey +push +pustulate +putrefy +pyalla +quadrisect +quaff +qualify +quantify +quantize +quartersaw +quash +quell +quench +quetch +quicken +quiesce +quieten +quit +quizzes +quo +quote +quoth +racemize +radiate +radioactivate +rainproof +rals +ramify +ran +randomize +rang +rankle +ransack +rarefy +rarify +rase +ratify +ratiocinate +rationalise +rationalize +ratten +ravin +ravish +raze +rbound +reabandon +reabridge +reabsorb +reaccede +reaccelerate +reaccent +reaccentuate +reaccept +reacclaim +reacclimate +reacclimatize +reaccommodate +reaccompany +reaccredit +reaccumulate +reaccuse +reaccustom +reacidify +reacknowledge +reacquaint +reacquire +react +reactivate +read +readapt +readd +readdress +readiest +readjourn +readjudicate +readjust +readmit +readopt +readorn +readvertise +readvertize +readvise +readvocate +reaffect +reaffiliate +reaffirm +reafforest +reaggregate +reagitate +realienate +realign +realine +realise +realize +reallege +reallocate +reallot +realter +reamalgamate +reamass +reamend +reanalyze +reanchor +reanimate +reannex +reannotate +reannounce +reanoint +reantagonize +reap +reapologize +reappeal +reappear +reapplaud +reapply +reappoint +reapportion +reappraise +reapprehend +reapproach +reappropriate +reapprove +rearbitrate +reargue +rearise +rearisen +rearm +rearose +rearouse +rearrange +rearticulate +reascend +reasonless +reassail +reassemble +reassent +reassert +reassess +reassign +reassimilate +reassist +reassociate +reassort +reassume +reassure +reast +reattach +reattack +reattain +reattempt +reattest +reattire +reattract +reattribute +reauthenticate +reauthorize +reave +reavow +reawake +reawaken +reawoke +rebait +rebake +rebalance +rebale +rebandage +rebank +rebaptize +rebathe +rebellow +rebend +rebent +rebill +rebind +rebleach +reblend +reblister +reblock +rebloom +reblossom +reboard +reboil +rebolt +reboot +rebrace +rebrand +rebrew +rebrighten +rebroaden +rebrush +rebuckle +rebudget +rebuild +rebury +rebut +rebutton +recable +recage +recalcitrate +recalculate +recalesce +recalk +recampaign +recancel +recane +recant +recapitalize +recapitulate +recarpet +recarry +recarve +recatalog +recatalogue +recategorize +recaution +recchose +recchosen +recede +receive +recelebrate +recement +recensor +recentralize +recertify +rechallenge +rechannel +recharge +rechart +recharter +rechoose +rechristen +recidivate +reciprocate +recircle +recirculate +recite +reck +reckon +reclasp +reclass +reclassify +reclean +recleanse +reclimb +recline +reclothe +recoagulate +recoat +recode +recodify +recognise +recognize +recoin +recollect +recolonise +recolonize +recolor +recolour +recomb +recombine +recomfort +recommence +recommend +recommit +recompare +recompensate +recompile +recompose +recompound +recompute +reconceal +reconcentrate +reconcile +recondemn +recondense +recondition +reconduct +reconfer +reconfine +reconfirm +reconfiscate +reconform +reconfront +reconfuse +reconnect +reconnoiter +reconquer +reconsecrate +reconsent +reconsider +reconsign +reconsole +reconsolidate +reconstruct +reconsult +recontemplate +recontend +recontest +recontract +reconvene +reconverge +reconvert +reconvict +recook +recool +recopy +recorrect +recost +recostume +recounsel +recover +recrate +recreate +recriminate +recriticize +recross +recrown +recrudesce +recrystallise +recrystallize +rectify +recultivate +recuperate +recur +recurve +recuse +recut +redact +redamage +redare +redarn +redate +redden +redebit +redecay +redeceive +redecide +redeclare +redecline +redecorate +rededicate +redeem +redefine +redefy +redelegate +redelete +redeliberate +redeliver +redemand +redemonstrate +redeny +redepend +redeploy +redepreciate +redescend +redescribe +redesert +redesign +redesignate +redetermine +redevelop +redictate +redid +redifferentiate +rediffuse +redig +redigest +redilate +redintegrate +redip +redirect +redisburse +redischarge +rediscipline +rediscover +rediscuss +redisinfect +redismiss +redispatch +redisperse +redisplay +redispose +redispute +redissect +redissolve +redistill +redistinguish +redistribute +redistrict +redivert +redivide +redline +redo +redock +redocket +redocument +redominate +redone +redound +redraw +redrawn +redrew +redrill +redrive +redriven +redroop +redrove +redrug +redry +reduce +redug +reduplicate +redust +redye +reearn +reecho +reedify +reedit +reeducate +reeject +reelect +reelevate +reem +reemanate +reembark +reembellish +reembody +reembrace +reemerge +reemigrate +reemit +reemphasize +reemploy +reenact +reenclose +reencourage +reendorse +reendow +reenergize +reenforce +reengage +reengrave +reengross +reenjoin +reenjoy +reenlarge +reenlighten +reenslave +reenter +reenumerate +reenunciate +reequip +reerect +reerupt +reest +reestablish +reevacuate +reevaluate +reevidence +reexamine +reexcavate +reexchange +reexecute +reexercise +reexhibit +reexpand +reexpel +reexperience +reexplain +reexplicate +reexplore +reexpose +reexpress +reface +refamiliarize +refashion +refasten +refect +refederalize +refederate +refeel +refertilize +reffelt +reffroze +reffrozen +refile +refilm +refilter +refinance +refind +refine +refire +refix +reflate +reflect +refloat +reflow +refocus +refold +reforecast +reforest +reforfeit +reforge +reformulate +refortify +reforward +refract +refracture +reframe +refreeze +refresh +refreshen +refrigerate +refrustrate +refry +reft +refuel +refunction +refurbish +refurnish +refute +regain +regalvanize +regamble +regarment +regarnish +regarrison +regather +regauge +regave +regear +regel +regelate +regenerate +regerminate +regild +regionalize +regird +registrate +regive +regiven +reglaze +reglorify +reglue +regorge +regovern +regrab +regradate +regrade +regraft +regraph +regrasp +regrate +regrease +regreet +regrew +regrind +regrip +reground +regroup +regrow +regrown +reguide +regularize +regulate +regurgitate +rehabilitate +rehammer +rehandle +rehang +reharden +reharmonize +reharness +reharvest +rehaul +rehear +rehearse +reheel +rehem +rehid +rehidden +rehide +rehinge +rehire +rehone +rehonor +rehospitalize +rehouse +rehumanize +rehumiliate +rehung +rehypnotize +rehypothecate +reice +reidentify +reify +reignite +reilluminate +reillustrate +reimage +reimburse +reimplant +reimplement +reimply +reimpose +reimpregnate +reimpress +reimprint +reimprison +reinaugurate +reincarnate +reincite +reincline +reinclude +reincorporate +reincrease +reincur +reindex +reindicate +reindict +reindoctrinate +reindorse +reinduce +reinduct +reindulge +reindustrialize +reinfect +reinfer +reinfest +reinfiltrate +reinflame +reinflate +reinfluence +reinforce +reinform +reinfuse +reinhabit +reinherit +reinject +reinjure +reink +reinoculate +reinquire +reinscribe +reinsert +reinsist +reinspect +reinspire +reinstall +reinstate +reinstitute +reinstruct +reinsulate +reinsure +reintegrate +reinter +reinterpret +reinterrogate +reinterrupt +reintervene +reintrench +reintroduce +reinvade +reinvent +reinvest +reinvestigate +reinvigorate +reinvite +reinvoke +reinvolve +reirrigate +reisolate +reist +reitemize +reiterate +reive +rejail +rejeopardize +rejig +rejigger +rejoice +rejoin +rejudge +rejustify +rejuvenate +rejuvenesce +rejuvenise +rejuvenize +rekindle +reknead +reknit +reknock +reknot +relabel +relace +relacquer +reladle +relaid +relance +reland +relatch +relate +relativize +relaunch +relaunder +relax +relead +relearn +relegate +relend +relent +relet +reletter +relevel +relever +relevy +reliberate +relicense +relieve +relight +relimit +reline +relink +relinquish +reliquefy +reliquidate +relist +relisten +relitigate +relive +relocate +relose +relost +relower +relubricate +reluct +relume +rely +relyric +remagnetize +remagnify +remail +remaim +remain +reman +remanifest +remanufacture +remap +remarket +remarry +remarshal +remaster +remasticate +rematerialize +rematriculate +remeasure +remediate +remelt +remember +rememorize +remend +remention +remerge +remigrate +remilitarize +remill +remind +remingle +reminisce +remint +remix +remobilize +remodel +remodify +remodulate +remold +remollify +remonetise +remonetize +remonstrate +remortgage +remultiply +remunerate +renail +rename +renationalize +renavigate +rend +renegate +renegotiate +reneutralize +renew +renominate +renormalize +renotarize +renotice +renotify +renourish +renovate +renullify +renumber +renumerate +reobject +reobligate +reoblige +reobserve +reobtain +reoccupy +reoccur +reoffend +reoil +reopen +reoperate +reoppose +reoppress +reorchestrate +reordain +reorganise +reorganize +reorient +reorientate +reornament +reoutfit +reoutline +reoxidise +reoxidize +repacify +repack +repackage +repad +repaginate +repanel +repaper +repark +repaste +repatch +repatrol +repatronize +repattern +repave +repawn +repay +repeddle +repel +repen +repenalize +repent +repeople +reperceive +reperform +reperuse +rephrase +repick +repin +repine +replace +replan +replane +replant +replaster +replate +replead +repledge +replenish +replete +replicate +replot +replow +replume +replunge +repoint +repolarize +reponder +repone +repopularize +repopulate +reportion +reposit +repossess +repost +repostpone +repostulate +repot +repour +repractice +repraise +reprehend +repremise +reprepare +represcribe +represent +repress +reprice +reprime +reprobe +reprocess +reproclaim +reproduce +reprogram +reproject +repromise +repromulgate +reproportion +repropose +reprosecute +reprove +reprovision +reprune +republicanise +republicanize +republish +repudiate +repugn +repunctuate +repunish +repurify +repurpose +repursue +requalify +requestion +requicken +require +requite +requote +reradiate +reran +rerank +rerate +reread +rereel +reregister +reregulate +rerent +rerise +rerisen +reroll +rerose +reroute +resaddle +resail +resalt +resalute +resample +resanction +resat +resawn +rescale +reschedule +reschool +rescind +rescrub +rescrutinize +reseal +reseason +reseat +resecure +reseek +resegregate +reseize +reselect +resell +resemble +resend +resensitize +resent +reseparate +reservice +reset +resettle +resew +resewn +reshake +reshaken +reshape +reshare +resharpen +reshave +reshew +reshift +reshine +reshingle +reshod +reshoe +reshook +reshoot +reshorten +reshoulder +reshow +reshower +reshut +resicken +reside +resift +resight +resign +resignal +resile +resilver +resimmer +resinate +resinify +resit +resituate +resize +resketch +reslander +resmooth +resmudge +resoak +resoften +resoil +resold +resolder +resole +resolicit +resolidify +resonate +resorb +resought +resound +resow +resown +respace +respade +respecify +respice +respire +resplice +resprang +respray +respread +resprinkle +resquander +resshot +restab +restabilize +restable +restack +restaff +restage +restain +restamp +restart +restate +restation +resterilize +restimulate +restipulate +restir +restitch +restitute +restock +restore +restraighten +restrain +restrap +restrengthen +restress +restricken +restrict +restrive +restriven +restrove +restruck +restructure +restrung +restuff +restung +restyle +resubject +resublimate +resublime +resubmerge +resubmit +resubscribe +resubstantiate +resulfurize +resulphurize +resummon +resupply +resuppress +resurface +resurge +resurrect +resuscitate +resuspend +reswallow +reswear +resweep +resweeten +reswell +reswept +reswore +resymbolize +resynthesize +resynthetize +resystematize +ret +retabulate +retack +retain +retaliate +retan +retape +retar +retariff +retaste +retaught +retax +reteach +retear +retelegraph +retelephone +retelevise +retell +retemper +retestify +rethank +rethatch +rethaw +rethicken +rethought +rethread +rethreaten +rethresh +retick +reticulate +retie +retighten +retile +retill +retime +retin +retinge +retint +retire +retiringly +retitle +retoast +retold +retool +retotal +retrace +retrack +retract +retrade +retrain +retranscribe +retranslate +retransmit +retransplant +retraverse +retrench +retroact +retrocede +retrofit +retrograde +retrogress +retroject +retry +rettore +rettorn +retune +returf +retwine +retwist +retype +reune +reunify +reunite +reupholster +reuse +reutilise +reutilize +reutter +revacate +revaccinate +revalidate +revalorize +revaluate +revalue +revaporize +revarnish +revegetate +revend +reventilate +reverberate +reverify +revest +revet +reveto +revibrate +revictual +revile +revindicate +reviolate +revisit +revisualize +revitalise +revitalize +revive +revivify +revoice +revolutionise +revolutionize +revolve +rewake +rewaken +rewarm +rewarn +rewarrant +rewash +rewater +rewax +reweaken +rewear +reweave +reweigh +reweld +rewet +rewiden +rewin +rewire +reword +rework +rewound +rewrap +rewritten +rewrote +rewwore +rewwove +reyoke +rezone +rfound +rhapsodize +rhubarb +rid +ridden +right +righten +rigidify +rile +ripen +risen +ritualize +rive +riven +rob +robotize +roentgenize +roger +roil +roister +roleplay +romanize +romanticize +roneo +roose +rootle +rotate +roughen +roust +routinize +royalise +royalize +rubberise +rubberize +rubberstamp +rubify +rubricate +ruckle +ruddle +ruggedize +ruminate +runtgenize +ruralise +ruralize +rusticate +rwound +saccarify +sad +sadden +sain +saith +salify +salinate +salivate +saltate +sanctify +sanitise +sanitize +sank +saponify +sate +satiate +satirise +satirize +satisfy +saturate +saute +save +sawn +say +scabble +scandalise +scandalize +scant +scarify +scart +scavenge +schematise +schematize +schillerize +schlep +schmoose +schreinerize +scintillate +scissor +scorify +scram +scramb +scranch +scraunch +scriech +scrimp +scrimpy +scrimshank +scrouge +scrounge +scrump +scrutinise +scrutinize +scry +sculpsit +sculpt +scummy +scurries +seals +secede +secern +secernate +seclude +secondguess +secrete +sectarianise +sectarianize +sectionalise +sectionalize +secularise +secularize +secundus +secure +sedate +seduce +seel +seem +seen +segregate +segue +seise +seize +select +sensationalise +sensibilize +sensify +sensitize +sensualize +sent +sentimentalise +sentimentalize +septuple +sequester +sequestrate +serialise +serialize +sermonise +sermonize +serpentinize +serrate +serry +set +setup +sever +severalize +sew +sewn +sexualize +shadowbox +shaken +shall +shalt +shamanize +shapen +sharecrop +sharpen +sharpshoot +sheathe +shellac +shelve +shend +shent +sherardize +shew +shies +shit +shlep +shmooze +shod +shodden +shone +shoo +shoot +shoplift +shorn +shorten +shortlist +should +shouldst +show +shown +shrank +shrill +shrinkwrap +shrive +shrivel +shrove +shrunk +shrunken +shun +shush +sibilate +sic +sicken +sift +sightsee +signa +signalise +signalize +signetur +signify +sile +silicify +silverise +silverplate +simonize +simplify +simulate +singularize +sipe +siss +sit +sitten +situate +siver +sizz +skee +skeletonise +skeletonize +sken +sket +skiddoo +skimp +skintle +skip +skitter +skive +skreak +skreigh +skriech +skriegh +skydive +skyjack +skywrite +skywritten +skywrote +slacken +slake +slank +slay +sleek +sleepwalk +slenderize +slept +slid +slidden +slim +slimmest +slow +slubber +slunk +smarten +smite +smitten +smoodge +smoothen +smote +smuggle +snap +snarf +snig +snip +snowk +snuck +snuggest +sny +sober +socialise +socialize +sociologize +sod +sodden +sodomize +soften +solarize +sold +solemnify +solemnize +solicit +solidarize +solidify +soliloquise +soliloquize +solmizate +solubilize +solve +sonnetise +sonnetize +sool +soothe +soothsaid +soothsay +sorcerize +sorn +sought +soundproof +sovietize +sown +spae +spag +spake +spang +sparest +sparge +sparkplug +spay +speak +specialise +specialize +specify +spectate +speculate +speechify +spelbound +spellbind +spelunk +spend +spent +sphacelate +spiderweb +spiflicate +spilt +spirantize +spiritize +spiritualize +splenectomize +spoilt +spoken +spoliate +spondaize +sporulate +spotweld +spraddle +sprang +sprauchle +spreadeagle +sprucest +spruik +sprung +spue +spun +squeaky +squeg +squinnies +stabilise +stabilize +stablish +stacher +stagnate +standardise +standardize +stargaze +start +starve +steady +steepen +stellify +sterilise +sterilize +stickle +stiffen +stigmatize +stipulate +stoke +stolen +stonewall +stonewash +stonker +stood +stopt +stot +stow +straighten +straiten +strangle +strangulate +stratify +stravaig +streetwalk +strengthen +strew +strewn +striate +stridulate +stript +strive +strode +strome +strook +strove +strow +strown +stroy +struck +strung +stuck +stultify +stung +stunk +stupefy +stupify +stylise +stylize +stylopize +subadministrate +subaerate +subcompensate +subconnect +subcontrol +subcool +subdate +subdemonstrate +subdivide +subduce +subduct +subdue +subedit +subendorse +subentitle +suberise +suberize +subgape +subinfer +subinfeudate +subinform +subinitial +subinsert +subintroduce +subirrigate +subjectify +subjoin +subjugate +submerge +submerse +subminiaturize +submit +suborn +subrogate +subscribe +subserve +subside +subsidize +subsist +subspecialize +substandardize +substantialize +substantiate +substantivize +subsume +subtend +subterraneanize +subtilise +subtilize +subtract +suburbanise +suburbanize +subvene +subvert +succumb +succuss +suckle +sue +suffer +suffice +sufflate +suffocate +suffumigate +suffuse +sugarcoat +sugg +suggest +sulfatize +sulfurette +sulfurize +sullies +sulphatize +sulphurate +sulphuret +sulphurette +sulphurize +summarise +summarize +summate +summerize +summon +sunbathe +sunburnt +sunday +sung +sunken +superabhor +superabound +superaccrue +superaccumulate +superactivate +superadd +superannuate +superassume +superastonish +superbuild +supercharge +supercool +superemphasize +superendorse +superendow +superengrave +supererogate +superestablish +superexalt +superexert +superexpand +superextend +superextol +superextoll +superfulfill +superfuse +supergovern +supergratify +supergravitate +superheat +superhumanize +superillustrate +superimpend +superimply +superimpose +superinduce +superinfer +superinfuse +superinscribe +superinsist +superintend +superlie +supermanifest +supermoisten +supernaturalise +supernaturalize +superobject +superordain +superoxygenate +superpose +superqualify +superquote +superrefine +supersatisfy +supersaturate +superscribe +supersede +supersensitise +supersensitize +supersimplify +supersolicit +superspecialize +superstimulate +superstruct +supersubsist +supersulfurize +supersulphurize +supertempt +supertrain +supervene +supervise +supinate +supplant +supple +supplely +supplicate +suppose +suppress +suppurate +surmount +surpass +survive +suspend +suspire +suss +sustain +susurrate +swaggi +swam +swang +sweal +sweeten +swept +swinge +swith +swive +swiver +swollen +swonk +swonken +swore +sworn +swosh +swum +swung +syllabicate +syllabify +syllabise +syllabize +syllogize +symbolise +symbolize +symmetrise +symmetrize +sympathise +sympathize +symphonise +symphonize +synchronise +synchronize +syncopate +syncretize +synonymise +synonymize +synopsise +synopsize +synthesise +synthesize +synthetise +syntonise +syntonize +sypher +syphilize +systematise +systematize +systemise +systemize +ta'en +tabularise +tabularize +tabulate +take +tallyho +tame +tantalise +tantalize +tapdance +tarmac +tarries +tarry +tartarize +taught +tauten +tautologise +tautologize +tautomerize +teargas +teem +teethe +telecommunicate +telefax +telepathize +televise +televize +tellurize +temporise +temporize +tempt +tend +tenderise +tenderize +tepefy +tergiversate +terminate +terrasse +terrify +territorialise +territorialize +terrorise +terrorize +tesselate +tessellate +testify +testimonialize +tetanise +tetanize +thank +theatricalise +theatricalize +theologise +theologize +theorise +theorize +thermalize +thicken +thieve +thig +thin +thirl +thoriate +thraw +threap +threaten +threw +thrive +thrombose +throve +thrown +thurify +thwack +ties +tighten +timber +tink +tintinnabulate +tippytoe +titillate +titivate +titrate +tittivate +told +tolerate +tonguetie +took +topdress +topple +torn +torrefy +tost +totalitarianize +totalize +touch +toughen +traduce +traject +trammel +tranquilize +tranquillize +transact +transcend +transcendentalize +transchange +transcribe +transdialect +transduce +transect +transelementate +transessentiate +transfeature +transfigure +transfix +transfuse +transgress +tranship +transilluminate +transistorize +transitivize +translate +transliterate +translocate +transmade +transmake +transmigrate +transmit +transmogrify +transmold +transmould +transmute +transpierce +transpirate +transpire +transpour +transshape +transshift +transship +transubstantiate +transude +transvalue +traumatize +treck +triangulate +trichinise +trichinize +tries +trimmest +trisect +tritiate +trivialise +trivialize +troat +trod +trodden +trode +trog +trollies +tropicalise +tropicalize +troubleshoot +troublesshot +trounce +trow +truncate +try +tubercularise +tubercularize +tuberculinise +tuberculinize +tuberculise +tubulate +tumefy +tut +tutoyer +tweedle +tweet +tweeze +twotime +typecast +typeset +typewrite +typewritten +typewrote +typify +tyrannise +tyrannize +ubound +uglify +ulcerate +ululate +unaccustom +unarm +unbait +unbale +unbandage +unbar +unbarbarise +unbarbarize +unbarricade +unbay +unbeard +unbelt +unbench +unbend +unbent +unberth +unbind +unbit +unblade +unblock +unbolster +unbolt +unbonnet +unbosom +unbottle +unbottom +unbound +unbox +unbrace +unbraid +unbridle +unbrooch +unbrutalise +unbrutalize +unbrutise +unbrutize +unbuckle +unbud +unbuild +unbuilt +unburden +unbutton +uncake +uncalk +uncanonise +uncanonize +uncap +uncase +uncask +uncatholicise +uncatholicize +unchain +unchair +unchapter +unchariot +unchurch +unchurn +uncinch +uncivilize +unclasp +unclench +unclinch +unclip +uncloak +unclog +unclose +unclothe +unclutter +uncoat +uncoffin +uncoil +uncollar +uncolonise +uncolonize +uncondition +unconfirm +unconfound +uncongeal +uncoop +uncore +uncork +uncorrect +uncouple +uncover +uncrate +uncredit +uncrib +uncross +uncrown +uncurb +uncurd +uncurl +undam +undarken +undeceive +undemocratise +undemocratize +underachieve +underact +underbake +underbalance +underballast +underbank +underbid +underbillow +underboil +underboom +underbrew +underbuild +underbuilt +underbuy +undercanvass +undercapitalize +undercarry +undercarve +underconsume +undercool +undercorrect +undercrawl +underdevelop +underdevelope +underdid +underdig +underdo +underdraw +underdrawn +underdrew +underdry +underdug +undereat +undereate +undereaten +underexercise +underexpose +underfinance +underfortify +underfurnish +undergarnish +undergird +undergnaw +undergo +undergone +undergrow +underhang +underhatch +underheat +underhorse +underjoin +underlaid +underlap +underlet +underlie +underload +underman +undermeasure +undermine +undernourish +underoxidise +underoxidize +underpaid +underpay +underpeep +underpeer +underpin +underplant +underplay +underpopulate +underprice +underprize +underproduce +underprop +underquote +underran +underrate +underrealise +underrealize +underreckon +underrecompense +underrepresent +underroast +undersaw +undersee +underseen +undersell +undershone +undershoot +undershorten +undersign +undersleep +underslept +undersold +underspecify +underspend +underspent +undersplice +underspread +undersshot +understand +understate +understeer +understood +understrew +understricken +understrike +understruck +understudies +understuff +undersweep +underswept +undertake +undertaught +underteach +undertest +underthaw +undertook +undertrade +undertrain +undertrump +undertruss +undervalue +underventilate +underwash +underwent +underwind +underwork +underwrite +underwritten +underwrote +undid +undistend +undo +undock +undouble +undrape +undraw +undrawn +undrest +undrew +undulate +unearth +unedge +unequalise +unequalize +unfasten +unfeminise +unfeminize +unfence +unfetter +unfeudalise +unfeudalize +unffroze +unfile +unfit +unfix +unflank +unfloor +unfold +unfork +unfree +unfreeze +unfrill +unfringe +unfrock +unfrost +unfurl +ungag +ungarland +ungarter +ungird +ungirdle +ungirt +ungladden +ungloom +unglue +ungrip +unhaft +unhair +unhallow +unhand +unhandcuff +unharden +unharmonise +unharmonize +unharness +unhasp +unhedge +unhelm +unhinge +unhitch +unhood +unhook +unhorse +unhouse +unhuddle +unhull +unhumanise +unhumanize +unhusk +unhypnotise +unhypnotize +unice +uniformise +uniformize +unify +uninsulate +unionise +unionize +unisolate +unitize +universalise +universalize +unjam +unjoin +unkennel +unkink +unknit +unknot +unlabialise +unlabialize +unlace +unlade +unlash +unlatch +unlax +unlay +unlead +unleaf +unlearn +unleash +unlimber +unlink +unlive +unload +unlocalise +unlocalize +unlock +unloop +unloose +unmade +unmake +unman +unmap +unmarbelize +unmarbleize +unmask +unmast +unmate +unmerge +unmesh +unmew +unmiter +unmitre +unmix +unmoisten +unmold +unmoor +unmortgage +unmortise +unmould +unmuffle +unmuzzle +unmysticise +unmysticize +unnaturalise +unnaturalize +unnerve +unneutralise +unneutralize +unpack +unpaganize +unpaste +unpedestal +unpeg +unpen +unpeople +unpick +unpictorialise +unpictorialize +unpile +unpin +unplait +unplan +unplaster +unplug +unpocket +unpot +unprison +unpuzzle +unquote +unrack +unravel +unrealise +unrealize +unreckon +unreeel +unreel +unreeve +unrhyme +unriddle +unrig +unrip +unrobe +unroll +unroof +unroot +unround +unrrove +unruffle +unrust +unsaddle +unsay +unscabbard +unscramble +unscrew +unseal +unseam +unseat +unsectarianize +unsell +unsensitise +unsensitize +unsepulcher +unsepulchre +unsettle +unsex +unshackle +unshade +unsheathe +unship +unshroud +unsnap +unsnarl +unsold +unsolder +unsole +unsort +unspan +unspeak +unspell +unsphere +unstaple +unstate +unsteady +unsteel +unstep +unstick +unstop +unstopper +unstrain +unstrap +unstuff +unsubstantialize +unswathe +unswear +unswivel +unswore +unsworn +untack +untangle +unteach +unthaw +unthicken +unthink +unthorn +unthought +unthread +unthrone +untidy +untie +untighten +untilt +untranquilize +untranquillise +untread +untrodden +untruss +unttrod +untuck +untune +untwine +untwist +unveil +unvoice +unvulgarise +unvulgarize +unwall +unweave +unwedge +unwheel +unwig +unwind +unwire +unwish +unwomb +unwound +unwrap +unwreathe +unwrinkle +unwwove +unwwoven +unyoke +unzip +unzone +upbbore +upbborne +upbear +upbraid +upbuild +upbuilt +upchuck +updo +upend +upfold +upgather +upheave +upheld +uphhove +uphold +upholster +upload +upraise +uprear +uprisen +uproot +uprose +uprouse +upswell +upswept +upswollen +uptear +upthrew +upthrown +uptilt +uptorn +upttore +upttorn +urbanise +urbanize +urinate +urticate +uspoke +uspoken +usurp +uti +utilise +utilize +utter +vacate +vaccinate +vacillate +validate +valorise +valorize +valuate +vamoose +vamose +vandalise +vandalize +vanquish +vaporize +vapourise +vapourize +variegate +variolate +vary +vasectomise +vasectomize +vassalize +vaticinate +vegetate +velarize +velcro +vellicate +vend +venerate +venge +ventilate +ventriloquise +ventriloquize +verbalise +verbalize +verbify +verify +vermiculate +verminate +vernacularise +vernacularize +vernalise +vernalize +versify +vesicate +vesiculate +vex +vibrate +victimise +victimize +vide +videotape +vilify +vilipend +vindicate +vinify +vinylate +violate +visualize +vitalise +vitalize +vitaminize +vitiate +vitrify +vitriolize +vituperate +vivify +vivisect +vocalize +vociferate +volatilise +volatilize +volcanize +vouchsafe +vulcanise +vulcanize +vulgarise +vulgarize +wair +wait +waitlist +waive +wanna +warn +was +wast +waul +wawl +waxen +waylay +weaken +weary +weatherproof +weatherstrip +ween +weighman +weightlift +welch +well +wend +went +wept +were +wert +westernise +westernize +whack +wheedle +wheelabrate +whelm +whicker +whiffle +whipsawn +whipt +whirry +whist +whistlestop +whiten +whizz +widen +wield +wifely +wilder +windsurf +winterize +wiredraw +wiredrawn +wiredrew +wis +wist +withdraw +withdrawn +withdrew +wither +withhold +withstand +withstood +wive +woke +woken +womanise +womanize +woo +wooden +woof +woolgather +wore +worn +worrit +worsen +wot +would +wouldst +wove +woven +wow +wrawl +wreak +wreathe +write +writhen +wrote +wrought +wrung +xerox +yaff +yap +yarovize +yclad +yclept +yean +yearn +yirr +youthen +zap +zincify +zindabad +zipping \ No newline at end of file diff --git a/tests/Basic/Basic.Tests.cs b/tests/Basic/Basic.Tests.cs index bcd8639e..bbfe8be0 100644 --- a/tests/Basic/Basic.Tests.cs +++ b/tests/Basic/Basic.Tests.cs @@ -112,17 +112,17 @@ public class BasicTests public void TestAbstractReturnType() { var returnsAbstractFoo = new ReturnsAbstractFoo(); - var abstractFoo = returnsAbstractFoo.getFoo(); - Assert.AreEqual(abstractFoo.pureFunction(), 5); - Assert.AreEqual(abstractFoo.pureFunction1(), 10); - Assert.AreEqual(abstractFoo.pureFunction2(), 15); + var abstractFoo = returnsAbstractFoo.Foo; + Assert.AreEqual(abstractFoo.pureFunction, 5); + Assert.AreEqual(abstractFoo.pureFunction1, 10); + Assert.AreEqual(abstractFoo.pureFunction2, 15); } [Test] public void TestANSI() { Foo foo = new Foo(); - Assert.That(foo.GetANSI(), Is.EqualTo("ANSI")); + Assert.That(foo.ANSI, Is.EqualTo("ANSI")); } } \ No newline at end of file diff --git a/tests/VTables/VTables.Tests.cs b/tests/VTables/VTables.Tests.cs index 6e932713..c3343154 100644 --- a/tests/VTables/VTables.Tests.cs +++ b/tests/VTables/VTables.Tests.cs @@ -4,10 +4,13 @@ using VTables; public class FooDerived : Foo { - public override int vfoo() + public override int vfoo { - Console.WriteLine("Hello from FooDerived"); - return 10; + get + { + Console.WriteLine("Hello from FooDerived"); + return 10; + } } } @@ -18,8 +21,8 @@ public class VTablesTests public void TestFoo() { var foo = new Foo(); - Assert.That(foo.vfoo(), Is.EqualTo(5)); - Assert.That(foo.Vbar(), Is.EqualTo(3)); + Assert.That(foo.vfoo, Is.EqualTo(5)); + Assert.That(foo.Vbar, Is.EqualTo(3)); Assert.That(foo.CallFoo(), Is.EqualTo(7)); var foo2 = new FooDerived(); From fcb1ab67ca1956ceaead39b86c57054dea76b1f7 Mon Sep 17 00:00:00 2001 From: Dimitar Dobrev Date: Wed, 2 Oct 2013 21:54:03 +0300 Subject: [PATCH 2/6] Added tests for properties. Signed-off-by: Dimitar Dobrev --- .../Passes/GetterSetterToPropertyPass.cs | 43 +++++++++++++++---- tests/Basic/Basic.Tests.cs | 2 +- tests/CSharpTemp/CSharpTemp.Tests.cs | 23 ++++++++-- tests/CSharpTemp/CSharpTemp.cpp | 30 +++++++++++++ tests/CSharpTemp/CSharpTemp.h | 29 +++++++++++++ 5 files changed, 113 insertions(+), 14 deletions(-) diff --git a/src/Generator/Passes/GetterSetterToPropertyPass.cs b/src/Generator/Passes/GetterSetterToPropertyPass.cs index 6e591fac..98b5d945 100644 --- a/src/Generator/Passes/GetterSetterToPropertyPass.cs +++ b/src/Generator/Passes/GetterSetterToPropertyPass.cs @@ -1,8 +1,10 @@ using System; using System.Collections.Generic; +using System.Globalization; using System.IO; using System.Linq; using System.Reflection; +using System.Text; using CppSharp.AST; namespace CppSharp.Passes @@ -77,15 +79,19 @@ namespace CppSharp.Passes foreach (var setter in group) { Class type = (Class) setter.Namespace; - string afterSet = setter.Name.Substring(3); + StringBuilder nameBuilder = new StringBuilder(setter.Name.Substring(3)); + if (char.IsLower(setter.Name[0])) + nameBuilder[0] = char.ToLowerInvariant(nameBuilder[0]); + string afterSet = nameBuilder.ToString(); foreach (var getter in nonSetters.Where(m => m.Namespace == type)) { - if (string.Compare(getter.Name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 && + string name = GetPropertyName(getter.Name); + if (string.Compare(name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 && getter.ReturnType == setter.Parameters[0].QualifiedType && !type.Methods.Any( m => m != getter && - string.Compare(getter.Name, m.Name, StringComparison.OrdinalIgnoreCase) == 0)) + string.Compare(name, m.Name, StringComparison.OrdinalIgnoreCase) == 0)) { GenerateProperty(getter.Namespace, getter, readOnly ? null : setter); goto next; @@ -105,9 +111,7 @@ namespace CppSharp.Passes foreach (Method nonSetter in nonSetters) { Class type = (Class) nonSetter.Namespace; - string name = nonSetter.Name; - if (GetFirstWord(name) == "get") - name = name.Substring(3); + string name = GetPropertyName(nonSetter.Name); Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = name }); if (!type.IsInterface && baseVirtualProperty != null) { @@ -129,7 +133,7 @@ namespace CppSharp.Passes p.ExplicitInterfaceImpl != getter.ExplicitInterfaceImpl)) { Property property = new Property(); - property.Name = getter.Name.Substring(GetFirstWord(getter.Name) == "get" ? 3 : 0); + property.Name = GetPropertyName(getter.Name); property.Namespace = type; property.QualifiedType = getter.ReturnType; if (getter.IsOverride || (setter != null && setter.IsOverride)) @@ -138,7 +142,7 @@ namespace CppSharp.Passes if (baseVirtualProperty.SetMethod == null) setter = null; foreach (Method method in type.Methods.Where(m => m.Name == property.Name && m.Parameters.Count > 0)) - method.Name = "Get" + method.Name; + method.Name = "get" + method.Name; } property.GetMethod = getter; property.SetMethod = setter; @@ -155,6 +159,26 @@ namespace CppSharp.Passes } } + private static string GetPropertyName(string name) + { + if (GetFirstWord(name) == "get") + { + if (char.IsLower(name[0])) + { + if (name.Length == 4) + { + return char.ToLowerInvariant( + name[3]).ToString(CultureInfo.InvariantCulture); + } + return char.ToLowerInvariant( + name[3]).ToString(CultureInfo.InvariantCulture) + + name.Substring(4); + } + return name.Substring(3); + } + return name; + } + private void DistributeMethod(Method method) { @@ -191,7 +215,8 @@ namespace CppSharp.Passes { char.ToLowerInvariant(name[0]) }; - firstVerb.AddRange(name.Skip(1).TakeWhile(char.IsLower)); + firstVerb.AddRange(name.Skip(1).TakeWhile( + c => char.IsLower(c) || !char.IsLetterOrDigit(c))); return new string(firstVerb.ToArray()); } } diff --git a/tests/Basic/Basic.Tests.cs b/tests/Basic/Basic.Tests.cs index bbfe8be0..abcf515e 100644 --- a/tests/Basic/Basic.Tests.cs +++ b/tests/Basic/Basic.Tests.cs @@ -112,7 +112,7 @@ public class BasicTests public void TestAbstractReturnType() { var returnsAbstractFoo = new ReturnsAbstractFoo(); - var abstractFoo = returnsAbstractFoo.Foo; + var abstractFoo = returnsAbstractFoo.foo; Assert.AreEqual(abstractFoo.pureFunction, 5); Assert.AreEqual(abstractFoo.pureFunction1, 10); Assert.AreEqual(abstractFoo.pureFunction2, 15); diff --git a/tests/CSharpTemp/CSharpTemp.Tests.cs b/tests/CSharpTemp/CSharpTemp.Tests.cs index fe6289ea..e24d3629 100644 --- a/tests/CSharpTemp/CSharpTemp.Tests.cs +++ b/tests/CSharpTemp/CSharpTemp.Tests.cs @@ -45,19 +45,34 @@ public class CSharpTempTests public void TestMultipleInheritance() { Baz baz = new Baz(); - Assert.That(baz.method(), Is.EqualTo(1)); + Assert.That(baz.method, Is.EqualTo(1)); var bar = (IBar) baz; - Assert.That(bar.method(), Is.EqualTo(2)); + Assert.That(bar.method, Is.EqualTo(2)); Assert.That(baz[0], Is.EqualTo(50)); bar[0] = new Foo { A = 1000 }; Assert.That(bar[0].A, Is.EqualTo(1000)); - Assert.That(baz.farAwayFunc(), Is.EqualTo(20)); + Assert.That(baz.farAwayFunc, Is.EqualTo(20)); Assert.That(baz.takesQux(baz), Is.EqualTo(20)); - Assert.That(baz.returnQux().farAwayFunc(), Is.EqualTo(20)); + Assert.That(baz.returnQux().farAwayFunc, Is.EqualTo(20)); int cast = baz; Assert.That(cast, Is.EqualTo(500)); var nested = new Baz.Nested(); int nestedCast = nested; Assert.That(nestedCast, Is.EqualTo(300)); } + + [Test] + public void TestProperties() + { + var proprietor = new Proprietor(); + proprietor.value = 20; + Assert.That(proprietor.value, Is.EqualTo(20)); + proprietor.prop = 50; + Assert.That(proprietor.prop, Is.EqualTo(50)); + var p = new P(); + p.value = 20; + Assert.That(p.value, Is.EqualTo(30)); + p.prop = 50; + Assert.That(p.prop, Is.EqualTo(150)); + } } \ No newline at end of file diff --git a/tests/CSharpTemp/CSharpTemp.cpp b/tests/CSharpTemp/CSharpTemp.cpp index d030f5af..ab01784a 100644 --- a/tests/CSharpTemp/CSharpTemp.cpp +++ b/tests/CSharpTemp/CSharpTemp.cpp @@ -65,3 +65,33 @@ Baz::operator int() const { return 500; } + +int AbstractProprietor::getValue() +{ + return m_value; +} + +void AbstractProprietor::setProp(long property) +{ + m_property = property; +} + +void Proprietor::setValue(int value) +{ + m_value = value; +} + +long Proprietor::prop() +{ + return m_property; +} + +void P::setValue(int value) +{ + m_value = value + 10; +} + +long P::prop() +{ + return m_property + 100; +} diff --git a/tests/CSharpTemp/CSharpTemp.h b/tests/CSharpTemp/CSharpTemp.h index 529a9589..f5faeb10 100644 --- a/tests/CSharpTemp/CSharpTemp.h +++ b/tests/CSharpTemp/CSharpTemp.h @@ -63,3 +63,32 @@ struct QByteArrayDataPtr { QByteArrayData* ptr; }; + +class DLL_API AbstractProprietor +{ +public: + virtual int getValue(); + virtual void setValue(int value) = 0; + + virtual long prop() = 0; + virtual void setProp(long prop); + +protected: + int m_value; + long m_property; +}; + +class DLL_API Proprietor : public AbstractProprietor +{ +public: + virtual void setValue(int value); + + virtual long prop(); +}; + +class DLL_API P : Proprietor +{ +public: + virtual void setValue(int value); + virtual long prop(); +}; From 27f8e28036752a4d01f1fee4bed83e8cfce5b848 Mon Sep 17 00:00:00 2001 From: Dimitar Dobrev Date: Wed, 2 Oct 2013 22:44:08 +0300 Subject: [PATCH 3/6] Fixed the generation of v-table calls to property setters. Ignored methods that are only named "get" and similar, as properties. Signed-off-by: Dimitar Dobrev --- .../Generators/CSharp/CSharpTextTemplate.cs | 15 ++++++++++++--- .../Passes/GetterSetterToPropertyPass.cs | 5 +++-- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs index 984c1194..e7bd048c 100644 --- a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs +++ b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs @@ -1264,9 +1264,18 @@ namespace CppSharp.Generators.CSharp } else { - var name = ((Class) method.Namespace).Properties.First( - p => p.GetMethod == method || p.SetMethod == method).Name; - WriteLine("target.{0};", name); + var property = ((Class) method.Namespace).Properties.FirstOrDefault( + p => p.GetMethod == method); + if (property == null) + { + property = ((Class) method.Namespace).Properties.First( + p => p.SetMethod == method); + WriteLine("target.{0} = {1};", property.Name, string.Join(", ", marshals)); + } + else + { + WriteLine("target.{0};", property.Name); + } } // TODO: Handle hidden structure return types. diff --git a/src/Generator/Passes/GetterSetterToPropertyPass.cs b/src/Generator/Passes/GetterSetterToPropertyPass.cs index 98b5d945..5bf2b77c 100644 --- a/src/Generator/Passes/GetterSetterToPropertyPass.cs +++ b/src/Generator/Passes/GetterSetterToPropertyPass.cs @@ -182,7 +182,7 @@ namespace CppSharp.Passes private void DistributeMethod(Method method) { - if (GetFirstWord(method.Name) == "set" && + if (GetFirstWord(method.Name) == "set" && method.Name.Length > 3 && method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void)) { if (method.Parameters.Count == 1) @@ -205,7 +205,8 @@ namespace CppSharp.Passes method.Parameters.Count > 0 || method.IsDestructor) return false; var result = GetFirstWord(method.Name); - return result == "get" || result == "is" || result == "has" || + return (result.Length < method.Name.Length && + (result == "get" || result == "is" || result == "has")) || (result != "to" && result != "new" && !verbs.Contains(result)); } From 19bae92f9b60727beef6723d2b7fb4c0fa039045 Mon Sep 17 00:00:00 2001 From: Dimitar Dobrev Date: Thu, 3 Oct 2013 01:38:58 +0300 Subject: [PATCH 4/6] Added a fake option so that the build stays healthy since the C++/CLI-back-end does not properly support properties yet. Signed-off-by: Dimitar Dobrev --- src/Generator/Driver.cs | 4 +++- tests/Basic/Basic.Tests.cs | 10 +++++----- tests/CSharpTemp/CSharpTemp.cs | 1 + tests/VTables/VTables.Tests.cs | 13 +++++-------- 4 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/Generator/Driver.cs b/src/Generator/Driver.cs index deca3f22..6c790857 100644 --- a/src/Generator/Driver.cs +++ b/src/Generator/Driver.cs @@ -158,7 +158,8 @@ namespace CppSharp TranslationUnitPasses.AddPass(new MultipleInheritancePass()); TranslationUnitPasses.AddPass(new ParamTypeToInterfacePass()); } - TranslationUnitPasses.AddPass(new GetterSetterToPropertyPass()); + if (Options.GenerateProperties) + TranslationUnitPasses.AddPass(new GetterSetterToPropertyPass()); } public void ProcessCode() @@ -289,6 +290,7 @@ namespace CppSharp public bool GenerateVirtualTables; public bool GenerateAbstractImpls; public bool GenerateInterfacesForMultipleInheritance; + public bool GenerateProperties; public bool GenerateInternalImports; public string IncludePrefix; public bool WriteOnlyWhenChanged; diff --git a/tests/Basic/Basic.Tests.cs b/tests/Basic/Basic.Tests.cs index abcf515e..bcd8639e 100644 --- a/tests/Basic/Basic.Tests.cs +++ b/tests/Basic/Basic.Tests.cs @@ -112,17 +112,17 @@ public class BasicTests public void TestAbstractReturnType() { var returnsAbstractFoo = new ReturnsAbstractFoo(); - var abstractFoo = returnsAbstractFoo.foo; - Assert.AreEqual(abstractFoo.pureFunction, 5); - Assert.AreEqual(abstractFoo.pureFunction1, 10); - Assert.AreEqual(abstractFoo.pureFunction2, 15); + var abstractFoo = returnsAbstractFoo.getFoo(); + Assert.AreEqual(abstractFoo.pureFunction(), 5); + Assert.AreEqual(abstractFoo.pureFunction1(), 10); + Assert.AreEqual(abstractFoo.pureFunction2(), 15); } [Test] public void TestANSI() { Foo foo = new Foo(); - Assert.That(foo.ANSI, Is.EqualTo("ANSI")); + Assert.That(foo.GetANSI(), Is.EqualTo("ANSI")); } } \ No newline at end of file diff --git a/tests/CSharpTemp/CSharpTemp.cs b/tests/CSharpTemp/CSharpTemp.cs index 19c40511..b5abc376 100644 --- a/tests/CSharpTemp/CSharpTemp.cs +++ b/tests/CSharpTemp/CSharpTemp.cs @@ -13,6 +13,7 @@ namespace CppSharp.Tests public override void SetupPasses(Driver driver) { driver.Options.GenerateInterfacesForMultipleInheritance = true; + driver.Options.GenerateProperties = true; } static class Program diff --git a/tests/VTables/VTables.Tests.cs b/tests/VTables/VTables.Tests.cs index c3343154..6e932713 100644 --- a/tests/VTables/VTables.Tests.cs +++ b/tests/VTables/VTables.Tests.cs @@ -4,13 +4,10 @@ using VTables; public class FooDerived : Foo { - public override int vfoo + public override int vfoo() { - get - { - Console.WriteLine("Hello from FooDerived"); - return 10; - } + Console.WriteLine("Hello from FooDerived"); + return 10; } } @@ -21,8 +18,8 @@ public class VTablesTests public void TestFoo() { var foo = new Foo(); - Assert.That(foo.vfoo, Is.EqualTo(5)); - Assert.That(foo.Vbar, Is.EqualTo(3)); + Assert.That(foo.vfoo(), Is.EqualTo(5)); + Assert.That(foo.Vbar(), Is.EqualTo(3)); Assert.That(foo.CallFoo(), Is.EqualTo(7)); var foo2 = new FooDerived(); From f086dd9051a26be467bf2a2629bb0a572453eac3 Mon Sep 17 00:00:00 2001 From: Dimitar Dobrev Date: Thu, 3 Oct 2013 18:55:41 +0300 Subject: [PATCH 5/6] Commented newly created properties. Signed-off-by: Dimitar Dobrev --- .../Passes/GetterSetterToPropertyPass.cs | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/src/Generator/Passes/GetterSetterToPropertyPass.cs b/src/Generator/Passes/GetterSetterToPropertyPass.cs index 5bf2b77c..fc14ed78 100644 --- a/src/Generator/Passes/GetterSetterToPropertyPass.cs +++ b/src/Generator/Passes/GetterSetterToPropertyPass.cs @@ -151,7 +151,22 @@ namespace CppSharp.Passes { property.ExplicitInterfaceImpl = setter.ExplicitInterfaceImpl; } - // TODO: add comments + if (getter.Comment != null) + { + var comment = new RawComment(); + comment.Kind = getter.Comment.Kind; + comment.BriefText = getter.Comment.BriefText; + comment.Text = getter.Comment.Text; + comment.FullComment = new FullComment(); + comment.FullComment.Blocks.AddRange(getter.Comment.FullComment.Blocks); + if (setter != null && setter.Comment != null) + { + comment.BriefText += Environment.NewLine + setter.Comment.BriefText; + comment.Text += Environment.NewLine + setter.Comment.Text; + comment.FullComment.Blocks.AddRange(setter.Comment.FullComment.Blocks); + } + property.Comment = comment; + } type.Properties.Add(property); getter.IsGenerated = false; if (setter != null) @@ -179,7 +194,6 @@ namespace CppSharp.Passes return name; } - private void DistributeMethod(Method method) { if (GetFirstWord(method.Name) == "set" && method.Name.Length > 3 && From f348a80c32077328fefd6c1efab6b4dbae2388f0 Mon Sep 17 00:00:00 2001 From: Dimitar Dobrev Date: Fri, 4 Oct 2013 23:34:23 +0300 Subject: [PATCH 6/6] Moved the improved property pass to a new class. Added the list of verbs as a resource in premake. Signed-off-by: Dimitar Dobrev --- src/Generator/Driver.cs | 2 +- src/Generator/Generator.lua | 5 +- .../Generators/CSharp/CSharpTextTemplate.cs | 36 ++- .../GetterSetterToPropertyAdvancedPass.cs | 245 +++++++++++++++ .../Passes/GetterSetterToPropertyPass.cs | 279 ++++++------------ 5 files changed, 363 insertions(+), 204 deletions(-) create mode 100644 src/Generator/Passes/GetterSetterToPropertyAdvancedPass.cs diff --git a/src/Generator/Driver.cs b/src/Generator/Driver.cs index 6c790857..7fa742a8 100644 --- a/src/Generator/Driver.cs +++ b/src/Generator/Driver.cs @@ -159,7 +159,7 @@ namespace CppSharp TranslationUnitPasses.AddPass(new ParamTypeToInterfacePass()); } if (Options.GenerateProperties) - TranslationUnitPasses.AddPass(new GetterSetterToPropertyPass()); + TranslationUnitPasses.AddPass(new GetterSetterToPropertyAdvancedPass()); } public void ProcessCode() diff --git a/src/Generator/Generator.lua b/src/Generator/Generator.lua index bfe88b43..f8fcb194 100644 --- a/src/Generator/Generator.lua +++ b/src/Generator/Generator.lua @@ -4,7 +4,10 @@ project "CppSharp.Generator" language "C#" location "." - files { "**.cs", "**.bmp", "**.resx", "**.config" } + files { "**.cs", "**.bmp", "**.resx", "**.config", "**verbs.txt" } excludes { "Filter.cs" } links { "System", "System.Core", "CppSharp.AST", "CppSharp.Parser" } + + configuration '**verbs.txt' + buildaction "Embed" diff --git a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs index e7bd048c..a4033148 100644 --- a/src/Generator/Generators/CSharp/CSharpTextTemplate.cs +++ b/src/Generator/Generators/CSharp/CSharpTextTemplate.cs @@ -898,7 +898,7 @@ namespace CppSharp.Generators.CSharp PopBlock(NewLineKind.BeforeNextBlock); return; } - WriteLine(""); + NewLine(); WriteStartBraceIndent(); Method method = function as Method; if (method != null && method.IsOverride && method.IsSynthetized) @@ -918,7 +918,7 @@ namespace CppSharp.Generators.CSharp } else if (decl is Field) { - WriteLine(""); + NewLine(); WriteStartBraceIndent(); var field = decl as Field; @@ -944,7 +944,7 @@ namespace CppSharp.Generators.CSharp } else if (decl is Variable) { - WriteLine(""); + NewLine(); WriteStartBraceIndent(); var @var = decl as Variable; var libSymbol = GetDeclarationLibrarySymbol(@var); @@ -1264,18 +1264,7 @@ namespace CppSharp.Generators.CSharp } else { - var property = ((Class) method.Namespace).Properties.FirstOrDefault( - p => p.GetMethod == method); - if (property == null) - { - property = ((Class) method.Namespace).Properties.First( - p => p.SetMethod == method); - WriteLine("target.{0} = {1};", property.Name, string.Join(", ", marshals)); - } - else - { - WriteLine("target.{0};", property.Name); - } + InvokeProperty(method, marshals); } // TODO: Handle hidden structure return types. @@ -1306,6 +1295,23 @@ namespace CppSharp.Generators.CSharp } } + private void InvokeProperty(Declaration method, IEnumerable marshals) + { + var property = ((Class) method.Namespace).Properties.FirstOrDefault( + p => p.GetMethod == method); + if (property == null) + { + property = ((Class) method.Namespace).Properties.First( + p => p.SetMethod == method); + WriteLine("target.{0} = {1};", SafeIdentifier(property.Name), + string.Join(", ", marshals)); + } + else + { + WriteLine("target.{0};", SafeIdentifier(property.Name)); + } + } + private void GenerateVTableMethodDelegates(Class @class, Method method) { PushBlock(CSharpBlockKind.VTableDelegate); diff --git a/src/Generator/Passes/GetterSetterToPropertyAdvancedPass.cs b/src/Generator/Passes/GetterSetterToPropertyAdvancedPass.cs new file mode 100644 index 00000000..aa16af61 --- /dev/null +++ b/src/Generator/Passes/GetterSetterToPropertyAdvancedPass.cs @@ -0,0 +1,245 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text; +using CppSharp.AST; + +namespace CppSharp.Passes +{ + class GetterSetterToPropertyAdvancedPass : TranslationUnitPass + { + // collect all types of methods first to be able to match pairs and detect virtuals and overrides; + // (a property needs to) be virtual or an override if either of its constituent methods are such) + private readonly List setters = new List(); + private readonly List setMethods = new List(); + private readonly List nonSetters = new List(); + private readonly HashSet getters = new HashSet(); + private static readonly HashSet verbs = new HashSet(); + + static GetterSetterToPropertyAdvancedPass() + { + LoadVerbs(); + } + + private static void LoadVerbs() + { + using (var resourceStream = Assembly.GetExecutingAssembly() + .GetManifestResourceStream("CppSharp.Generator.Passes.verbs.txt")) + { + using (StreamReader streamReader = new StreamReader(resourceStream)) + while (!streamReader.EndOfStream) + verbs.Add(streamReader.ReadLine()); + } + } + + public GetterSetterToPropertyAdvancedPass() + { + Options.VisitClassFields = false; + Options.VisitClassProperties = false; + Options.VisitNamespaceEnums = false; + Options.VisitNamespaceTemplates = false; + Options.VisitNamespaceTypedefs = false; + Options.VisitNamespaceEvents = false; + Options.VisitNamespaceVariables = false; + Options.VisitFunctionParameters = false; + Options.VisitTemplateArguments = false; + } + + public override bool VisitTranslationUnit(TranslationUnit unit) + { + bool result = base.VisitTranslationUnit(unit); + GenerateProperties(); + return result; + } + + public override bool VisitMethodDecl(Method method) + { + if (!method.IsConstructor && !method.IsDestructor && !method.IsOperator && + !method.Ignore) + DistributeMethod(method); + return base.VisitMethodDecl(method); + } + + public void GenerateProperties() + { + GenerateProperties(setters, false); + GenerateProperties(setMethods, true); + + foreach (Method getter in + from getter in getters + where getter.IsGenerated && + ((Class) getter.Namespace).Methods.All(m => m == getter || m.Name != getter.Name) + select getter) + { + // Make it a read-only property + GenerateProperty(getter.Namespace, getter); + } + } + + private void GenerateProperties(IEnumerable settersToUse, bool readOnly) + { + foreach (var group in settersToUse.GroupBy(m => m.Namespace)) + { + foreach (var setter in group) + { + Class type = (Class) setter.Namespace; + StringBuilder nameBuilder = new StringBuilder(setter.Name.Substring(3)); + if (char.IsLower(setter.Name[0])) + nameBuilder[0] = char.ToLowerInvariant(nameBuilder[0]); + string afterSet = nameBuilder.ToString(); + foreach (var getter in nonSetters.Where(m => m.Namespace == type)) + { + string name = GetPropertyName(getter.Name); + if (string.Compare(name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 && + getter.ReturnType == setter.Parameters[0].QualifiedType && + !type.Methods.Any( + m => + m != getter && + string.Compare(name, m.Name, StringComparison.OrdinalIgnoreCase) == 0)) + { + GenerateProperty(getter.Namespace, getter, readOnly ? null : setter); + goto next; + } + } + Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = afterSet }); + if (!type.IsInterface && baseVirtualProperty != null) + { + bool isReadOnly = baseVirtualProperty.SetMethod == null; + GenerateProperty(setter.Namespace, baseVirtualProperty.GetMethod, + readOnly || isReadOnly ? null : setter); + } + next: + ; + } + } + foreach (Method nonSetter in nonSetters) + { + Class type = (Class) nonSetter.Namespace; + string name = GetPropertyName(nonSetter.Name); + Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = name }); + if (!type.IsInterface && baseVirtualProperty != null) + { + bool isReadOnly = baseVirtualProperty.SetMethod == null; + if (readOnly == isReadOnly) + { + GenerateProperty(nonSetter.Namespace, nonSetter, + readOnly ? null : baseVirtualProperty.SetMethod); + } + } + } + } + + private static void GenerateProperty(DeclarationContext context, Method getter, Method setter = null) + { + Class type = (Class) context; + if (type.Properties.All( + p => string.Compare(getter.Name, p.Name, StringComparison.OrdinalIgnoreCase) != 0 || + p.ExplicitInterfaceImpl != getter.ExplicitInterfaceImpl)) + { + Property property = new Property(); + property.Name = GetPropertyName(getter.Name); + property.Namespace = type; + property.QualifiedType = getter.ReturnType; + if (getter.IsOverride || (setter != null && setter.IsOverride)) + { + Property baseVirtualProperty = type.GetRootBaseProperty(property); + if (baseVirtualProperty.SetMethod == null) + setter = null; + foreach (Method method in type.Methods.Where(m => m.Name == property.Name && m.Parameters.Count > 0)) + method.Name = "get" + method.Name; + } + property.GetMethod = getter; + property.SetMethod = setter; + property.ExplicitInterfaceImpl = getter.ExplicitInterfaceImpl; + if (property.ExplicitInterfaceImpl == null && setter != null) + { + property.ExplicitInterfaceImpl = setter.ExplicitInterfaceImpl; + } + if (getter.Comment != null) + { + var comment = new RawComment(); + comment.Kind = getter.Comment.Kind; + comment.BriefText = getter.Comment.BriefText; + comment.Text = getter.Comment.Text; + comment.FullComment = new FullComment(); + comment.FullComment.Blocks.AddRange(getter.Comment.FullComment.Blocks); + if (setter != null && setter.Comment != null) + { + comment.BriefText += Environment.NewLine + setter.Comment.BriefText; + comment.Text += Environment.NewLine + setter.Comment.Text; + comment.FullComment.Blocks.AddRange(setter.Comment.FullComment.Blocks); + } + property.Comment = comment; + } + type.Properties.Add(property); + getter.IsGenerated = false; + if (setter != null) + setter.IsGenerated = false; + } + } + + private static string GetPropertyName(string name) + { + if (GetFirstWord(name) == "get") + { + if (char.IsLower(name[0])) + { + if (name.Length == 4) + { + return char.ToLowerInvariant( + name[3]).ToString(CultureInfo.InvariantCulture); + } + return char.ToLowerInvariant( + name[3]).ToString(CultureInfo.InvariantCulture) + + name.Substring(4); + } + return name.Substring(3); + } + return name; + } + + private void DistributeMethod(Method method) + { + if (GetFirstWord(method.Name) == "set" && method.Name.Length > 3 && + method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void)) + { + if (method.Parameters.Count == 1) + setters.Add(method); + else + setMethods.Add(method); + } + else + { + if (IsGetter(method)) + getters.Add(method); + if (method.Parameters.Count == 0) + nonSetters.Add(method); + } + } + + private bool IsGetter(Method method) + { + if (method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void) || + method.Parameters.Count > 0 || method.IsDestructor) + return false; + var result = GetFirstWord(method.Name); + return (result.Length < method.Name.Length && + (result == "get" || result == "is" || result == "has")) || + (result != "to" && result != "new" && !verbs.Contains(result)); + } + + private static string GetFirstWord(string name) + { + List firstVerb = new List + { + char.ToLowerInvariant(name[0]) + }; + firstVerb.AddRange(name.Skip(1).TakeWhile( + c => char.IsLower(c) || !char.IsLetterOrDigit(c))); + return new string(firstVerb.ToArray()); + } + } +} diff --git a/src/Generator/Passes/GetterSetterToPropertyPass.cs b/src/Generator/Passes/GetterSetterToPropertyPass.cs index fc14ed78..3ad2ebbd 100644 --- a/src/Generator/Passes/GetterSetterToPropertyPass.cs +++ b/src/Generator/Passes/GetterSetterToPropertyPass.cs @@ -1,10 +1,5 @@ using System; -using System.Collections.Generic; -using System.Globalization; -using System.IO; using System.Linq; -using System.Reflection; -using System.Text; using CppSharp.AST; namespace CppSharp.Passes @@ -15,12 +10,6 @@ namespace CppSharp.Passes /// public class GetterSetterToPropertyPass : TranslationUnitPass { - private readonly List setters = new List(); - private readonly List setMethods = new List(); - private readonly List nonSetters = new List(); - private readonly HashSet getters = new HashSet(); - private readonly HashSet verbs = new HashSet(); - public GetterSetterToPropertyPass() { Options.VisitClassFields = false; @@ -32,207 +21,123 @@ namespace CppSharp.Passes Options.VisitNamespaceVariables = false; Options.VisitFunctionParameters = false; Options.VisitTemplateArguments = false; - using (var resourceStream = Assembly.GetExecutingAssembly() - .GetManifestResourceStream("CppSharp.Generator.Passes.verbs.txt")) - { - using (StreamReader streamReader = new StreamReader(resourceStream)) - while (!streamReader.EndOfStream) - verbs.Add(streamReader.ReadLine()); - } } - public override bool VisitTranslationUnit(TranslationUnit unit) + static bool IsSetter(Function method) { - bool result = base.VisitTranslationUnit(unit); - GenerateProperties(); - return result; - } + var isRetVoid = method.ReturnType.Type.IsPrimitiveType( + PrimitiveType.Void); - public override bool VisitMethodDecl(Method method) - { - if (!method.IsConstructor && !method.IsDestructor && !method.IsOperator && - !method.Ignore) - DistributeMethod(method); - return base.VisitMethodDecl(method); - } + var isSetter = method.OriginalName.StartsWith("set", + StringComparison.InvariantCultureIgnoreCase); - public void GenerateProperties() - { - GenerateProperties(setters, false); - GenerateProperties(setMethods, true); - - foreach (Method getter in - from getter in getters - where getter.IsGenerated && - ((Class) getter.Namespace).Methods.All(m => m == getter || m.Name != getter.Name) - select getter) - { - // Make it a read-only property - GenerateProperty(getter.Namespace, getter); - } + return isRetVoid && isSetter && method.Parameters.Count == 1; } - private void GenerateProperties(IEnumerable settersToUse, bool readOnly) + static bool IsGetter(Function method) { - foreach (var group in settersToUse.GroupBy(m => m.Namespace)) - { - foreach (var setter in group) - { - Class type = (Class) setter.Namespace; - StringBuilder nameBuilder = new StringBuilder(setter.Name.Substring(3)); - if (char.IsLower(setter.Name[0])) - nameBuilder[0] = char.ToLowerInvariant(nameBuilder[0]); - string afterSet = nameBuilder.ToString(); - foreach (var getter in nonSetters.Where(m => m.Namespace == type)) - { - string name = GetPropertyName(getter.Name); - if (string.Compare(name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 && - getter.ReturnType == setter.Parameters[0].QualifiedType && - !type.Methods.Any( - m => - m != getter && - string.Compare(name, m.Name, StringComparison.OrdinalIgnoreCase) == 0)) - { - GenerateProperty(getter.Namespace, getter, readOnly ? null : setter); - goto next; - } - } - Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = afterSet }); - if (!type.IsInterface && baseVirtualProperty != null) - { - bool isReadOnly = baseVirtualProperty.SetMethod == null; - GenerateProperty(setter.Namespace, baseVirtualProperty.GetMethod, - readOnly || isReadOnly ? null : setter); - } - next: - ; - } - } - foreach (Method nonSetter in nonSetters) - { - Class type = (Class) nonSetter.Namespace; - string name = GetPropertyName(nonSetter.Name); - Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = name }); - if (!type.IsInterface && baseVirtualProperty != null) - { - bool isReadOnly = baseVirtualProperty.SetMethod == null; - if (readOnly == isReadOnly) - { - GenerateProperty(nonSetter.Namespace, nonSetter, - readOnly ? null : baseVirtualProperty.SetMethod); - } - } - } - } + var isRetVoid = method.ReturnType.Type.IsPrimitiveType( + PrimitiveType.Void); - private static void GenerateProperty(DeclarationContext context, Method getter, Method setter = null) - { - Class type = (Class) context; - if (type.Properties.All( - p => string.Compare(getter.Name, p.Name, StringComparison.OrdinalIgnoreCase) != 0 || - p.ExplicitInterfaceImpl != getter.ExplicitInterfaceImpl)) - { - Property property = new Property(); - property.Name = GetPropertyName(getter.Name); - property.Namespace = type; - property.QualifiedType = getter.ReturnType; - if (getter.IsOverride || (setter != null && setter.IsOverride)) - { - Property baseVirtualProperty = type.GetRootBaseProperty(property); - if (baseVirtualProperty.SetMethod == null) - setter = null; - foreach (Method method in type.Methods.Where(m => m.Name == property.Name && m.Parameters.Count > 0)) - method.Name = "get" + method.Name; - } - property.GetMethod = getter; - property.SetMethod = setter; - property.ExplicitInterfaceImpl = getter.ExplicitInterfaceImpl; - if (property.ExplicitInterfaceImpl == null && setter != null) - { - property.ExplicitInterfaceImpl = setter.ExplicitInterfaceImpl; - } - if (getter.Comment != null) - { - var comment = new RawComment(); - comment.Kind = getter.Comment.Kind; - comment.BriefText = getter.Comment.BriefText; - comment.Text = getter.Comment.Text; - comment.FullComment = new FullComment(); - comment.FullComment.Blocks.AddRange(getter.Comment.FullComment.Blocks); - if (setter != null && setter.Comment != null) - { - comment.BriefText += Environment.NewLine + setter.Comment.BriefText; - comment.Text += Environment.NewLine + setter.Comment.Text; - comment.FullComment.Blocks.AddRange(setter.Comment.FullComment.Blocks); - } - property.Comment = comment; - } - type.Properties.Add(property); - getter.IsGenerated = false; - if (setter != null) - setter.IsGenerated = false; - } + var isGetter = method.OriginalName.StartsWith("get", + StringComparison.InvariantCultureIgnoreCase); + + return !isRetVoid && isGetter && method.Parameters.Count == 0; } - private static string GetPropertyName(string name) + Property GetOrCreateProperty(Class @class, string name, QualifiedType type) { - if (GetFirstWord(name) == "get") + var prop = @class.Properties.FirstOrDefault(property => property.Name == name + && property.QualifiedType.Equals(type)); + + var prop2 = @class.Properties.FirstOrDefault(property => property.Name == name); + + if (prop == null && prop2 != null) + Driver.Diagnostics.EmitWarning(DiagnosticId.PropertySynthetized, + "Property {0}::{1} already exist with type {2}", @class.Name, name, type.Type.ToString()); + + if (prop != null) + return prop; + + prop = new Property { - if (char.IsLower(name[0])) - { - if (name.Length == 4) - { - return char.ToLowerInvariant( - name[3]).ToString(CultureInfo.InvariantCulture); - } - return char.ToLowerInvariant( - name[3]).ToString(CultureInfo.InvariantCulture) + - name.Substring(4); - } - return name.Substring(3); - } - return name; + Name = name, + Namespace = @class, + QualifiedType = type + }; + + @class.Properties.Add(prop); + return prop; } - private void DistributeMethod(Method method) + public override bool VisitMethodDecl(Method method) { - if (GetFirstWord(method.Name) == "set" && method.Name.Length > 3 && - method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void)) + if (AlreadyVisited(method)) + return false; + + if (ASTUtils.CheckIgnoreMethod(method)) + return false; + + var @class = method.Namespace as Class; + + if (@class == null || @class.IsIncomplete) + return false; + + if (IsGetter(method)) { - if (method.Parameters.Count == 1) - setters.Add(method); - else - setMethods.Add(method); + var name = method.Name.Substring("get".Length); + var prop = GetOrCreateProperty(@class, name, method.ReturnType); + prop.GetMethod = method; + prop.Access = method.Access; + + // Do not generate the original method now that we know it is a getter. + method.IsGenerated = false; + + Driver.Diagnostics.EmitMessage(DiagnosticId.PropertySynthetized, + "Getter created: {0}::{1}", @class.Name, name); + + return false; } - else + + if (IsSetter(method) && IsValidSetter(method)) { - if (IsGetter(method)) - getters.Add(method); - if (method.Parameters.Count == 0) - nonSetters.Add(method); + var name = method.Name.Substring("set".Length); + + var type = method.Parameters[0].QualifiedType; + var prop = GetOrCreateProperty(@class, name, type); + prop.SetMethod = method; + prop.Access = method.Access; + + // Ignore the original method now that we know it is a setter. + method.IsGenerated = false; + + Driver.Diagnostics.EmitMessage(DiagnosticId.PropertySynthetized, + "Setter created: {0}::{1}", @class.Name, name); + + return false; } + + return false; } - private bool IsGetter(Method method) + // Check if a matching getter exist or no other setter exists. + private bool IsValidSetter(Method method) { - if (method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void) || - method.Parameters.Count > 0 || method.IsDestructor) + var @class = method.Namespace as Class; + var name = method.Name.Substring("set".Length); + + if (method.Parameters.Count == 0) return false; - var result = GetFirstWord(method.Name); - return (result.Length < method.Name.Length && - (result == "get" || result == "is" || result == "has")) || - (result != "to" && result != "new" && !verbs.Contains(result)); - } - private static string GetFirstWord(string name) - { - List firstVerb = new List - { - char.ToLowerInvariant(name[0]) - }; - firstVerb.AddRange(name.Skip(1).TakeWhile( - c => char.IsLower(c) || !char.IsLetterOrDigit(c))); - return new string(firstVerb.ToArray()); + var type = method.Parameters[0].Type; + + var getter = @class.Methods.FirstOrDefault(m => m.Name == "Get" + name && m.Type.Equals(type)); + + var otherSetter = @class.Methods.FirstOrDefault(m => m.Name == method.Name + && m.Parameters.Count == 1 + && !m.Parameters[0].Type.Equals(type)); + + return getter != null || otherSetter == null; } } }