compiler/libec/pass15: (#276) Fixed computation of bit classes

ecere · May 21, 2014 · d3a2010 · d3a2010
1 parent 3f337a9
commit d3a2010
Show file tree

Hide file tree

Showing 2 changed files with 44 additions and 81 deletions.
diff --git a/compiler/bootstrap/libec/bootstrap/pass15.c b/compiler/bootstrap/libec/bootstrap/pass15.c
@@ -11421,9 +11421,8 @@ else if(dataMember)
 {
 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)dataMember;
 struct Type * type;
-int part = 0;
+uint64 part;
 
-GetInt(value, &part);
 bits = (bits & ~bitMember->mask);
 if(!bitMember->dataType)
 bitMember->dataType = ProcessTypeString(bitMember->dataTypeString, 0x0);
@@ -11438,52 +11437,57 @@ switch(type->kind)
 {
 case 24:
 case 1:
-if(type->isSigned)
-bits |= ((char)part << bitMember->pos);
-else
-bits |= ((unsigned char)part << bitMember->pos);
+{
+unsigned char v;
+
+type->isSigned ? GetChar(value, &v) : GetUChar(value, &v);
+part = (uint64)v;
 break;
+}
 case 2:
-if(type->isSigned)
-bits |= ((short)part << bitMember->pos);
-else
-bits |= ((unsigned short)part << bitMember->pos);
+{
+unsigned short v;
+
+type->isSigned ? GetShort(value, &v) : GetUShort(value, &v);
+part = (uint64)v;
 break;
+}
 case 3:
 case 5:
-if(type->isSigned)
-bits |= (part << bitMember->pos);
-else
-bits |= ((unsigned int)part << bitMember->pos);
+{
+unsigned int v;
+
+type->isSigned ? GetInt(value, &v) : GetUInt(value, &v);
+part = (uint64)v;
 break;
+}
 case 4:
-if(type->isSigned)
-bits |= ((long long)part << bitMember->pos);
-else
-bits |= ((uint64)part << bitMember->pos);
-break;
-case 22:
-if(type->isSigned)
 {
-bits |= ((intptr_t)part << bitMember->pos);
+uint64 v;
+
+type->isSigned ? GetInt64(value, &v) : GetUInt64(value, &v);
+part = v;
+break;
 }
-else
+case 22:
 {
-bits |= ((uintptr_t)part << bitMember->pos);
-}
+intptr_t v;
+
+type->isSigned ? GetIntPtr(value, &v) : GetUIntPtr(value, &v);
+part = (uint64)v;
 break;
-case 23:
-if(type->isSigned)
-{
-bits |= ((ssize_t)part << bitMember->pos);
 }
-else
+case 23:
 {
-bits |= ((size_t)part << bitMember->pos);
-}
+ssize_t v;
+
+type->isSigned ? GetIntSize(value, &v) : GetUIntSize(value, &v);
+part = (uint64)v;
 break;
 }
 }
+bits += part << bitMember->pos;
+}
 }
 }
 else

diff --git a/compiler/libec/src/pass15.ec b/compiler/libec/src/pass15.ec
@@ -5021,70 +5021,29 @@ void ComputeInstantiation(Expression exp)
                            {
                               BitMember bitMember = (BitMember) dataMember;
                               Type type;
-                              int part = 0;
-                              GetInt(value, &part);
+                              uint64 part;
                               bits = (bits & ~bitMember.mask);
                               if(!bitMember.dataType)
                                  bitMember.dataType = ProcessTypeString(bitMember.dataTypeString, false);
-
                               type = bitMember.dataType;
-
                               if(type.kind == classType && type._class && type._class.registered)
                               {
                                  if(!type._class.registered.dataType)
                                     type._class.registered.dataType = ProcessTypeString(type._class.registered.dataTypeString, false);
                                  type = type._class.registered.dataType;
                               }
-
                               switch(type.kind)
                               {
                                  case _BoolType:
-                                 case charType:
-                                    if(type.isSigned)
-                                       bits |= ((char)part << bitMember.pos);
-                                    else
-                                       bits |= ((unsigned char)part << bitMember.pos);
-                                    break;
-                                 case shortType:
-                                    if(type.isSigned)
-                                       bits |= ((short)part << bitMember.pos);
-                                    else
-                                       bits |= ((unsigned short)part << bitMember.pos);
-                                    break;
+                                 case charType:       { byte v; type.isSigned ? GetChar(value, &v) : GetUChar(value, &v); part = (uint64)v; break; }
+                                 case shortType:      { uint16 v; type.isSigned ? GetShort(value, &v) : GetUShort(value, &v); part = (uint64)v; break; }
                                  case intType:
-                                 case longType:
-                                    if(type.isSigned)
-                                       bits |= ((int)part << bitMember.pos);
-                                    else
-                                       bits |= ((unsigned int)part << bitMember.pos);
-                                    break;
-                                 case int64Type:
-                                    if(type.isSigned)
-                                       bits |= ((int64)part << bitMember.pos);
-                                    else
-                                       bits |= ((uint64)part << bitMember.pos);
-                                    break;
-                                 case intPtrType:
-                                    if(type.isSigned)
-                                    {
-                                       bits |= ((intptr)part << bitMember.pos);
-                                    }
-                                    else
-                                    {
-                                       bits |= ((uintptr)part << bitMember.pos);
-                                    }
-                                    break;
-                                 case intSizeType:
-                                    if(type.isSigned)
-                                    {
-                                       bits |= ((ssize_t)(intsize)part << bitMember.pos);
-                                    }
-                                    else
-                                    {
-                                       bits |= ((size_t) (uintsize)part << bitMember.pos);
-                                    }
-                                    break;
+                                 case longType:       { uint v; type.isSigned ? GetInt(value, &v) : GetUInt(value, &v); part = (uint64)v; break; }
+                                 case int64Type:      { uint64 v; type.isSigned ? GetInt64(value, &v) : GetUInt64(value, &v); part = (uint64)v; break; }
+                                 case intPtrType:     { intptr v; type.isSigned ? GetIntPtr(value, &v) : GetUIntPtr(value, &v); part = (uint64)v; break; }
+                                 case intSizeType:    { intsize v; type.isSigned ? GetIntSize(value, &v) : GetUIntSize(value, &v); part = (uint64)v; break; }
                               }
+                              bits += part << bitMember.pos;
                            }
                         }
                      }