Esempio n. 1
0
        private object InterpretCall(GenericScope genericScope, MethodBase method, MethodDefinition definition, object target, IReadOnlyList <object> arguments)
        {
            var context     = new CilHandlerContext(genericScope, method, definition, target, arguments ?? Empty <object> .Array, _resolver, _invoker);
            var instruction = definition.Body.Instructions[0];

            var returnType = (method as MethodInfo)?.ReturnType;

            while (instruction != null)
            {
                if (instruction.OpCode == OpCodes.Ret)
                {
                    var result = (object)null;
                    if (returnType != null && returnType != typeof(void))
                    {
                        result = TypeSupport.Convert(context.Stack.Pop(), returnType);
                    }

                    if (context.Stack.Count > 0)
                    {
                        throw new Exception($"Unbalanced stack on return: {context.Stack.Count} extra items.");
                    }

                    return(result);
                }

                context.NextInstruction = instruction.Next;
                InterpretInstruction(instruction, context);
                instruction = context.NextInstruction;
            }

            throw new Exception($"Failed to reach a 'ret' instruction.");
        }
Esempio n. 2
0
        public void Handle(Instruction instruction, CilHandlerContext context)
        {
            var length    = (int)Primitives.Convert(context.Stack.Pop(), typeof(int));
            var arrayType = context.Resolver.Type(new ArrayType((TypeReference)instruction.Operand), context.GenericScope);

            context.Stack.Push(TypeSupport.CreateArray(arrayType, length));
        }
Esempio n. 3
0
        public override bool IsAssignableFrom(Type c)
        {
            if (c == null)
            {
                return(false);
            }

            return(TypeSupport.IsAssignableFrom(this, c));
        }
Esempio n. 4
0
        public override bool IsInstanceOfType(object o)
        {
            if (o == null)
            {
                return(false);
            }

            return(IsAssignableFrom(TypeSupport.GetTypeOf(o)));
        }
Esempio n. 5
0
        public ObjectTypeOverride(object @object, NonRuntimeType type)
        {
            if (@object is INonRuntimeObject)
            {
                throw new ArgumentException($"Attempted to override type twice ({@object}).");
            }

            if (TypeSupport.GetTypeOf(@object) == type)
            {
                throw new ArgumentException($"Attempted to override type for {@object} that already has type {type}.");
            }

            Type   = Argument.NotNull(nameof(type), type);
            Object = @object;
        }
Esempio n. 6
0
    void setTypeSupport()
    {
        int i = Random.Range(0, 8);

        switch (i)
        {
        case 0:
            typeSupport = TypeSupport.hp;
            GetComponent <SpriteRenderer>().sprite = add_HP;
            break;

        case 1:
            typeSupport = TypeSupport.plane;
            GetComponent <SpriteRenderer>().sprite = add_Plane;
            break;

        case 2:
            typeSupport = TypeSupport.shield;
            GetComponent <SpriteRenderer>().sprite = shield;
            break;

        case 3:
            typeSupport = TypeSupport.up_bullet;
            GetComponent <SpriteRenderer>().sprite = lv_up_bullet;
            break;

        case 4:
            typeSupport = TypeSupport.homing;
            GetComponent <SpriteRenderer>().sprite = homing;
            break;

        case 5:
            typeSupport = TypeSupport.add_dame;
            GetComponent <SpriteRenderer>().sprite = add_Dame;
            break;

        case 6:
            typeSupport = TypeSupport.add_bullet_up;
            GetComponent <SpriteRenderer>().sprite = add_bullet_up;
            break;

        case 7:
            typeSupport = TypeSupport.add_bullet_left_right;
            GetComponent <SpriteRenderer>().sprite = add_bullet_left_right;
            break;
        }
    }
Esempio n. 7
0
        public virtual object Get(InterpretedField field)
        {
            if (_fieldValues == null)
            {
                _fieldValues = new Dictionary <string, object>();
            }

            object value;

            if (!_fieldValues.TryGetValue(field.Name, out value))
            {
                value = TypeSupport.GetDefaultValue(field.FieldType);
                _fieldValues.Add(field.Name, value);
            }

            return(value);
        }
Esempio n. 8
0
        private static MethodInfo FindTargetMethodByExplicitOverrides(MethodInfo method, Type targetType)
        {
            if (TypeSupport.IsRuntime(targetType))
            {
                throw new NotImplementedException();
            }

            foreach (var candidate in targetType.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic))
            {
                var overrides = ((InterpretedMethod)candidate).GetExplicitOverrides();
                if (overrides.Contains(method))
                {
                    return(candidate);
                }
            }

            return(null);
        }
Esempio n. 9
0
    public void setTypeSupport(TypeSupport type)
    {
        switch (type)
        {
        case TypeSupport.add_bullet_left_right:
            StopCoroutine(activeSupport(add_bullet_left_right));
            StartCoroutine(activeSupport(add_bullet_left_right));
            break;

        case TypeSupport.add_bullet_up:
            StopCoroutine(activeSupport(add_bullet_up));
            StartCoroutine(activeSupport(add_bullet_up));
            break;

        case TypeSupport.homing:
            StopCoroutine(activeSupport(homing));
            StartCoroutine(activeSupport(homing));
            break;

        case TypeSupport.hp:
            GetComponent <PlaneController>().add_HP(add_HP);
            break;

        case TypeSupport.plane:
            StopCoroutine(activeSupport(add_Plane));
            StartCoroutine(activeSupport(add_Plane));
            break;

        case TypeSupport.shield:
            active_shield();
            StopCoroutine(activeSupport(shield));
            StartCoroutine(activeSupport(shield));
            break;

        case TypeSupport.add_dame:
            active_add_dame();
            break;

        case TypeSupport.up_bullet:
            active_up_bullet();
            break;
        }
    }
        public Topic(string topicName, AdapterTopicQos requiredTopicQoS, TypeSupport clientTypeSupport)
        {
            if (clientTypeSupport == null)
            {
                throw new ArgumentNullException("clientTypeSupport");
            }

            string domain = null;

            // just using the default partition, named after the topic name
            TopicName = topicName;
            TopicType = typeof(T).Name;

            // Create a DomainParticipantFactory and a DomainParticipant
            RegisterDomain(this, domain);

            ErrorHandler.CheckHandle(Participant, "DDS.DomainParticipantFactory.CreateParticipant");

            // Register the required datatype.
            typeSupport = new TopicTypeSupport(clientTypeSupport);
            ReturnCode status = typeSupport.RegisterType(Participant, topicName);

            ErrorHandler.CheckStatus(status, "Topic.TopicMessageTypeSupport.RegisterType");

            TopicQos topicQos = null;

            Participant.GetDefaultTopicQos(ref topicQos);
            ApplyQos(topicQos, requiredTopicQoS);

            TopicQos = topicQos;

            TopicMessageTopic = Participant.CreateTopic(topicName, topicName, topicQos);

            Participant.SetDefaultTopicQos(topicQos);
            if (TopicMessageTopic == null)
            {
                throw new Exception("QoS for topic " + TopicName + " FAILED!, please check QoS!");
            }
        }
 public TopicTypeSupport(TypeSupport clientTypeSupport) : base(typeof(T))
 {
     this.clientTypeSupport = clientTypeSupport;
 }
Esempio n. 12
0
 public void    When_creating_an_instance_from_TypeSupport_it_should_not_be_null()
 {
     Assert.IsNotNull(TypeSupport <t> .Create());
 }
Esempio n. 13
0
        public void SetVariable(int index, object value)
        {
            var definition = _variableDefinitions[index];

            _variablesMutable[index] = TypeSupport.Convert(value, Resolver.Type(definition.VariableType, GenericScope));
        }
Esempio n. 14
0
        public static string Output(this FPdf document, string name, OutputDevice destination)
        {
            // Output PDF to some destination
            if (document.State < 3)
            {
                document.Close();
            }
            if (destination == OutputDevice.Default)
            {
                if (string.IsNullOrEmpty(name))
                {
                    name        = "doc.pdf";
                    destination = OutputDevice.StandardOutput;
                }
                else
                {
                    destination = OutputDevice.SaveToFile;
                }
            }
            switch (destination)
            {
            case OutputDevice.StandardOutput:
                HttpContext.Current.Response.AppendHeader("Content-Type: application/pdf", "");
                HttpContext.Current.Response.AppendHeader("Content-Disposition: inline; filename=\"" + name + "\"",
                                                          "");
                HttpContext.Current.Response.AppendHeader("Cache-Control: private, max-age=0, must-revalidate", "");
                HttpContext.Current.Response.AppendHeader("Pragma: public", "");
                HttpContext.Current.Response.Write(document.Buffer);
                break;

            case OutputDevice.Download:
                // Download file
                HttpContext.Current.Response.AppendHeader("Content-Type: application/x-download", "");
                HttpContext.Current.Response.AppendHeader(
                    "Content-Disposition: attachment; filename=\"" + name + "\"", "");
                HttpContext.Current.Response.AppendHeader("Cache-Control: private, max-age=0, must-revalidate", "");
                HttpContext.Current.Response.AppendHeader("Pragma: public", "");
                HttpContext.Current.Response.Write(document.Buffer);
                break;

            case OutputDevice.SaveToFile:
                // Save to local file
                FileStream f = FileSystemSupport.FileOpen(name, "wb");
                if (!TypeSupport.ToBoolean(f))
                {
                    throw new InvalidOperationException("Unable to create output file: " + name);
                }
                var writer = new StreamWriter(f, FPdf.PrivateEncoding);
                writer.Write(document.Buffer);
                writer.Close();
                break;

            case OutputDevice.ReturnAsString:
                return(document.Buffer);

            default:
                throw new InvalidOperationException("Incorrect output destination: " + destination);
                break;
            }
            return(string.Empty);
        }
        private ILType CreateTypeInternal(ITypeSymbol symbol)
        {
            var pointerSymbol = symbol as PointerSymbol;

            if (pointerSymbol != null)
            {
                var element = GetTypeInternal(pointerSymbol.Element);
                if (element == null)
                {
                    return(null);
                }
                var type = element.CreatePointerType();
                return(CacheTypeInternal(type));
            }

            var refSymbol = symbol as RefSymbol;

            if (refSymbol != null)
            {
                var element = GetTypeInternal(refSymbol.Element);
                if (element == null)
                {
                    return(null);
                }
                var type = element.CreateByRefType();
                return(CacheTypeInternal(type));
            }

            var arraySymbol = symbol as ArraySymbol;

            if (arraySymbol != null)
            {
                var element = GetTypeInternal(arraySymbol.Element);
                if (element == null)
                {
                    return(null);
                }
                var type = element.CreateArrayType(arraySymbol.Rank);
                return(CacheTypeInternal(type));
            }

            var genericSymbol = symbol as GenericSymbol;

            if (genericSymbol != null)
            {
                var elementType = GetTypeInternal(genericSymbol.Element);
                if (elementType == null)
                {
                    return(null);
                }

                var genericArugments = new FastList <ILType>(genericSymbol.GenericParameters.Count);
                foreach (var generic in genericSymbol.GenericParameters)
                {
                    var genericType = GetTypeInternal(generic);
                    if (genericType == null)
                    {
                        return(null);
                    }
                    genericArugments.Add(genericType);
                }

                var type = elementType.CreateGenericType(genericArugments);
                return(CacheTypeInternal(type));
            }

            var nameSymbol = symbol as NameSymbol;

            if (nameSymbol != null)
            {
                var clr = TypeSupport.GetType(nameSymbol.AssemblyQualifiedName);
                if (clr == null)
                {
                    return(null);
                }
                var type = CLRType.Create(clr, this);
                return(CacheTypeInternal(type));
            }
            return(null);
        }