/// <summary>
/// Initializes a new instance of the <see cref="TerminalType"/> class.
/// </summary>
/// <param name="type">The <see cref="Type"/> of the <see cref="Terminal"/> described by this <see cref="TerminalType"/>.</param>
public TerminalType(Type type)
: base(LanguageElementTypes.Terminal)
{
if (!type.IsSubclassOf(typeof(Terminal)))
{
throw new ArgumentException("Type must be a subclass of Terminal.", "type");
}
m_fullName = type.AssemblyQualifiedName;
m_name = GetName(type);
m_constructor = delegate() { return (Terminal)Activator.CreateInstance(type); };
object[] attributes = type.GetCustomAttributes(typeof(TerminalAttribute), false);
foreach (object attribute in attributes)
{
TerminalAttribute terminalAttribute = (TerminalAttribute)attribute;
if (terminalAttribute.IsStop)
{
m_isStop = true;
}
if (terminalAttribute.Ignore)
{
m_ignore = true;
}
m_pattern = terminalAttribute.Pattern;
}
}
/// <summary>
/// Creates a <c>Parameter</c> using the provided constructor
/// and the XML annotation. The parameter produced contains all
/// information related to the constructor parameter. It knows the
/// name of the XML entity, as well as the type.
/// </summary>
/// <param name="method">
/// this is the constructor the parameter exists in
/// </param>
/// <param name="label">
/// represents the XML annotation for the contact
/// </param>
/// <returns>
/// returns the parameter instantiated for the field
/// </returns>
public Parameter GetInstance(Constructor method, Annotation label, int index) {
Constructor factory = GetConstructor(label);
if(!factory.isAccessible()) {
factory.setAccessible(true);
}
return (Parameter)factory.newInstance(method, label, index);
}
public JSBuiltinFunctionImp(mdr.DFuncImpInstance.JittedMethod m, Constructor c)
: base(null, null) //base(m.Method.Name, null, null)
{
Name = m.Method.Name;
_method = m;
_construct = c;
}
/// <summary>
/// Initializes a new instance of the <see cref="TerminalType"/> class.
/// </summary>
/// <param name="type">The <see cref="Type"/> of the <see cref="Terminal"/> described by this <see cref="TerminalType"/>.</param>
public TerminalType(Type type)
: base(LanguageElementTypes.Terminal)
{
if (!type.IsSubclassOf(typeof(Terminal)))
{
throw new ArgumentException("Type must be a subclass of Terminal.", "type");
}
_fullName = type.AssemblyQualifiedName;
_name = GetName(type);
_constructor = () => (Terminal) Activator.CreateInstance(type);
var attributes = type.GetCustomAttributes(typeof(TerminalAttribute), false);
foreach (var terminalAttribute in attributes.Cast<TerminalAttribute>())
{
if (terminalAttribute.IsStop)
{
IsStop = true;
}
if (terminalAttribute.Ignore)
{
Ignore = true;
}
Pattern = terminalAttribute.Pattern;
}
}
private static InjectionPlan NewConstructor(string fullName, List<InjectionPlan> plans)
{
Constructor cconstr = new Constructor();
foreach (InjectionPlan p in plans)
{
cconstr.args.Add(p);
}
InjectionPlan plan = new InjectionPlan();
plan.name = fullName;
plan.constructor = cconstr;
return plan;
}
public void Run()
{
Dictionary<string, string> cfg = new Dictionary<string, string>() {
{ "AUTO_CONFIG", "true" },
{ "MODEL", "true" } };
using (Context ctx = new Context(cfg))
{
Constructor c_leaf = ctx.MkConstructor("leaf", "is_leaf", new string[] { "val" }, new Sort[] { ctx.IntSort });
Constructor c_node = ctx.MkConstructor("node", "is_node", new string[] { "left", "right" }, new Sort[] { null, null }, new uint[] { 1, 1 });
Constructor[] constr_1 = new Constructor[] { c_leaf, c_node };
Constructor c_nil = ctx.MkConstructor("nil", "is_nil");
Constructor c_cons = ctx.MkConstructor("cons", "is_cons", new string[] { "car", "cdr" }, new Sort[] { null, null }, new uint[] { 0, 1 });
Constructor[] constr_2 = new Constructor[] { c_nil, c_cons };
DatatypeSort[] ts = ctx.MkDatatypeSorts(new string[] { "Tree", "TreeList" },
new Constructor[][] { constr_1, constr_2 });
DatatypeSort Tree = ts[0];
DatatypeSort TreeList = ts[1];
FuncDecl leaf = Tree.Constructors[0];
FuncDecl node = Tree.Constructors[1];
FuncDecl val = Tree.Accessors[0][0];
FuncDecl nil = TreeList.Constructors[0];
FuncDecl cons = TreeList.Constructors[1];
Expr t1 = leaf[ctx.MkInt(10)];
Expr tl1 = cons[t1, nil.Apply()];
Expr t2 = node[tl1, nil.Apply()];
Console.WriteLine(t2);
Console.WriteLine(val.Apply(t1).Simplify());
t1 = ctx.MkConst("t1", TreeList);
t2 = ctx.MkConst("t2", TreeList);
Expr t3 = ctx.MkConst("t3", TreeList);
Solver s = ctx.MkSolver();
s.Assert(ctx.MkDistinct(t1, t2, t3));
Console.WriteLine(s.Check());
Console.WriteLine(s.Model);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NonterminalType"/> class.
/// </summary>
/// <param name="type">The <see cref="Type"/> of the <see cref="Nonterminal"/> described by this <see cref="NonterminalType"/>.</param>
public NonterminalType(Type type)
: base(LanguageElementTypes.Nonterminal)
{
if (!type.IsSubclassOf(typeof(Nonterminal)))
{
throw new ArgumentException("Type must be a subclass of Nonterminal.", "type");
}
_fullName = type.AssemblyQualifiedName;
_name = GetName(type);
_constructor = () => (Nonterminal) Activator.CreateInstance(type);
var attributes = type.GetCustomAttributes(typeof(NonterminalAttribute), false);
foreach (var nonterminalAttribute in attributes.Cast<NonterminalAttribute>().Where(nonterminalAttribute => nonterminalAttribute.IsStart))
{
_isStart = true;
}
}
protected PoolBase(object reference, Type type, Constructor constructor, Destructor destructor, int startSize, bool initialize)
{
PoolUtility.InitializeJanitor();
this.reference = reference;
this.constructor = constructor ?? Construct;
this.destructor = destructor ?? Destroy;
this.startSize = startSize;
Type = type;
isPoolable = reference is IPoolable;
hashedInstances = new HashSet<object>();
if (ApplicationUtility.IsMultiThreaded)
updater = new AsyncPoolUpdater();
else
updater = new SyncPoolUpdater();
if (initialize)
Initialize();
}
/// <summary>
/// This is used to create a <c>Parameter</c> object which is
/// used to represent a parameter to a constructor. Each parameter
/// contains an annotation an the index it appears in.
/// </summary>
/// <param name="factory">
/// this is the constructor the parameter is in
/// </param>
/// <param name="label">
/// this is the annotation used for the parameter
/// </param>
/// <param name="ordinal">
/// this is the position the parameter appears at
/// </param>
/// <returns>
/// this returns the parameter for the constructor
/// </returns>
public Parameter Create(Constructor factory, Annotation label, int ordinal) {
Parameter value = ParameterFactory.getInstance(factory, label, ordinal);
String name = value.getName();
if(index.containsKey(name)) {
Validate(value, name);
}
return value;
}
public static bool CanBeCreated(this Type type)
{
return(type.IsConcrete() && Constructor.HasConstructors(type));
}
/// <summary>
/// This is used to build the <c>Builder</c> object that is
/// to be used to instantiate the object. The builder contains
/// the constructor at the parameters in the declaration order.
/// </summary>
/// <param name="factory">
/// this is the constructor that is to be scanned
/// </param>
/// <param name="map">
/// this is the parameter map that contains parameters
/// </param>
public void Build(Constructor factory, Index map) {
Builder builder = new Builder(factory, map);
if(builder.isDefault()) {
primary = builder;
}
list.add(builder);
}
void MethodDecl(MemberModifiers mmod, bool allowConstructor, bool isWithinAbstractModule, out Method/*!*/ m)
{
Contract.Ensures(Contract.ValueAtReturn(out m) !=null);
IToken/*!*/ id = Token.NoToken;
bool hasName = false; IToken keywordToken;
Attributes attrs = null;
List<TypeParameter/*!*/>/*!*/ typeArgs = new List<TypeParameter/*!*/>();
List<Formal/*!*/> ins = new List<Formal/*!*/>();
List<Formal/*!*/> outs = new List<Formal/*!*/>();
List<MaybeFreeExpression/*!*/> req = new List<MaybeFreeExpression/*!*/>();
List<FrameExpression/*!*/> mod = new List<FrameExpression/*!*/>();
List<MaybeFreeExpression/*!*/> ens = new List<MaybeFreeExpression/*!*/>();
List<Expression/*!*/> dec = new List<Expression/*!*/>();
Attributes decAttrs = null;
Attributes modAttrs = null;
BlockStmt body = null;
bool isLemma = false;
bool isConstructor = false;
bool isIndLemma = false;
bool isCoLemma = false;
IToken signatureEllipsis = null;
IToken bodyStart = Token.NoToken;
IToken bodyEnd = Token.NoToken;
while (!(StartOf(10))) {SynErr(158); Get();}
switch (la.kind) {
case 84: {
Get();
break;
}
case 41: {
Get();
isLemma = true;
break;
}
case 85: {
Get();
isCoLemma = true;
break;
}
case 86: {
Get();
isCoLemma = true;
errors.Warning(t, "the 'comethod' keyword has been deprecated; it has been renamed to 'colemma'");
break;
}
case 40: {
Get();
Expect(41);
isIndLemma = true;
break;
}
case 87: {
Get();
if (allowConstructor) {
isConstructor = true;
} else {
SemErr(t, "constructors are allowed only in classes");
}
break;
}
default: SynErr(159); break;
}
keywordToken = t;
if (isLemma) {
if (mmod.IsGhost) {
SemErr(t, "lemmas cannot be declared 'ghost' (they are automatically 'ghost')");
}
} else if (isConstructor) {
if (mmod.IsGhost) {
SemErr(t, "constructors cannot be declared 'ghost'");
}
if (mmod.IsStatic) {
SemErr(t, "constructors cannot be declared 'static'");
}
} else if (isIndLemma) {
if (mmod.IsGhost) {
SemErr(t, "inductive lemmas cannot be declared 'ghost' (they are automatically 'ghost')");
}
} else if (isCoLemma) {
if (mmod.IsGhost) {
SemErr(t, "colemmas cannot be declared 'ghost' (they are automatically 'ghost')");
}
}
while (la.kind == 46) {
Attribute(ref attrs);
}
if (la.kind == 1) {
NoUSIdent(out id);
hasName = true;
}
if (!hasName) {
id = keywordToken;
if (!isConstructor) {
SemErr(la, "a method must be given a name (expecting identifier)");
}
}
if (la.kind == 50 || la.kind == 52) {
if (la.kind == 52) {
GenericParameters(typeArgs);
}
Formals(true, !mmod.IsGhost, ins);
if (la.kind == 83) {
Get();
if (isConstructor) { SemErr(t, "constructors cannot have out-parameters"); }
Formals(false, !mmod.IsGhost, outs);
}
} else if (la.kind == 59) {
Get();
signatureEllipsis = t;
} else SynErr(160);
while (StartOf(11)) {
MethodSpec(req, mod, ens, dec, ref decAttrs, ref modAttrs);
}
if (la.kind == 46) {
BlockStmt(out body, out bodyStart, out bodyEnd);
}
if (!isWithinAbstractModule && DafnyOptions.O.DisallowSoundnessCheating && body == null && ens.Count > 0 && !Attributes.Contains(attrs, "axiom") && !Attributes.Contains(attrs, "imported") && !Attributes.Contains(attrs, "decl") && theVerifyThisFile) {
SemErr(t, "a method with an ensures clause must have a body, unless given the :axiom attribute");
}
IToken tok = theVerifyThisFile ? id : new IncludeToken(id);
if (isConstructor) {
m = new Constructor(tok, hasName ? id.val : "_ctor", typeArgs, ins,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
} else if (isIndLemma) {
m = new InductiveLemma(tok, id.val, mmod.IsStatic, typeArgs, ins, outs,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
} else if (isCoLemma) {
m = new CoLemma(tok, id.val, mmod.IsStatic, typeArgs, ins, outs,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
} else if (isLemma) {
m = new Lemma(tok, id.val, mmod.IsStatic, typeArgs, ins, outs,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
} else {
m = new Method(tok, id.val, mmod.IsStatic, mmod.IsGhost, typeArgs, ins, outs,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
}
m.BodyStartTok = bodyStart;
m.BodyEndTok = bodyEnd;
}
public static void SetConstructor(Constructor c)
{
s_constructor = c;
}
internal static void constructor_location(this TextWriter trapFile, Constructor constructor, Location location)
{
trapFile.WriteTuple("constructor_location", constructor, location);
}
public virtual void Visit(Constructor c)
{
}
private void EnumeratorConstructorMustCallReset()
{
Constructor constructor = _enumerator.ClassDefinition.GetConstructor(0);
constructor.Body.Add(CreateMethodInvocation(_enumerator.ClassDefinition, "Reset"));
}
override public void OnConstructor(Constructor method)
{
_current = method;
Visit(_current.Body);
}
private SourceCode GenerateApiEndpointClasses(List<VimeoApiEndpointInfo> apiList)
{
SourceCode sc = new SourceCode();
sc.UsingNamespaces.Add("System");
Namespace ns = new Namespace("HigLabo.Net.Vimeo.Api_3_2");
sc.Namespaces.Add(ns);
Class apiEndpointsClass = new Class(AccessModifier.Public, "ApiEndpoints");
apiEndpointsClass.Modifier.Partial = true;
ns.Classes.Add(apiEndpointsClass);
foreach (var apiName1 in apiList.Select(el => el.Name1).Distinct())
{
apiEndpointsClass.Fields.Add(new Field("Api_" + apiName1, "_" + apiName1));
var p = new Property("Api_" + apiName1, apiName1);
p.Get.Body.Add(SourceCodeLanguage.CSharp, "if (_{0} == null) _{0} = new Api_{0}(this);", apiName1);
p.Get.Body.Add(SourceCodeLanguage.CSharp, "return _{0};", apiName1);
p.Set = null;
apiEndpointsClass.Properties.Add(p);
Class apiClass = new Class(AccessModifier.Public, "Api_" + apiName1);
apiClass.Modifier.Partial = true;
apiEndpointsClass.Classes.Add(apiClass);
apiClass.Fields.Add(new Field("ApiEndpoints", "_ApiEndpoints"));
var ct = new Constructor(AccessModifier.Public, "Api_" + apiName1);
ct.Parameters.Add(new MethodParameter("ApiEndpoints", "apiEndpoints"));
ct.Body.Add(SourceCodeLanguage.CSharp, "_ApiEndpoints = apiEndpoints;");
apiClass.Constructors.Add(ct);
foreach (var apiName2 in apiList.Where(el => el.Name1 == apiName1).Select(el => el.Name2))
{
var apiInfo = apiList.Find(el => el.Name1 == apiName1 && el.Name2 == apiName2);
if (apiInfo.HasResult == false) { continue; }
apiClass.Methods.Add(this.CreateApiMethod(apiInfo));
if (apiInfo.CommandParameters.Count > 0)
{
apiClass.Methods.AddRange(this.CreateApiMethod1(apiInfo));
}
}
}
return sc;
}
/// <summary>
/// Registers a new item constructor, keyed by a type key. ...
/// </summary>
public object registerType(JsString type, Constructor cls){return null;}
void MethodDecl(DeclModifierData dmod, bool allowConstructor, bool isWithinAbstractModule, out Method/*!*/ m) {
Contract.Ensures(Contract.ValueAtReturn(out m) !=null);
IToken/*!*/ id = Token.NoToken;
bool hasName = false; IToken keywordToken;
Attributes attrs = null;
List<TypeParameter/*!*/>/*!*/ typeArgs = new List<TypeParameter/*!*/>();
List<Formal/*!*/> ins = new List<Formal/*!*/>();
List<Formal/*!*/> outs = new List<Formal/*!*/>();
List<MaybeFreeExpression/*!*/> req = new List<MaybeFreeExpression/*!*/>();
List<FrameExpression/*!*/> mod = new List<FrameExpression/*!*/>();
List<MaybeFreeExpression/*!*/> ens = new List<MaybeFreeExpression/*!*/>();
List<Expression/*!*/> dec = new List<Expression/*!*/>();
Attributes decAttrs = null;
Attributes modAttrs = null;
BlockStmt body = null;
bool isLemma = false;
bool isConstructor = false;
bool isIndLemma = false;
bool isCoLemma = false;
bool isTactic = false;
IToken signatureEllipsis = null;
IToken bodyStart = Token.NoToken;
IToken bodyEnd = Token.NoToken;
AllowedDeclModifiers allowed = AllowedDeclModifiers.None;
string caption = "";
while (!(StartOf(12))) {SynErr(172); Get();}
switch (la.kind) {
case 89: {
Get();
caption = "Methods";
allowed = AllowedDeclModifiers.Ghost | AllowedDeclModifiers.Static
| AllowedDeclModifiers.Extern;
break;
}
case 60: {
Get();
isTactic = true; caption = "Tactics";
allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static
| AllowedDeclModifiers.Protected;
break;
}
case 41: {
Get();
isLemma = true; caption = "Lemmas";
allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static
| AllowedDeclModifiers.Protected;
break;
}
case 90: {
Get();
isCoLemma = true; caption = "Colemmas";
allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static
| AllowedDeclModifiers.Protected;
break;
}
case 91: {
Get();
isCoLemma = true; caption = "Comethods";
allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static
| AllowedDeclModifiers.Protected;
errors.Warning(t, "the 'comethod' keyword has been deprecated; it has been renamed to 'colemma'");
break;
}
case 40: {
Get();
Expect(41);
isIndLemma = true; caption = "Inductive lemmas";
allowed = AllowedDeclModifiers.AlreadyGhost | AllowedDeclModifiers.Static;
break;
}
case 92: {
Get();
if (allowConstructor) {
isConstructor = true;
} else {
SemErr(t, "constructors are allowed only in classes");
}
caption = "Constructors";
allowed = AllowedDeclModifiers.None;
break;
}
default: SynErr(173); break;
}
keywordToken = t;
CheckDeclModifiers(dmod, caption, allowed);
while (la.kind == 46) {
Attribute(ref attrs);
}
if (la.kind == 1) {
NoUSIdent(out id);
hasName = true;
}
if (!hasName) {
id = keywordToken;
if (!isConstructor) {
SemErr(la, "a method must be given a name (expecting identifier)");
}
}
EncodeExternAsAttribute(dmod, ref attrs, id, /* needAxiom */ true);
if (la.kind == 50 || la.kind == 52) {
if (la.kind == 52) {
GenericParameters(typeArgs);
}
Formals(true, !dmod.IsGhost, ins);
if (la.kind == 88) {
Get();
if (isConstructor) { SemErr(t, "constructors cannot have out-parameters"); }
Formals(false, !dmod.IsGhost, outs);
}
} else if (la.kind == 59) {
Get();
signatureEllipsis = t;
} else SynErr(174);
while (StartOf(13)) {
MethodSpec(req, mod, ens, dec, ref decAttrs, ref modAttrs);
}
if (la.kind == 46) {
BlockStmt(out body, out bodyStart, out bodyEnd);
}
if (!isWithinAbstractModule && DafnyOptions.O.DisallowSoundnessCheating && body == null && ens.Count > 0 && !Attributes.Contains(attrs, "axiom") && !Attributes.Contains(attrs, "imported") && !Attributes.Contains(attrs, "decl") && theVerifyThisFile) {
SemErr(t, "a method with an ensures clause must have a body, unless given the :axiom attribute");
}
IToken tok = theVerifyThisFile ? id : new IncludeToken(id);
if (isConstructor) {
m = new Constructor(tok, hasName ? id.val : "_ctor", typeArgs, ins,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
} else if (isIndLemma) {
m = new InductiveLemma(tok, id.val, dmod.IsStatic, typeArgs, ins, outs,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
} else if (isCoLemma) {
m = new CoLemma(tok, id.val, dmod.IsStatic, typeArgs, ins, outs,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
} else if (isLemma) {
m = new Lemma(tok, id.val, dmod.IsStatic, typeArgs, ins, outs,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
} else if(isTactic) {
m = new Tactic(tok, id.val, dmod.IsStatic, typeArgs, ins, outs,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
} else {
m = new Method(tok, id.val, dmod.IsStatic, dmod.IsGhost, typeArgs, ins, outs,
req, new Specification<FrameExpression>(mod, modAttrs), ens, new Specification<Expression>(dec, decAttrs), body, attrs, signatureEllipsis);
}
m.BodyStartTok = bodyStart;
m.BodyEndTok = bodyEnd;
}
/// <summary>
/// Gets the example expected summary text for a constructor, based on the type of the constructor.
/// </summary>
/// <param name="constructor">The constructor.</param>
/// <param name="type">The type of the element containing the constructor.</param>
/// <returns>Returns the example summary text.</returns>
private static string GetExampleSummaryTextForConstructorType(Constructor constructor, string type)
{
Param.AssertNotNull(constructor, "constructor");
Param.AssertValidString(type, "type");
if (constructor.ContainsModifier(TokenType.Static))
{
return string.Format(
CultureInfo.InvariantCulture,
CachedCodeStrings.ExampleHeaderSummaryForStaticConstructor,
type);
}
else if (constructor.AccessModifierType == AccessModifierType.Private &&
(constructor.ParameterList == null || constructor.ParameterList.Count == 0))
{
return string.Format(
CultureInfo.InvariantCulture,
CachedCodeStrings.ExampleHeaderSummaryForPrivateInstanceConstructor,
type);
}
else
{
return string.Format(
CultureInfo.InvariantCulture,
CachedCodeStrings.ExampleHeaderSummaryForInstanceConstructor,
type);
}
}
/// <summary>
/// Checks a constructor to ensure that the summary text matches the expected text.
/// </summary>
/// <param name="constructor">The constructor to check.</param>
/// <param name="formattedDocs">The formatted header documentation.</param>
private void CheckConstructorSummaryText(Constructor constructor, XmlDocument formattedDocs)
{
Param.AssertNotNull(constructor, "constructor");
Param.AssertNotNull(formattedDocs, "formattedDocs");
XmlNode node = formattedDocs.SelectSingleNode("root/summary");
if (node != null)
{
string summaryText = node.InnerXml.Trim();
string type = constructor.Parent is Struct ? "struct" : "class";
ClassBase parent = constructor.Parent as ClassBase;
if (parent != null)
{
// Get a regex to match the type name.
string typeRegex = BuildCrefValidationStringForType(parent);
// Get the full expected summary text.
string expectedRegex = GetExpectedSummaryTextForConstructorType(constructor, type, typeRegex);
if (!Regex.IsMatch(summaryText, expectedRegex, RegexOptions.ExplicitCapture))
{
this.AddViolation(
constructor,
Rules.ConstructorSummaryDocumentationMustBeginWithStandardText,
GetExampleSummaryTextForConstructorType(constructor, type));
}
}
}
}
protected override bool DoDefineMembers()
{
var builtin_types = Compiler.BuiltinTypes;
var ctor_parameters = ParametersCompiled.CreateFullyResolved(
new [] {
new Parameter(new TypeExpression(builtin_types.Object, Location), "object", Parameter.Modifier.NONE, null, Location),
new Parameter(new TypeExpression(builtin_types.IntPtr, Location), "method", Parameter.Modifier.NONE, null, Location)
},
new [] {
builtin_types.Object,
builtin_types.IntPtr
}
);
Constructor = new Constructor(this, Constructor.ConstructorName,
Modifiers.PUBLIC, null, ctor_parameters, Location);
Constructor.Define();
//
// Here the various methods like Invoke, BeginInvoke etc are defined
//
// First, call the `out of band' special method for
// defining recursively any types we need:
//
var p = parameters;
if (!p.Resolve(this))
{
return(false);
}
//
// Invoke method
//
// Check accessibility
foreach (var partype in p.Types)
{
if (!IsAccessibleAs(partype))
{
Report.SymbolRelatedToPreviousError(partype);
Report.Error(59, Location,
"Inconsistent accessibility: parameter type `{0}' is less accessible than delegate `{1}'",
partype.GetSignatureForError(), GetSignatureForError());
}
}
var ret_type = ReturnType.ResolveAsType(this);
if (ret_type == null)
{
return(false);
}
//
// We don't have to check any others because they are all
// guaranteed to be accessible - they are standard types.
//
if (!IsAccessibleAs(ret_type))
{
Report.SymbolRelatedToPreviousError(ret_type);
Report.Error(58, Location,
"Inconsistent accessibility: return type `" +
ret_type.GetSignatureForError() + "' is less " +
"accessible than delegate `" + GetSignatureForError() + "'");
return(false);
}
CheckProtectedModifier();
if (Compiler.Settings.StdLib && ret_type.IsSpecialRuntimeType)
{
Method.Error1599(Location, ret_type, Report);
return(false);
}
VarianceDecl.CheckTypeVariance(ret_type, Variance.Covariant, this);
var resolved_rt = new TypeExpression(ret_type, Location);
InvokeBuilder = new Method(this, resolved_rt, MethodModifiers, new MemberName(InvokeMethodName), p, null);
InvokeBuilder.Define();
//
// Don't emit async method for compiler generated delegates (e.g. dynamic site containers)
//
if (!IsCompilerGenerated)
{
DefineAsyncMethods(resolved_rt);
}
return(true);
}
public static void Test <U, V> (Context <U> .D2 <V> d)
{
var c = new Constructor();
c.Before(d);
}
public override void EmitCpp(CppEmitContext cec)
{
if (cec.Pass == CppPasses.PREDEF)
{
if (!cec.CheckCanEmit(Location))
{
return;
}
if (!has_static_constructor && HasStaticFieldInitializer)
{
var c = DefineDefaultConstructor(true);
c.Define();
}
if (!(this.Parent is NamespaceContainer))
{
cec.Report.Error(7175, Location, "C++ code generation for nested types not supported.");
return;
}
Constructor constructor = null;
foreach (var member in Members)
{
var c = member as Constructor;
if (c != null)
{
if ((c.ModFlags & Modifiers.STATIC) != 0)
{
continue;
}
if (constructor != null)
{
cec.Report.Error(7177, c.Location, "C++ generation not supported for overloaded constructors");
return;
}
constructor = c;
}
}
}
if (cec.Pass == CppPasses.PREDEF)
{
cec.Buf.Write("\tclass ", MemberName.Name, ";\n");
}
else if (cec.Pass == CppPasses.CLASSDEF)
{
cec.Buf.Write("\tclass ", MemberName.Name, " {\n", Location);
cec.Buf.Indent();
cec.Buf.Write("\tpublic:\n");
}
base.EmitCpp(cec);
if (cec.Pass == CppPasses.CLASSDEF)
{
cec.Buf.Unindent();
cec.Buf.Write("\t};\n");
}
}
public virtual int compare<T1, T2>(Constructor<T1> arg0, Constructor<T2> arg1)
{
return arg0.toGenericString().compareTo(arg1.toGenericString());
}
public override int GetHashCode()
{
return(Constructor.GetHashCode() ^ TargetMethod.GetHashCode());
}
public BasicForm()
{
this._rightPane = new Constructor();
this._rows = new List <Row>();
}
internal Constructor GetConstructorInvoker()
{
if (_constructor == null)
{
ConstructorInfo info = _type.GetConstructor(Type.EmptyTypes);
DynamicMethod dynamicMethod = new DynamicMethod(string.Empty, _type, new Type[0], info.DeclaringType.Module);
ILGenerator il = dynamicMethod.GetILGenerator();
il.Emit(OpCodes.Newobj, info);
il.Emit(OpCodes.Ret);
_constructor = (Constructor) dynamicMethod.CreateDelegate(typeof (Constructor));
}
return _constructor;
}
public BasicForm(string rightPaneTemplatePath)
{
this._rightPane = new Constructor(rightPaneTemplatePath);
this._rows = new List <Row>();
}
public override void OnConstructor(AST.Constructor node)
{
if (node.IsSynthetic && node.Parameters.Count == 0) return;
Constructor ctor = new Constructor(GetModifier(node), GetRegion(node), GetClientRegion(node), OuterClass);
ConvertAttributes(node, ctor);
ConvertParameters(node.Parameters, ctor);
_currentClass.Peek().Methods.Add(ctor);
ctor.UserData = node;
}
public View OnCreateView(string name, Context context, IAttributeSet attrs)
{
if (name.Equals("com.android.internal.view.menu.ActionMenuItemView", StringComparison.InvariantCultureIgnoreCase))
{
View view = null;
try
{
if (ActionMenuItemViewClass == null)
{
ActionMenuItemViewClass = ClassLoader.SystemClassLoader.LoadClass(name);
}
}
catch (ClassNotFoundException)
{
return(null);
}
if (ActionMenuItemViewClass == null)
{
return(null);
}
if (ActionMenuItemViewConstructor == null)
{
try
{
ActionMenuItemViewConstructor = ActionMenuItemViewClass.GetConstructor(new Class[] {
Class.FromType(typeof(Context)),
Class.FromType(typeof(IAttributeSet))
});
}
catch (SecurityException)
{
return(null);
}
catch (NoSuchMethodException)
{
return(null);
}
}
if (ActionMenuItemViewConstructor == null)
{
return(null);
}
try
{
Java.Lang.Object[] args = new Java.Lang.Object[] { context, (Java.Lang.Object)attrs };
view = (View)(ActionMenuItemViewConstructor.NewInstance(args));
}
catch (IllegalArgumentException)
{
return(null);
}
catch (InstantiationException)
{
return(null);
}
catch (IllegalAccessException)
{
return(null);
}
catch (InvocationTargetException)
{
return(null);
}
if (null == view)
{
return(null);
}
View v = view;
new Handler().Post(() => {
try
{
if (v is LinearLayout)
{
var ll = (LinearLayout)v;
for (int i = 0; i < ll.ChildCount; i++)
{
var button = ll.GetChildAt(i) as Button;
if (button != null)
{
var title = button.Text;
if (!string.IsNullOrEmpty(title) && title.Length == 1)
{
button.SetTypeface(Typeface, TypefaceStyle.Normal);
}
}
}
}
else if (v is TextView)
{
var tv = (TextView)v;
string title = tv.Text;
if (!string.IsNullOrEmpty(title) && title.Length == 1)
{
tv.SetTypeface(Typeface, TypefaceStyle.Normal);
}
}
}
catch (ClassCastException)
{
}
});
return(view);
}
return(null);
}
/// <exception cref="System.Exception"></exception>
public virtual void Process()
{
// System.out.println("exec "+grammarName+"."+startRuleName);
string lexerName = grammarName + "Lexer";
ClassLoader cl = Sharpen.Thread.CurrentThread().GetContextClassLoader();
Type lexerClass = null;
try
{
lexerClass = cl.LoadClass(lexerName).AsSubclass <Lexer>();
}
catch (TypeLoadException)
{
// might be pure lexer grammar; no Lexer suffix then
lexerName = grammarName;
try
{
lexerClass = cl.LoadClass(lexerName).AsSubclass <Lexer>();
}
catch (TypeLoadException)
{
System.Console.Error.WriteLine("Can't load " + lexerName + " as lexer or parser");
return;
}
}
Constructor <Lexer> lexerCtor = lexerClass.GetConstructor(typeof(ICharStream));
Lexer lexer = lexerCtor.NewInstance((ICharStream)null);
Type parserClass = null;
Parser parser = null;
if (!startRuleName.Equals(LexerStartRuleName))
{
string parserName = grammarName + "Parser";
parserClass = cl.LoadClass(parserName).AsSubclass <Parser>();
if (parserClass == null)
{
System.Console.Error.WriteLine("Can't load " + parserName);
return;
}
Constructor <Parser> parserCtor = parserClass.GetConstructor(typeof(ITokenStream));
parser = parserCtor.NewInstance((ITokenStream)null);
}
if (inputFiles.IsEmpty())
{
Stream @is = Sharpen.Runtime.@in;
StreamReader r;
if (encoding != null)
{
r = new StreamReader(@is, encoding);
}
else
{
r = new StreamReader(@is);
}
Process(lexer, parserClass, parser, @is, r);
return;
}
foreach (string inputFile in inputFiles)
{
Stream @is = Sharpen.Runtime.@in;
if (inputFile != null)
{
@is = new FileInputStream(inputFile);
}
StreamReader r;
if (encoding != null)
{
r = new StreamReader(@is, encoding);
}
else
{
r = new StreamReader(@is);
}
if (inputFiles.Count > 1)
{
System.Console.Error.WriteLine(inputFile);
}
Process(lexer, parserClass, parser, @is, r);
}
}
static void Main(string[] args)
{
var resultado = Menu();
if (resultado == -1)
{
Console.WriteLine("Opcion no valida ");
return;
}
Constructor Comida = null;
switch (resultado)
{
case 1:
Console.Clear();
Console.WriteLine("Escoge hamburguesa");
Console.WriteLine("1. Hamburguesa Carne ");
Console.WriteLine("2. Hamburguesa Queso");
Console.WriteLine("3. Hamburguesa Vegetariana");
var l = Console.ReadLine();
var num = int.Parse(l);
switch (num)
{
case 1:
Comida = new ConstructorHamCarne();
break;
case 2:
Comida = new ConstrutorHamQueso();
break;
case 3:
Comida = new ConstrutorHamVege();
break;
}
break;
case 2:
Console.Clear();
Console.WriteLine("Escoge Baggette");
Console.WriteLine("1. Baggette Atun ");
Console.WriteLine("2. Baggette Jamon");
Console.WriteLine("3. Baggette Pepperoni");
var b = Console.ReadLine();
var num2 = int.Parse(b);
switch (num2)
{
case 1:
Comida = new ConstructorBaggAtun();
break;
case 2:
Comida = new ConstructorBaggJamon();
break;
case 3:
Comida = new ConstructorBaggPeppe();
break;
}
break;
default:
Console.WriteLine("Intentelo de nuevo");
break;
}
var ComidaHecha = Comida.ComerComida();
Console.WriteLine($"Ingredientes: {ComidaHecha.PonerIngredientes()}");
Console.WriteLine($"Catsup: {ComidaHecha.PonerCatsup()}");
Console.WriteLine($"Salsa: {ComidaHecha.PonerSalsa()}");
}
/// <summary>
/// This is used to scan the specified constructor for annotations
/// that it contains. Each parameter annotation is evaluated and
/// if it is an XML annotation it is considered to be a valid
/// parameter and is added to the parameter map.
/// </summary>
/// <param name="factory">
/// this is the constructor that is to be scanned
/// </param>
/// <param name="map">
/// this is the parameter map that contains parameters
/// </param>
public void Scan(Constructor factory, Index map) {
Annotation[][] labels = factory.getParameterAnnotations();
Class[] types = factory.getParameterTypes();
for(int i = 0; i < types.length; i++) {
for(int j = 0; j < labels[i].length; j++) {
Parameter value = Process(factory, labels[i][j], i);
if(value != null) {
String name = value.getName();
if(map.containsKey(name)) {
throw new PersistenceException("Parameter '%s' is a duplicate in %s", name, factory);
}
index.put(name, value);
map.put(name, value);
}
}
}
if(types.length == map.size()) {
Build(factory, map);
}
}
public object Create() => Constructor.Invoke(Arguments.Select(x => x.Next()).ToArray());
/// <summary>
/// This is used to create a <c>Parameter</c> object which is
/// used to represent a parameter to a constructor. Each parameter
/// contains an annotation an the index it appears in.
/// </summary>
/// <param name="factory">
/// this is the constructor the parameter is in
/// </param>
/// <param name="label">
/// this is the annotation used for the parameter
/// </param>
/// <param name="ordinal">
/// this is the position the parameter appears at
/// </param>
/// <returns>
/// this returns the parameter for the constructor
/// </returns>
public Parameter Process(Constructor factory, Annotation label, int ordinal) {
if(label instanceof Attribute) {
return Create(factory, label, ordinal);
}
if(label instanceof ElementList) {
return Create(factory, label, ordinal);
}
if(label instanceof ElementArray) {
return Create(factory, label, ordinal);
}
if(label instanceof ElementMap) {
return Create(factory, label, ordinal);
}
if(label instanceof Element) {
return Create(factory, label, ordinal);
}
return null;
}
// TODO: Refactor this method into multiple helper methods and possibly into a control for Toolbar
private View CreateCustomToolbarItem(string name, Context context, IAttributeSet attrs)
{
View view = null;
try
{
if (null == ActionMenuItemViewClass)
{
ActionMenuItemViewClass = ClassLoader.LoadClass(name);
}
}
catch (ClassNotFoundException cnf)
{
LogDebugMessage(cnf, "CreateCustomToolbarItem()");
return(null);
}
if (ActionMenuItemViewClass == null)
{
return(null);
}
if (ActionMenuItemViewConstructor == null)
{
try
{
ActionMenuItemViewConstructor = ActionMenuItemViewClass.GetConstructor(new Class[] {
Class.FromType(typeof(Context)),
Class.FromType(typeof(IAttributeSet))
});
}
catch (SecurityException se)
{
LogDebugMessage(se, "CreateCustomToolbarItem()");
return(null);
}
catch (NoSuchMethodException nsme)
{
LogDebugMessage(nsme, "CreateCustomToolbarItem()");
return(null);
}
}
if (ActionMenuItemViewConstructor == null)
{
return(null);
}
try
{
Java.Lang.Object[] args = new Java.Lang.Object[] { context, (Java.Lang.Object)attrs };
view = (View)(ActionMenuItemViewConstructor.NewInstance(args));
}
catch (IllegalArgumentException)
{
//LogDebugMessage(se, "CreateCustomToolbarItem()");
return(null);
}
catch (InstantiationException)
{
//LogDebugMessage(se, "CreateCustomToolbarItem()");
return(null);
}
catch (IllegalAccessException)
{
//LogDebugMessage(se, "CreateCustomToolbarItem()");
return(null);
}
catch (InvocationTargetException)
{
//LogDebugMessage(se, "CreateCustomToolbarItem()");
return(null);
}
if (null == view)
{
return(null);
}
View v = view;
new Handler().Post(() =>
{
try
{
if (v is LinearLayout)
{
var linearLayout = (LinearLayout)v;
for (int i = 0; i < linearLayout.ChildCount; i++)
{
var button = linearLayout.GetChildAt(i) as Button;
var title = button?.Text;
if (!string.IsNullOrEmpty(title) && title.Length == 1)
{
button.SetTypeface(Typeface, TypefaceStyle.Normal);
}
}
}
else if (v is TextView)
{
var tv = (TextView)v;
string title = tv.Text;
if (!string.IsNullOrEmpty(title) && title.Length == 1)
{
tv.SetTypeface(Typeface, TypefaceStyle.Normal);
}
}
}
catch (ClassCastException cce)
{
LogDebugMessage(cce, "CreateCustomToolbarItem()");
}
});
return(view);
}
public override void OnConstructor(Constructor node)
{
OnMethod(node);
}
public static void Start()
{
if (Navigator.Manager.NotDefined(MethodInfo.GetCurrentMethod()))
{
Navigator.AddSettings(new List <EntitySettings>
{
new EntitySettings <EmployeeEntity>()
{
View = e => new Employee()
},
new EntitySettings <TerritoryEntity>()
{
View = e => new Territory()
},
new EntitySettings <RegionEntity>()
{
View = e => new Region()
},
new EntitySettings <ProductEntity>()
{
View = e => new Product()
},
new EntitySettings <CategoryEntity>()
{
View = e => new Category(), IsViewable = true
},
new EntitySettings <SupplierEntity>()
{
View = e => new Supplier()
},
new EntitySettings <CompanyEntity>()
{
View = e => new Company()
},
new EntitySettings <PersonEntity>()
{
View = e => new Person()
},
new EntitySettings <OrderEntity>()
{
View = e => new Order()
},
});
QuerySettings.RegisterPropertyFormat((EmployeeEntity e) => e.Photo, b =>
{
b.Converter = SouthwindConverters.ImageConverter;
return(Fluent.GetDataTemplate(() => new Image {
MaxHeight = 32.0, Stretch = Stretch.Uniform
}
.Bind(Image.SourceProperty, b)
.Set(RenderOptions.BitmapScalingModeProperty, BitmapScalingMode.Linear)));
}); //Photo
QuerySettings.RegisterPropertyFormat((CategoryEntity e) => e.Picture, b =>
{
b.Converter = SouthwindConverters.EmbeddedImageConverter;
return(Fluent.GetDataTemplate(() => new Image {
MaxHeight = 32.0, Stretch = Stretch.Uniform
}
.Bind(Image.SourceProperty, b)
.Set(RenderOptions.BitmapScalingModeProperty, BitmapScalingMode.Linear)));
}); //Picture
Constructor.Register(ctx => new EmployeeEntity {
Address = new AddressEmbedded()
});
Constructor.Register(ctx => new PersonEntity {
Address = new AddressEmbedded()
});
Constructor.Register(ctx => new CompanyEntity {
Address = new AddressEmbedded()
});
Constructor.Register(ctx => new SupplierEntity {
Address = new AddressEmbedded()
});
OperationClient.AddSettings(new List <OperationSettings>()
{
new ConstructorOperationSettings <OrderEntity>(OrderOperation.Create)
{
Constructor = ctx =>
{
var cust = Finder.Find <CustomerEntity>(); // could return null, but we let it continue
return(OperationServer.Construct(OrderOperation.Create, cust));
},
},
new ContextualOperationSettings <ProductEntity>(OrderOperation.CreateOrderFromProducts)
{
Click = ctx =>
{
var cust = Finder.Find <CustomerEntity>(); // could return null, but we let it continue
var result = OperationServer.ConstructFromMany(ctx.Entities, OrderOperation.CreateOrderFromProducts, cust);
Navigator.Navigate(result);
},
},
new EntityOperationSettings <OrderEntity>(OrderOperation.SaveNew)
{
IsVisible = ctx => ctx.Entity.IsNew
},
new EntityOperationSettings <OrderEntity>(OrderOperation.Save)
{
IsVisible = ctx => !ctx.Entity.IsNew
},
new EntityOperationSettings <OrderEntity>(OrderOperation.Cancel)
{
ConfirmMessage = ctx => ((OrderEntity)ctx.Entity).State == OrderState.Shipped ? OrderMessage.CancelShippedOrder0.NiceToString(ctx.Entity) : null
},
new EntityOperationSettings <OrderEntity>(OrderOperation.Ship)
{
Click = ctx =>
{
DateTime shipDate = DateTime.Now;
if (!ValueLineBox.Show(ref shipDate,
labelText: DescriptionManager.NiceName((OrderEntity o) => o.ShippedDate),
owner: Window.GetWindow(ctx.EntityControl)))
{
return(null);
}
try
{
return(ctx.Entity.Execute(OrderOperation.Ship, shipDate));
}
catch (IntegrityCheckException e)
{
ctx.Entity.SetGraphErrors(e);
throw e;
}
},
Contextual =
{
Click = ctx =>
{
DateTime shipDate = DateTime.Now;
if (!ValueLineBox.Show(ref shipDate,
labelText: DescriptionManager.NiceName((OrderEntity o) => o.ShippedDate),
owner: Window.GetWindow(ctx.SearchControl)))
{
return;
}
ctx.Entities.SingleEx().ExecuteLite(OrderOperation.Ship, shipDate);
}
}
},
});
//NotDefined
}
}
public RotationsGroup(byte dimensions, Constructor <T, P, int> ctor) : base(dimensions, ctor)
{
}
static void Main(string[] args)
{
var boolType = SolidityType.Bool;
var intType = SolidityType.Int;
var propertyName = "PropertyName1";
var propertyName2 = "PropertyName2";
var propertyName3 = "PropertyName3";
var pr1 = new ContractProperty()
{
Variable = PrepareVariable(propertyName, boolType),
Visibility = Visibility.Public
};
var pr2 = new ContractProperty()
{
Variable = PrepareVariable(propertyName2, intType),
Visibility = Visibility.Private
};
var pr3 = new ContractProperty()
{
Variable = PrepareVariable(propertyName3, boolType),
Visibility = Visibility.Public
};
var properties = new List <ContractProperty>()
{
pr1, pr2, pr3
};
var eventName = "EventName1";
var eventName2 = "EventName2";
var eventName3 = "EventName3";
var epl = new ParametersList()
{
Parameters = new List <Variable>()
{
PrepareVariable("ep1", boolType), PrepareVariable("ep2", intType)
}
};
var epl2 = new ParametersList()
{
Parameters = new List <Variable>()
{
PrepareVariable("ep1", boolType)
}
};
var epl3 = new ParametersList()
{
Parameters = new List <Variable>()
{
PrepareVariable("ep1", intType)
}
};
var e1 = new ContractEvent()
{
Name = eventName,
Parameters = epl
};
var e2 = new ContractEvent()
{
Name = eventName2,
Parameters = epl2
};
var e3 = new ContractEvent()
{
Name = eventName3,
Parameters = epl3
};
var events = new List <ContractEvent>()
{
e1, e2, e3
};
var name1 = "_p";
var name2 = "_q";
var name3 = "_r";
var name4 = "v";
var p1 = PrepareVariable(name1, boolType);
var p2 = PrepareVariable(name2, boolType);
var p3 = PrepareVariable(name3, boolType);
var v = PrepareVariable(name4, boolType);
var pl = new ParametersList()
{
Parameters = new List <Variable>()
{
p1, p2
}
};
var pl2 = new ParametersList()
{
Parameters = new List <Variable>()
{
p1, p2, p3
}
};
var cpl = new CallingParametersList()
{
Parameters = new List <IAssignable>()
{
p1, p2
}
};
var cpl2 = new CallingParametersList()
{
Parameters = new List <IAssignable>()
{
p1, p2, p3
}
};
var d = new Declaration()
{
Variable = v
};
var op = new Operation()
{
LeftSide = p1,
Operator = OperationOperator.OR,
RightSide = p2
};
var instruction = new Assignment()
{
Destination = d,
Source = op
};
var ao = new Operation()
{
LeftSide = v,
Operator = OperationOperator.Negation
};
var instruction2 = new Assignment()
{
Destination = v,
Source = ao
};
var instructions = new InstructionsList();
instructions.AppendInstruction(instruction);
instructions.AppendInstruction(instruction2);
var c = new Constructor()
{
Visibility = Visibility.Public,
Parameters = pl,
Instructions = instructions
};
var functionInstructions = new InstructionsList();
functionInstructions.AppendInstruction(instruction);
var aof = new Operation()
{
LeftSide = v,
Operator = OperationOperator.AND,
RightSide = p3
};
var instruction3 = new Assignment()
{
Destination = v,
Source = aof
};
functionInstructions.AppendInstruction(instruction3);
var function = new ContractFunction()
{
Name = "TestFunction",
Visibility = Visibility.Public,
Parameters = pl2,
Instructions = functionInstructions
};
var fp1 = PrepareVariable(name1, intType);
var fp2 = PrepareVariable(name2, intType);
var fp3 = PrepareVariable(name3, intType);
var fv = PrepareVariable(name4, intType);
var fpl = new ParametersList()
{
Parameters = new List <Variable>()
{
fp1, fp2, fp3
}
};
var fd = new Declaration()
{
Variable = fv
};
var fop = new Operation()
{
LeftSide = p1,
Operator = OperationOperator.Plus,
RightSide = p2
};
var finstruction = new Assignment()
{
Destination = fd,
Source = fop
};
var fao = new Operation()
{
LeftSide = v,
Operator = OperationOperator.Multiply,
RightSide = fp3
};
var finstruction2 = new Assignment()
{
Destination = pr2,
Source = fao
};
var finstructions = new InstructionsList();
finstructions.AppendInstruction(finstruction);
finstructions.AppendInstruction(finstruction2);
var function2 = new ContractFunction()
{
Name = "TestFunction2",
Visibility = Visibility.External,
Parameters = fpl,
Instructions = finstructions
};
var trueInstructions = new InstructionsList();
var falseInstructions = new InstructionsList();
trueInstructions.AppendInstruction(
new FunctionCall()
{
FunctionToCall = function, Parameters = cpl2
}
);
var ecpl = new CallingParametersList()
{
Parameters = new List <IAssignable>()
{
p1
}
};
falseInstructions.AppendInstruction(
new EventCall()
{
EventToCall = e2, Parameters = ecpl
}
);
var newFInstructions = new InstructionsList();
var condOp = new Operation()
{
LeftSide = p1,
Operator = OperationOperator.Negation
};
var cond = new Condition()
{
ConditionOperation = condOp
};
var ifStatement = new IfStatement()
{
Condition = cond,
TrueInstructions = trueInstructions,
FalseInstructions = falseInstructions
};
newFInstructions.AppendInstruction(ifStatement);
var loopVariable = PrepareVariable("loopVariable", intType);
var declaration = new Declaration()
{
Variable = loopVariable
};
var assignment = new Assignment()
{
Destination = declaration,
Source = new ConstantValue()
{
Value = "0"
}
};
var condOperation = new Operation()
{
LeftSide = loopVariable,
Operator = OperationOperator.NotEquals,
RightSide = new ConstantValue()
{
Value = "1"
}
};
var breakCondition = new Condition()
{
ConditionOperation = condOperation
};
var stepOp = new Operation()
{
LeftSide = loopVariable,
Operator = OperationOperator.Plus,
RightSide = new ConstantValue()
{
Value = "1"
}
};
var stepInstruction = new Assignment()
{
Destination = loopVariable,
Source = stepOp
};
var loopInstructions = new InstructionsList();
var cple = new CallingParametersList()
{
Parameters = new List <IAssignable>()
{
loopVariable
}
};
loopInstructions.AppendInstruction(
new EventCall()
{
EventToCall = e3,
Parameters = cple
}
);
var loop = new ContractLoop()
{
InitialAssignment = assignment,
BreakCondition = breakCondition,
StepInstruction = stepInstruction,
Instructions = loopInstructions
};
newFInstructions.AppendInstruction(loop);
var function3 = new ContractFunction()
{
Name = "NewFunction",
Visibility = Visibility.Public,
Parameters = pl2,
Instructions = newFInstructions
};
var functions = new List <ContractFunction>()
{
function, function2, function3
};
string contractName = "TestContract";
Contract contract = new Contract()
{
Name = contractName,
Constructor = c,
Functions = functions,
Events = events,
Properties = properties
};
Console.WriteLine(contract.GenerateCode(new Indentation()));
}
public MainViewModel()
{
SampleGeneration = Command.RegisterCommand(GenerateSample);
MyMethod = new MethodPresenter().PresentMethod();
Params = new ObservableCollection <Parameter>(MyMethod.MethodInformation.GetParameters().ToParamaters());
Ctors = new ObservableCollection <KeyValuePair <object, string> >(Constructor.GetCTors(MyMethod.ClassInstance.GetType()).GetSelectList(EMPTYCTOR));
SelectedCtorParameters = new ObservableCollection <Parameter>();
Results = new ObservableCollection <TestResult>();
SelectedCtor = Ctors.FirstOrDefault();
SetProperties = MyMethod.ClassInstance.GetType().GetProps().ToCaption();
System.Diagnostics.Debug.WriteLine(SetProperties);
GenerateSample();
}
public static IManualTypeDefinitionManager WithAcceptedDefinition <T>(this IManualTypeDefinitionManager manualTypeDefinitionManager, T defaultValue, string editorName = null, string displayName = null) => manualTypeDefinitionManager.WithAcceptedDefinition(Constructor.TypeDefinition(defaultValue, editorName, displayName));
internal static void constructors(this TextWriter trapFile, Constructor key, string name, Type definingType, Constructor originalDefinition)
{
trapFile.WriteTuple("constructors", key, name, definingType, originalDefinition);
}
public View OnCreateView(string name, Context context, IAttributeSet attrs)
{
if (name.Equals("com.android.internal.view.menu.ActionMenuItemView", StringComparison.InvariantCultureIgnoreCase))
{
View view = null;
try
{
if (ActionMenuItemViewClass == null)
ActionMenuItemViewClass = ClassLoader.SystemClassLoader.LoadClass(name);
}
catch (ClassNotFoundException)
{
return null;
}
if (ActionMenuItemViewClass == null)
return null;
if (ActionMenuItemViewConstructor == null)
{
try
{
ActionMenuItemViewConstructor = ActionMenuItemViewClass.GetConstructor(new Class[] {
Class.FromType(typeof(Context)),
Class.FromType(typeof(IAttributeSet))
});
}
catch (SecurityException)
{
return null;
}
catch (NoSuchMethodException)
{
return null;
}
}
if (ActionMenuItemViewConstructor == null)
return null;
try
{
Java.Lang.Object[] args = new Java.Lang.Object[] { context, (Java.Lang.Object)attrs };
view = (View)(ActionMenuItemViewConstructor.NewInstance(args));
}
catch (IllegalArgumentException)
{
return null;
}
catch (InstantiationException)
{
return null;
}
catch (IllegalAccessException)
{
return null;
}
catch (InvocationTargetException)
{
return null;
}
if (null == view)
return null;
View v = view;
new Handler().Post(() => {
try
{
var tv = (TextView)v;
string title = tv.Text;
if (!string.IsNullOrEmpty(title) && title.Length == 1)
{
tv.SetTypeface(Typeface, TypefaceStyle.Normal);
}
}
catch (ClassCastException)
{
}
});
return view;
}
return null;
}
void HandleConstructor()
{
for (int i = 0; i < myUnits.Count; i++)
{
if (myUnits[i].GetComponent <Constructor>() && myUnits[i].GetComponent <Constructor>().doingNothing())
{
Constructor constructor = myUnits[i].GetComponent <Constructor>();
CreationBuilding buildingToBuild;
if (UnityEngine.Random.value < 0.5f)
{
buildingToBuild = constructor.Buildings[0];
}
else
{
buildingToBuild = constructor.Buildings[1];
}
float money = myFaction.Equals(Faction.Blue) ? gameMaster.BlueWool : gameMaster.RedWool;
if (buildingToBuild.Cost <= money)
{
GameObject tmp = Instantiate(buildingToBuild.BuildingGhost, initialBuildingPosition.position + Vector3.up * 0.5f, buildingToBuild.BuildingGhost.transform.rotation);
BuildingGhost bdGhostInstantied = tmp.GetComponent <BuildingGhost>();
int cap = 0;
RaycastHit ra;
bool hittedSomeGO = true;
Physics.SphereCast(bdGhostInstantied.transform.position + Vector3.up * 40, 5, -Vector3.up, out ra, 50);
if (ra.collider.gameObject.GetComponent <RTSGameObject>())
{
hittedSomeGO = true;
}
else
{
hittedSomeGO = false;
}
while (hittedSomeGO && cap < 7)
{
bdGhostInstantied.transform.position += Vector3.forward * -20;
Physics.SphereCast(bdGhostInstantied.transform.position + Vector3.up * 40, 5, -Vector3.up, out ra, 50);
if (ra.collider.gameObject.GetComponent <RTSGameObject>())
{
hittedSomeGO = true;
}
else
{
hittedSomeGO = false;
}
cap++;
}
if (cap >= 7)
{
tooMuchBuilding = true;
}
else
{
constructor.SendBuildOrder(buildingToBuild.gameObject, bdGhostInstantied.gameObject,
bdGhostInstantied.transform.position, buildingToBuild.gameObject.transform.rotation, true, false);
}
}
else
{
constructor.SendDirectMoveOrder(constructorBasePosition.position);
}
}
}
}
public Testable(Type type)
{
_type = type;
_constructor = new Constructor(_type);
_dependencies = new Dependencies(_type);
}
public OperationDescription(string name, Constructor create)
{
Name = name;
Create = create;
}
public GenericInstanceConstructorInfo(Constructor ctor, Type declaringType, GenericTypeInfo genericType) : base(ctor)
{
_declaringType = declaringType;
_genericType = genericType;
}
/*!
\brief Create a forest of trees.
forest ::= nil | cons(tree, forest)
tree ::= nil | cons(forest, forest)
*/
public void forest_example()
{
mk_context();
Sort tree, forest;
FuncDecl nil1_decl, is_nil1_decl, cons1_decl, is_cons1_decl, car1_decl, cdr1_decl;
FuncDecl nil2_decl, is_nil2_decl, cons2_decl, is_cons2_decl, car2_decl, cdr2_decl;
Expr nil1, nil2, t1, t2, t3, t4, f1, f2, f3, l1, l2, x, y, u, v;
//
// Declare the names of the accessors for cons.
// Then declare the sorts of the accessors.
// For this example, all sorts refer to the new types 'forest' and 'tree'
// being declared, so we pass in null for both sorts1 and sorts2.
// On the other hand, the sort_refs arrays contain the indices of the
// two new sorts being declared. The first element in sort1_refs
// points to 'tree', which has index 1, the second element in sort1_refs array
// points to 'forest', which has index 0.
//
Symbol[] head_tail1 = new Symbol[] { z3.MkSymbol("head"), z3.MkSymbol("tail") };
Sort[] sorts1 = new Sort[] { null, null };
uint[] sort1_refs = new uint[] { 1, 0 }; // the first item points to a tree, the second to a forest
Symbol[] head_tail2 = new Symbol[] { z3.MkSymbol("car"), z3.MkSymbol("cdr") };
Sort[] sorts2 = new Sort[] { null, null };
uint[] sort2_refs = new uint[] { 0, 0 }; // both items point to the forest datatype.
Constructor nil1_con, cons1_con, nil2_con, cons2_con;
Constructor[] constructors1 = new Constructor[2], constructors2 = new Constructor[2];
Symbol[] sort_names = { z3.MkSymbol("forest"), z3.MkSymbol("tree") };
Console.WriteLine("\nforest_example");
/* build a forest */
nil1_con = z3.MkConstructor(z3.MkSymbol("nil"), z3.MkSymbol("is_nil"), null, null, null);
cons1_con = z3.MkConstructor(z3.MkSymbol("cons1"), z3.MkSymbol("is_cons1"), head_tail1, sorts1, sort1_refs);
constructors1[0] = nil1_con;
constructors1[1] = cons1_con;
/* build a tree */
nil2_con = z3.MkConstructor(z3.MkSymbol("nil2"), z3.MkSymbol("is_nil2"), null, null, null);
cons2_con = z3.MkConstructor(z3.MkSymbol("cons2"), z3.MkSymbol("is_cons2"), head_tail2, sorts2, sort2_refs);
constructors2[0] = nil2_con;
constructors2[1] = cons2_con;
Constructor[][] clists = new Constructor[][] { constructors1, constructors2 };
Sort[] sorts = z3.MkDatatypeSorts(sort_names, clists);
forest = sorts[0];
tree = sorts[1];
//
// Now that the datatype has been created.
// Query the constructors for the constructor
// functions, testers, and field accessors.
//
nil1_decl = nil1_con.ConstructorDecl;
is_nil1_decl = nil1_con.TesterDecl;
cons1_decl = cons1_con.ConstructorDecl;
is_cons1_decl = cons1_con.TesterDecl;
FuncDecl[] cons1_accessors = cons1_con.AccessorDecls;
car1_decl = cons1_accessors[0];
cdr1_decl = cons1_accessors[1];
nil2_decl = nil2_con.ConstructorDecl;
is_nil2_decl = nil2_con.TesterDecl;
cons2_decl = cons2_con.ConstructorDecl;
is_cons2_decl = cons2_con.TesterDecl;
FuncDecl[] cons2_accessors = cons2_con.AccessorDecls;
car2_decl = cons2_accessors[0];
cdr2_decl = cons2_accessors[1];
nil1 = z3.MkConst(nil1_decl);
nil2 = z3.MkConst(nil2_decl);
f1 = mk_binary_app(cons1_decl, nil2, nil1);
t1 = mk_binary_app(cons2_decl, nil1, nil1);
t2 = mk_binary_app(cons2_decl, f1, nil1);
t3 = mk_binary_app(cons2_decl, f1, f1);
t4 = mk_binary_app(cons2_decl, nil1, f1);
f2 = mk_binary_app(cons1_decl, t1, nil1);
f3 = mk_binary_app(cons1_decl, t1, f1);
/* nil != cons(nil,nil) */
prove2(z3.MkNot(z3.MkEq(nil1, f1)), true);
prove2(z3.MkNot(z3.MkEq(nil2, t1)), true);
/* cons(x,u) = cons(x, v) => u = v */
u = mk_var("u", forest);
v = mk_var("v", forest);
x = mk_var("x", tree);
y = mk_var("y", tree);
l1 = mk_binary_app(cons1_decl, x, u);
l2 = mk_binary_app(cons1_decl, y, v);
prove2(z3.MkImplies(z3.MkEq(l1, l2), z3.MkEq(u, v)), true);
prove2(z3.MkImplies(z3.MkEq(l1, l2), z3.MkEq(x, y)), true);
/* is_nil(u) or is_cons(u) */
prove2(z3.MkOr((BoolExpr)z3.MkApp(is_nil1_decl, u),
(BoolExpr)z3.MkApp(is_cons1_decl, u)), true);
/* occurs check u != cons(x,u) */
prove2(z3.MkNot(z3.MkEq(u, l1)), true);
}
private T InvokeConstructor(Constructor constructorWithParameters, object[] parameters)
{
return(constructorWithParameters.ConstructorInfo.Invoke(parameters) as T);
}
public View OnCreateView(View parent, string name, Context context, IAttributeSet attrs)
{
System.Diagnostics.Debug.WriteLine (name);
if (name.Equals("android.support.v7.internal.view.menu.ActionMenuItemView", StringComparison.InvariantCultureIgnoreCase))
{
View view = null;
try
{
if (ActionMenuItemViewClass == null)
ActionMenuItemViewClass = ClassLoader.SystemClassLoader.LoadClass(name);
}
catch (ClassNotFoundException)
{
return null;
}
if (ActionMenuItemViewClass == null)
return null;
if (ActionMenuItemViewConstructor == null)
{
try
{
ActionMenuItemViewConstructor = ActionMenuItemViewClass.GetConstructor(new Class[] {
Class.FromType(typeof(Context)),
Class.FromType(typeof(IAttributeSet))
});
}
catch (SecurityException)
{
return null;
}
catch (NoSuchMethodException)
{
return null;
}
}
if (ActionMenuItemViewConstructor == null)
return null;
try
{
Java.Lang.Object[] args = new Java.Lang.Object[] { context, (Java.Lang.Object)attrs };
view = (View)(ActionMenuItemViewConstructor.NewInstance(args));
}
catch (IllegalArgumentException)
{
return null;
}
catch (InstantiationException)
{
return null;
}
catch (IllegalAccessException)
{
return null;
}
catch (InvocationTargetException)
{
return null;
}
if (null == view)
return null;
View v = view;
new Handler().Post(() => {
try
{
if(v is LinearLayout) {
var ll = (LinearLayout)v;
for(int i = 0; i < ll.ChildCount; i++) {
var button = ll.GetChildAt(i) as Button;
if(button != null) {
var title = button.Text;
if (!string.IsNullOrEmpty(title) && title.Length == 1)
{
button.SetTypeface(Typeface, TypefaceStyle.Normal);
}
}
}
}
else if(v is TextView) {
var tv = (TextView)v;
string title = tv.Text;
if (!string.IsNullOrEmpty(title) && title.Length == 1)
{
tv.SetTypeface(Typeface, TypefaceStyle.Normal);
}
}
}
catch (ClassCastException)
{
}
});
return view;
}
return null;
}
public override int getLength()
{
return(_value.Length + Constructor.getLength() + _width);
}
private static INodeField ValueDisplay(ITypeDefinition typeDef, object x)
{
INodeField output = Constructor.NodeField(x.ToString()).WithValue("Displayed", Constructor.RigidTypeDefinitionManager(typeDef.DefaultValue, null, "DefaultDisplay"), false);
output.DisplayedValue.Value = x;
output.SetFlowOutput();
return(output);
}
/// <summary>
/// Constructor for the <c>Builder</c> object. This is used
/// to create a factory like object used for instantiating objects.
/// Each builder will score its suitability using the parameters
/// it is provided.
/// </summary>
/// <param name="factory">
/// this is the factory used for instantiation
/// </param>
/// <param name="index">
/// this is the map of parameters that are declared
/// </param>
public Builder(Constructor factory, Index index) {
this.list = index.Parameters;
this.factory = factory;
this.index = index;
}
public ApplyOperation(Constructor c)
{
C = c;
}
private object[] GetParameterValues(Constructor constructor)
{
return(constructor.Parameters.Select(x => x.Value).ToArray());
}
public override object VisitConstructorDeclaration(AST.ConstructorDeclaration constructorDeclaration, object data)
{
DomRegion region = GetRegion(constructorDeclaration.StartLocation, constructorDeclaration.EndLocation);
DomRegion bodyRegion = GetRegion(constructorDeclaration.EndLocation, constructorDeclaration.Body != null ? constructorDeclaration.Body.EndLocation : RefParser.Location.Empty);
DefaultClass c = GetCurrentClass();
Constructor constructor = new Constructor(ConvertModifier(constructorDeclaration.Modifier), region, bodyRegion, GetCurrentClass());
constructor.Documentation = GetDocumentation(region.BeginLine, constructorDeclaration.Attributes);
ConvertAttributes(constructorDeclaration, constructor);
if (constructorDeclaration.Parameters != null) {
foreach (AST.ParameterDeclarationExpression par in constructorDeclaration.Parameters) {
constructor.Parameters.Add(CreateParameter(par));
}
}
if (constructor.Modifiers.HasFlag(ModifierEnum.Static))
constructor.Modifiers = ConvertModifier(constructorDeclaration.Modifier, ModifierEnum.None);
c.Methods.Add(constructor);
return null;
}
private bool IsCtorWithInterfacesOnly(Constructor constructor)
{
return(constructor.Parameters.All(x => x.Type.IsInterface));
}
