Beispiel #1
0
 public FieldHashConflict(int hash, string name, object @value, global::haxe.lang.FieldHashConflict next)
 {
     this.hash   = hash;
     this.name   = name;
     this.@value = @value;
     this.next   = next;
 }
Beispiel #2
0
        public static bool deleteHashConflict(ref global::haxe.lang.FieldHashConflict head, int hash, string name)
        {
            if ((head == null))
            {
                return(false);
            }

            if (((head.hash == hash) && (head.name == name)))
            {
                head = ((global::haxe.lang.FieldHashConflict)(head.next));
                return(true);
            }

            global::haxe.lang.FieldHashConflict prev = head;
            global::haxe.lang.FieldHashConflict node = head.next;
            while ((node != null))
            {
                if (((node.hash == hash) && (node.name == name)))
                {
                    prev.next = node.next;
                    return(true);
                }

                node = node.next;
            }

            return(false);
        }
Beispiel #3
0
        public override object __hx_getField(string field, int hash, bool throwErrors, bool isCheck, bool handleProperties)
        {
            if ((hash < 0))
            {
                global::haxe.lang.FieldHashConflict conflict = global::haxe.lang.FieldLookup.getHashConflict(this.__hx_conflicts, hash, field);
                if ((conflict != null))
                {
                    return(conflict.@value);
                }
            }

            int res = global::haxe.lang.FieldLookup.findHash(hash, this.__hx_hashes, this.__hx_length);

            if ((res >= 0))
            {
                return(this.__hx_dynamics[res]);
            }

            res = global::haxe.lang.FieldLookup.findHash(hash, this.__hx_hashes_f, this.__hx_length_f);
            if ((res >= 0))
            {
                return(this.__hx_dynamics_f[res]);
            }

            if (isCheck)
            {
                return(global::haxe.lang.Runtime.undefined);
            }
            else
            {
                return(null);
            }
        }
Beispiel #4
0
        public override double __hx_getField_f(string field, int hash, bool throwErrors, bool handleProperties)
        {
                        #line 147 "/opt/haxe/std/cs/internal/HxObject.hx"
            if ((hash < 0))
            {
                                #line 148 "/opt/haxe/std/cs/internal/HxObject.hx"
                global::haxe.lang.FieldHashConflict conflict = global::haxe.lang.FieldLookup.getHashConflict(this.__hx_conflicts, hash, field);
                if ((conflict != null))
                {
                                        #line 150 "/opt/haxe/std/cs/internal/HxObject.hx"
                    return((double)(global::haxe.lang.Runtime.toDouble(conflict.@value)));
                }
            }

                        #line 154 "/opt/haxe/std/cs/internal/HxObject.hx"
            int res = global::haxe.lang.FieldLookup.findHash(hash, this.__hx_hashes_f, this.__hx_length_f);
            if ((res >= 0))
            {
                                #line 156 "/opt/haxe/std/cs/internal/HxObject.hx"
                return(this.__hx_dynamics_f[res]);
            }

                        #line 158 "/opt/haxe/std/cs/internal/HxObject.hx"
            res = global::haxe.lang.FieldLookup.findHash(hash, this.__hx_hashes, this.__hx_length);
            if ((res >= 0))
            {
                                #line 160 "/opt/haxe/std/cs/internal/HxObject.hx"
                return((double)(global::haxe.lang.Runtime.toDouble(this.__hx_dynamics[res])));
            }

                        #line 163 "/opt/haxe/std/cs/internal/HxObject.hx"
            return(0.0);
        }
Beispiel #5
0
        public override double __hx_getField_f(string field, int hash, bool throwErrors, bool handleProperties)
        {
            if ((hash < 0))
            {
                global::haxe.lang.FieldHashConflict conflict = global::haxe.lang.FieldLookup.getHashConflict(this.__hx_conflicts, hash, field);
                if ((conflict != null))
                {
                    return((double)(global::haxe.lang.Runtime.toDouble(conflict.@value)));
                }
            }

            int res = global::haxe.lang.FieldLookup.findHash(hash, this.__hx_hashes_f, this.__hx_length_f);

            if ((res >= 0))
            {
                return(this.__hx_dynamics_f[res]);
            }

            res = global::haxe.lang.FieldLookup.findHash(hash, this.__hx_hashes, this.__hx_length);
            if ((res >= 0))
            {
                return((double)(global::haxe.lang.Runtime.toDouble(this.__hx_dynamics[res])));
            }

            return(0.0);
        }
Beispiel #6
0
 public static void addHashConflictNames(global::haxe.lang.FieldHashConflict head, global::haxe.root.Array <object> arr)
 {
     while ((head != null))
     {
         arr.push(head.name);
         head = head.next;
     }
 }
 public FieldHashConflict(int hash, string name, object @value, global::haxe.lang.FieldHashConflict next)
 {
                 #line 34 "/opt/haxe/std/cs/internal/FieldLookup.hx"
     this.hash = hash;
     this.name = name;
                 #line 36 "/opt/haxe/std/cs/internal/FieldLookup.hx"
     this.@value = @value;
     this.next   = next;
 }
Beispiel #8
0
 public FieldHashConflict(int hash, string name, object @value, global::haxe.lang.FieldHashConflict next)
 {
                 #line 34 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
     this.hash = hash;
     this.name = name;
                 #line 36 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
     this.@value = @value;
     this.next   = next;
 }
Beispiel #9
0
 public static void addHashConflictNames(global::haxe.lang.FieldHashConflict head, global::Array <string> arr)
 {
                 #line 306 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
     while ((head != null))
     {
                         #line 307 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
         arr.push(head.name);
         head = head.next;
     }
 }
 public static void addHashConflictNames(global::haxe.lang.FieldHashConflict head, global::Array <string> arr)
 {
                 #line 306 "/opt/haxe/std/cs/internal/FieldLookup.hx"
     while ((head != null))
     {
                         #line 307 "/opt/haxe/std/cs/internal/FieldLookup.hx"
         arr.push(head.name);
         head = head.next;
     }
 }
Beispiel #11
0
        public static global::haxe.lang.FieldHashConflict getHashConflict(global::haxe.lang.FieldHashConflict head, int hash, string name)
        {
            while ((head != null))
            {
                if (((head.hash == hash) && (head.name == name)))
                {
                    return(head);
                }

                head = head.next;
            }

            return(null);
        }
Beispiel #12
0
        public static void setHashConflict(ref global::haxe.lang.FieldHashConflict head, int hash, string name, object @value)
        {
            global::haxe.lang.FieldHashConflict node = head;
            while ((node != null))
            {
                if (((node.hash == hash) && (node.name == name)))
                {
                    node.@value = @value;
                    return;
                }

                node = ((global::haxe.lang.FieldHashConflict)(node.next));
            }

            head = ((global::haxe.lang.FieldHashConflict)(new global::haxe.lang.FieldHashConflict(hash, name, @value, ((global::haxe.lang.FieldHashConflict)(head)))));
        }
        public static global::haxe.lang.FieldHashConflict getHashConflict(global::haxe.lang.FieldHashConflict head, int hash, string name)
        {
                        #line 258 "/opt/haxe/std/cs/internal/FieldLookup.hx"
            while ((head != null))
            {
                                #line 259 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                if (((head.hash == hash) && (head.name == name)))
                {
                                        #line 260 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                    return(head);
                }

                                #line 262 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                head = head.next;
            }

                        #line 264 "/opt/haxe/std/cs/internal/FieldLookup.hx"
            return(null);
        }
Beispiel #14
0
        public static global::haxe.lang.FieldHashConflict getHashConflict(global::haxe.lang.FieldHashConflict head, int hash, string name)
        {
                        #line 258 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
            while ((head != null))
            {
                                #line 259 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                if (((head.hash == hash) && (head.name == name)))
                {
                                        #line 260 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                    return(head);
                }

                                #line 262 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                head = head.next;
            }

                        #line 264 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
            return(null);
        }
Beispiel #15
0
        public override object __hx_getField(string field, int hash, bool throwErrors, bool isCheck, bool handleProperties)
        {
                        #line 99 "/opt/haxe/std/cs/internal/HxObject.hx"
            if ((hash < 0))
            {
                                #line 100 "/opt/haxe/std/cs/internal/HxObject.hx"
                global::haxe.lang.FieldHashConflict conflict = global::haxe.lang.FieldLookup.getHashConflict(this.__hx_conflicts, hash, field);
                if ((conflict != null))
                {
                                        #line 102 "/opt/haxe/std/cs/internal/HxObject.hx"
                    return(conflict.@value);
                }
            }

                        #line 106 "/opt/haxe/std/cs/internal/HxObject.hx"
            int res = global::haxe.lang.FieldLookup.findHash(hash, this.__hx_hashes, this.__hx_length);
            if ((res >= 0))
            {
                                #line 108 "/opt/haxe/std/cs/internal/HxObject.hx"
                return(this.__hx_dynamics[res]);
            }

                        #line 110 "/opt/haxe/std/cs/internal/HxObject.hx"
            res = global::haxe.lang.FieldLookup.findHash(hash, this.__hx_hashes_f, this.__hx_length_f);
            if ((res >= 0))
            {
                                #line 112 "/opt/haxe/std/cs/internal/HxObject.hx"
                return(this.__hx_dynamics_f[res]);
            }

                        #line 115 "/opt/haxe/std/cs/internal/HxObject.hx"
            if (isCheck)
            {
                                #line 115 "/opt/haxe/std/cs/internal/HxObject.hx"
                return(global::haxe.lang.Runtime.undefined);
            }
            else
            {
                                #line 115 "/opt/haxe/std/cs/internal/HxObject.hx"
                return(null);
            }
        }
Beispiel #16
0
        public static void setHashConflict(ref global::haxe.lang.FieldHashConflict head, int hash, string name, object @value)
        {
                        #line 268 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
            global::haxe.lang.FieldHashConflict node = head;
            while ((node != null))
            {
                                #line 270 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                if (((node.hash == hash) && (node.name == name)))
                {
                                        #line 271 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                    node.@value = @value;
                    return;
                }

                                #line 274 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                node = ((global::haxe.lang.FieldHashConflict)(node.next));
            }

                        #line 276 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
            head = ((global::haxe.lang.FieldHashConflict)(new global::haxe.lang.FieldHashConflict(hash, name, @value, ((global::haxe.lang.FieldHashConflict)(head)))));
        }
        public static void setHashConflict(ref global::haxe.lang.FieldHashConflict head, int hash, string name, object @value)
        {
                        #line 268 "/opt/haxe/std/cs/internal/FieldLookup.hx"
            global::haxe.lang.FieldHashConflict node = head;
            while ((node != null))
            {
                                #line 270 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                if (((node.hash == hash) && (node.name == name)))
                {
                                        #line 271 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                    node.@value = @value;
                    return;
                }

                                #line 274 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                node = ((global::haxe.lang.FieldHashConflict)(node.next));
            }

                        #line 276 "/opt/haxe/std/cs/internal/FieldLookup.hx"
            head = ((global::haxe.lang.FieldHashConflict)(new global::haxe.lang.FieldHashConflict(hash, name, @value, ((global::haxe.lang.FieldHashConflict)(head)))));
        }
Beispiel #18
0
        public static bool deleteHashConflict(ref global::haxe.lang.FieldHashConflict head, int hash, string name)
        {
                        #line 281 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
            if ((head == null))
            {
                                #line 282 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                return(false);
            }

                        #line 286 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
            if (((head.hash == hash) && (head.name == name)))
            {
                                #line 287 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                head = ((global::haxe.lang.FieldHashConflict)(head.next));
                return(true);
            }

                        #line 292 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
            global::haxe.lang.FieldHashConflict prev = head;
                        #line 292 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
            global::haxe.lang.FieldHashConflict node = head.next;
            while ((node != null))
            {
                                #line 294 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                if (((node.hash == hash) && (node.name == name)))
                {
                                        #line 295 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                    prev.next = node.next;
                    return(true);
                }

                                #line 298 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
                node = node.next;
            }

                        #line 302 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\FieldLookup.hx"
            return(false);
        }
        public static bool deleteHashConflict(ref global::haxe.lang.FieldHashConflict head, int hash, string name)
        {
                        #line 281 "/opt/haxe/std/cs/internal/FieldLookup.hx"
            if ((head == null))
            {
                                #line 282 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                return(false);
            }

                        #line 286 "/opt/haxe/std/cs/internal/FieldLookup.hx"
            if (((head.hash == hash) && (head.name == name)))
            {
                                #line 287 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                head = ((global::haxe.lang.FieldHashConflict)(head.next));
                return(true);
            }

                        #line 292 "/opt/haxe/std/cs/internal/FieldLookup.hx"
            global::haxe.lang.FieldHashConflict prev = head;
                        #line 292 "/opt/haxe/std/cs/internal/FieldLookup.hx"
            global::haxe.lang.FieldHashConflict node = head.next;
            while ((node != null))
            {
                                #line 294 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                if (((node.hash == hash) && (node.name == name)))
                {
                                        #line 295 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                    prev.next = node.next;
                    return(true);
                }

                                #line 298 "/opt/haxe/std/cs/internal/FieldLookup.hx"
                node = node.next;
            }

                        #line 302 "/opt/haxe/std/cs/internal/FieldLookup.hx"
            return(false);
        }