[Delphi] C Structs met IF statements naar packed record

[Parcye]

Ik ben bezig met een project om data om te zetten naar CSV zodat deze op internet geimporteerd kan worden. Het project wordt in Delphi gemaakt, maar ik heb in C wat structs die gebruikt (en dus omgezet moeten worden).

C:

struct CString
{
    unsigned int m_uiStringSize;
    if (m_uiStringSize > 0)
    {
        wchar_t *m_pString[m_uiStringSize + 1];
    }
};

Dit is omgezet naar het volgende...

Delphi:

RString = packed record
    StringSize: integer;
    TheString: record end;
    {TheString: array[1..StringSize*2+2] of char}
end;

Ik kan echter de waarde van 'TheString' niet benaderen.

Verder heb ik meer structs met een 'if' er in verwerkt. Voorbeeld:

C:

struct CContract
{
    unsigned char ContractType;
    if (ContractType == 1)
    {
        CDatum ContractEinde;
    }
    if (ContractType == 2)
    {
        CString Naam;
        CDatum ContractEinde;
    }
};

Volgens mij is dit niet te veranderen door een 'case of' situatie, omdat de record/struct een andere lengte heeft afhankelijk van ContractType.

Iemand die mij opweg kan helpen naar het omzetten van deze structs naar packed records?

[.oisyn]

Nou ben ik benieuwd welke C compiler jouw C code toelaat, maar ik gok dat het pseudocode is. De tweede case zou zijn:

C:

struct CContract
{
    unsigned char ContractType;
    union
    {
        struct
        {
            CDatum ContractEinde; 
        } type1;

        struct
        {
            CString Naam; 
            CDatum ContractEinde; 
        } type2;
    };
};

Geen idee of Delphi een variant voor union heeft, maar anders zou je het met verschillende structs aan kunnen pakken.

Het eerste probleem kun je natuurlijk gewoon oplossen met een array van lengte 1. Die 'record end' gaat natuurlijk niet werken omdat TheString dan geen type heeft.

[ Voor 13% gewijzigd door .oisyn op 25-09-2006 17:49 ]

[Parcye]

Het record werkt in Delphi wel, hij leest ook de juist bytes in, ik kan ze echter niet meer benaderen. Maar met 'case ... of' kun je in Delphi de union nabootsen, echter heb ik begrepen dat alle types de zelfde lengte moeten hebben.

In eerste instantie dacht ik zelf ook de de C code psuedocode is/was, maar het schijnt te werken. Zelf heb ik geen C omgeving meer om het mee te testen.

[ Voor 25% gewijzigd door Parcye op 25-09-2006 18:16 ]

[.oisyn]

maar het schijnt te werken

Het is iig geen standaard C/C++

[Creepy]

Parcye schreef op maandag 25 september 2006 @ 16:16:

Delphi:

RString = packed record
    StringSize: integer;
    TheString: record end;
    {TheString: array[1..StringSize*2+2] of char}
end;

TheString is nu een leeg record, dus dat je die niet kan benadering is niet zo vreemd.
Een *char of char[] kan in Delphi ook worden gebruikt alleen is het Delphi type dan pchar.

Maar ik denk dat je beter direct de code kan omschrijven naar een echt native Delphi iets. Een CString is "gewoon" een struct of class om een string te benaderen, iets wat Pascal/Delphi al standaard heeft. Voor het inlezen van een CVS bestand heb je die struct omgezet naar Delphi echt niet nodig.

[ Voor 26% gewijzigd door Creepy op 25-09-2006 18:58 ]

[Parcye]

Het is geen CSV bestand dat ingelezen moet worden maar een .dat bestand met een custom format. Ik wil de data inlezen en omzetten naar CSV.

Dus ik zal hoe dan ook een packed record moeten gebruiken om het in te lezen.

[LordLarry]

Neehoor, je kan ook gewoon stukje voor stukje of byte voor byte inlezen. En waarom probeer je niet eens hoe ver je met de case records in Delphi komt? De rest kan je dan stukje voor stukje doen.

[Parcye]

Maar maakt dat het niet gelijk erg traag? Als je byte voor byte gaat inlezen en plaatsen....

Als je de structuur weet... kun je toch beter op die manier inlezen?

[LordLarry]

Ja, dat zou iets sneller zijn. Ik beid je een oplossing die werkt, maar je mag ook nog verder zoeken naar een snellere oplossing die misschien helemaal niet bestaat.

[Tomatoman]

Er is in Delphi een subtiel verschil tussen de twee onderstaande records:

Delphi:

type
  TShapeList = (Rectangle, Triangle, Circle, Ellipse, Other);

  TFigure1 = record
    case TShapeList of
         Rectangle: (Height, Width: Real);
         Triangle: (Side1, Side2, Angle: Real);
         Circle: (Radius: Real);
         Ellipse, Other: ();
  end;

  TFigure2 = record
    case TheShape: TShapeList of
         Rectangle: (Height, Width: Real);
         Triangle: (Side1, Side2, Angle: Real);
         Circle: (Radius: Real);
         Ellipse, Other: ();
  end;

Het verschil tussen TFigure1 en TFigure 2 is dat er bij TFigure1 geen ruimte in de record is gealloceerd voor het element TheShape en bij TFigure2 wel. De tweede record is daarom precies de grootte van TShapeList groter dan de eerste record.

Je kunt ook zien dat afhankelijk van de gekozen shape er 0, 1, 2 of 3 reals in de record worden opgeslagen. De grootte van de record is eenvoudigweg de maximale grootte die nodig is om alle elementen op te nemen (dus 3 reals).

Verder nog een stuk tekst uit de help files:

A record type can have a variant part, which looks like a case statement. The variant part must follow the other fields in the record declaration.

To declare a record type with a variant part, use the following syntax.

Delphi:

type
  recordTypeName = record
       fieldList1: type1;
        ...
       fieldListn: typen;
       case tag: ordinalType of
          constantList1: (variant1);
          ...
          constantListn: (variantn);
     end;

The first part of the declaration - up to the reserved word case - is the same as that of a standard record type. The remainder of the declaration - from case to the optional final semicolon - is called the variant part. In the variant part,

• tag is optional and can be any valid identifier. If you omit tag, omit the colon ( after it as well.
• ordinalType denotes an ordinal type.
• Each constantList is a constant denoting a value of type ordinalType, or a comma-delimited list of such constants. No value can be represented more than once in the combined constantLists.
• Each variant is a semicolon-delimited list of declarations resembling the fieldList: type constructions in the main part of the record type. That is, a variant has the form
  
  Delphi:
  

  fieldList1: type1;
    ...
  fieldListn: typen;

  
  where each fieldList is a valid identifier or comma-delimited list of identifiers, each type denotes a type, and the final semicolon is optional. The types must not be long strings, dynamic arrays, variants (that is, Borland.Vcl.Variants.Variant types), or interfaces, nor can they be structured types that contain long strings, dynamic arrays, variants, or interfaces; but they can be pointers to these types.

[Parcye]

Ik ben er achter waar mijn voorbeeld code vanaf komt, dat is een bin template van de 010 editor.