Automatisch Code generieren

[Zacherl]

Hallo zusammen,

in einem aktuellen Projekt benötige ich die Funktionalität Code für verschiedene Sprachen zu generieren (vorerst vor allem C, C++ und Pascal). Hierbei geht es mir im Speziellen um die Initialisierung von konstanten Structs/Records und Arrays. Außerdem müssen Typ-Aliase und Enums deklariert werden können.

Gibt es hier vielleicht schon ein fertiges Framework?
Hat hier vielleicht schon jemand etwas Ähnliches mal gemacht und kann mir Tipps zum Klassendesign / zur Umsetzung geben?

Mein momentaner Entwurf ist eine TCodeWriter Klasse:

Delphi-Quellcode:

type
  TContainerType  = (Struct, &Class, Union, &Array);
  TOrdinalBase    = (Dec, Oct, Hex);
  TSymbolModifier = (Default, Pointer, Reference);
  TStorageClass   = (Default, Auto, Register, Static, Extern);

  TCodeWriter = class abstract(TObject)
  strict private
    FWriter: TTextWriter;
    FIndent: Integer;
    FIndentString: String;
  public
    procedure IncIndent; virtual;
    procedure DecIndent; virtual;
    procedure WriteLine; virtual;
    procedure WriteIndent; inline;
    procedure WriteRaw(const AText: String); virtual; abstract;
    procedure WriteComment(const AComment: String); virtual; abstract;
    procedure WriteMultiLineComment(const AComment: String); virtual; abstract;
  public
    procedure WriteContainerBegin(AContainerType: TContainerType); virtual; abstract;
    procedure WriteContainerEnd; virtual; abstract;
    procedure WriteStructBegin; inline; // WriteContainerBegin(TContainerType.Struct)
    procedure WriteStructEnd; inline;   // WriteContainerEnd
    procedure WriteClassBegin; inline;  // WriteContainerBegin(TContainerType.Class)
    procedure WriteClassEnd; inline;    // WriteContainerEnd
    procedure WriteUnionBegin; inline;  // WriteContainerBegin(TContainerType.Union)
    procedure WriteUnionEnd; inline;    // WriteContainerEnd
    procedure WriteArrayBegin; inline;  // WriteContainerBegin(TContainerType.Array)
    procedure WriteArrayEnd; inline;    // WriteContainerEnd
  public
    procedure WriteSymbol(const ASymbol: String;
      AModifier: TSymbolModifier = TSymbolModifier.Default); virtual; abstract;

    // To be used in struct/class/union initializations only
    // Pascal: `AName:` | C/C++: `.AName =`
    procedure WriteFieldName(const AName: String); virtual; abstract;

    // To be used in struct/class/union/array initializations only
    procedure WriteValue(const AItem: String); overload; virtual; abstract;
    procedure WriteValue(AItem: Integer;
      AOrdinalBase: TOrdinalBase = TOrdinalBase.Dec); overload; virtual; abstract;
    procedure WriteValue(AItem: Boolean); overload; virtual; abstract;
    // ...
  public
    // Used to sum up multiple declarations in the same block (for languages like Pascal)
    procedure DeclarationBegin; virtual; abstract;
    procedure DeclarationEnd; virtual; abstract;

    // Strong = true  -> Pascal: `type AName = type AType` | C/C++: `typedef AType AName`
    // String = false -> Pascal: `type AName = AType`      | C/C++: `typedef AType AName`
    procedure WriteDeclareType(const AName, AType: String;
      StrongType: Boolean); virtual; abstract;

    // Strong = true  -> Pascal: `type AName = (`          | C/C++: `enum AName = {`
    // Strong = false -> Pascal: `type AName = (`          | C++  : `enum class AName : AType = {`
    procedure WriteDeclareEnum(const AName: String; const AType: String = '';
      StrongType: Boolean = true); virtual; abstract;
    procedure WriteEnumItem(const AName: String; AValue: Integer = 0;
      AOrdinalBase = TOrdinalBase.Dec); overload; virtual; abstract;
    procedure WriteEnumItem(const AName, ASymbol: String); overload; overload; virtual; abstract;
    // ...
  public
    // Used to sum up multiple constants in the same block (for languages like Pascal)
    procedure ConstantBegin(
      AStorageClass: TStorageClass = TStorageClass.Default); virtual; abstract;
    procedure ConstantEnd; virtual; abstract;

    procedure WriteDeclareConstant(const AName, AType: String); virtual; abstract;

    // Used to sum up multiple constants in the same block (for languages like Pascal)
    procedure VariableBegin(
      AStorageClass: TStorageClass = TStorageClass.Default); virtual; abstract;
    procedure VariableEnd; virtual; abstract;

    procedure WriteDeclareVariable(const AName, AType: String); virtual; abstract;
  strict protected
    constructor Create(AWriter: TTextWriter; AIndent, AInitialIndent: Integer); virtual;
  public
    destructor Destroy; override;
  public
    property Writer: TTextWriter read FWriter;
  end;

Konkrete Umsetzung ist dann leider etwas schwieriger, da ich alle Aktionen bei Ausführung erst auf Validität prüfen möchte. Dafür habe ich eine Kombination aus Stack und Statemachine ins Auge gefasst, was allerdings recht viel Aufwand ist, da die Logik für alle unterstützten Sprachen komplett individuell implementiert werden muss.

Viele Grüße
Zacherl