Präprozessor(?): Zeichen in Zeichenkette ersetzen

[Otto Normalverbraucher (Gast)]

Ich habe ein Display mit einem "komischen" Zeichensatz. Alphanumerische 
Zeichen (0..9, a..Z) sind ok, aber bei öäü gibt es Vertauschungen mit 
anderen Sonderzeichen.

Ich habe bei den Zeichenketten, die ich ins Flash lege, bisher immer 
statt z.B.

const __flash char TEST = "Töfftöff";

sowas geschrieben:

const __flash char TEST = "T%fft%ff";

So funktioniert das natürlich, ist aber eher unschön. Ich suche nach 
einer automatischen Lösung.
Eine Alternative ist natürlich, die Zeichen zur Laufzeit in der 
Displayroutine einzeln ersetzen zu lassen, was aber unnötig Rechenzeit 
und Flash kostet. Sowas müsste doch eigentlich auch zur Compilezeit bzw. 
im Präprozessor gehen? Hat jemand Tipps?

[Otto Normalverbraucher (Gast)]

Achso, avr-gcc.

[Rolf M. (rmagnus)]

Ist es denn irgendein Standard-Zeichensatz? Dann könntest du den im gcc 
als execution character set einstellen.

[Otto Normalverbraucher (Gast)]

Standard ist da leider gar nichts. Da liegen u.a. auch japanische 
Zeichen zwischen den Umlauten usw.

[Johann L. (gjlayde)]

Otto Normalverbraucher schrieb:

Und sowas?

>#define oe "\x8a"
> const __flash char Toeff_Toeff[] = "T"oe"fft"oe"ff";

[Markus F. (mfro)]

Wenn Du weißt, welchen Zeichencode Du ausgeben willst, wieso schreibst 
Du ihn nicht einfach hin?

const char *leberkaes = "Leberk\x84s";
const char *knoedel = "Kn\x94del";

[Otto Normalverbraucher (Gast)]

Ich möchte die Texte einfach auf natürliche Art und Weise schreiben. 
Ohne Sonderzeichen dazwischen, ohne \x-Verrenkungen. Wenn ich "Sülze" 
ausgeben will, möchte ich "Sülze" schreiben.

[g457 (Gast)]

..besser wartbar wirds mit ein paar lesbaren Defines, z.B. sowas in der 
Art:

#define sAUML  "\x84"
#define sOUML  "\x94"

const char* const pLeberkaes = "Leberk" sAUML "se";
const char* const pKnoedel   = "Kn" sOUML "del";

> Wenn ich "Sülze" ausgeben will, möchte ich "Sülze" schreiben.

Textersetzung pre-compile-Event oder zur Laufzeit machen. Hat aber alles 
Vor- und Nachteile, such Dir aus, welche Du haben willst.

[Markus F. (mfro)]

Otto Normalverbraucher schrieb:
> Ohne Sonderzeichen dazwischen, ohne \x-Verrenkungen. Wenn ich "Sülze"
> ausgeben will, möchte ich "Sülze" schreiben.

Ich möcht' auch viel. Manchmal muß man halt mit dem zufrieden sein, was 
man kriegt ;).

Du kannst natürlich auch dein komisches Display wegschmeissen und dir 
eins kaufen, das mit Sonderzeichen besser umgehen kann.

Wenn's dir das wert ist.

[Tom (Gast)]

Otto Normalverbraucher schrieb:
> as aber unnötig Rechenzeit
> und Flash kostet.

Ist der Display-Code so laufzeitrelevant, dass das so schlimm wäre? Ich 
kenne deine Anwendung nicht, aber für ein paar Statusmeldungen auf einem 
Display kann man sich für jedes Zeichen durchaus ein switch-case mit
8 Möglichkeiten (ÄÖÜäöüß, default) leisten. Das ist immer noch um einige 
Größenordnungen schneller, als man lesen kann.

[Johann L. (gjlayde)]

Und wie wär's mit Fallunterscheidungen in der Ausgaberoutine?

extern void real_write_c (char);

static char map_uml (char c)
{
    switch (c)
    {
        default: break;
        case 'ä': c = '\x12'; break;
        case 'ö': c = '\x8f'; break;
        ...
    }
    return c;
}

void write_c (char c)
{
    real_write_c (map_ump (c));
}

[MitLeser (Gast)]

im Sourcecode-Text ganz normal schreiben damit man es
auch vernünftig lesen kann.
In der LcdWriteChar() die Umlaute, Sonderzeichen etc. bei
der Ausgabe durch die entsprechenden Werte des LCD-Zeichensatzes
ersetzen.

[MitLeser (Gast)]

schade war zu spät :-)
Johann L. hat es auf den Punkt gebracht.

[Niklas G. (erlkoenig)]

In C++11 gehts auch ganz ohne Präprozessor:

#include <cstddef>
#include <array>
#include <cstdio>

template <typename T, T... I>
struct IntegerSequence {
  using value_type = T;
  static constexpr size_t size () { return sizeof... (I); }
};

namespace Helper {
  template <typename T, typename S1, typename S2>
  struct ConcatSequence;

  template <typename T, T... S1, T... S2>
  struct ConcatSequence<T, IntegerSequence<T, S1...>, IntegerSequence<T, S2...>> {
    using type = IntegerSequence<T, S1..., (sizeof...(S1) + S2)...>;
  };

  template <typename T, T N, bool isZero, bool isOne>
  struct GenSeqI;
}
template <typename T, T N>
using GenSeq = typename Helper::GenSeqI<T, N, N == 0, N == 1>::type;

namespace Helper {
  template <typename T, T N>
  struct GenSeqI<T, N, false, false> {
    using type = typename ConcatSequence<T, GenSeq<T, N/2>, GenSeq<T, N-N/2>>::type;
  };
  template <typename T, T N>
  struct GenSeqI<T, N, true, false> {
    using type = IntegerSequence<T>;
  };
  template <typename T, T N>
  struct GenSeqI<T, N, false, true> {
    using type = IntegerSequence<T, 0>;
  };
}

inline constexpr char replace (char value) {
  return
    value == 'ö' ? 'o' :
    value == 'ä' ? 'a' :
    value == 'ü' ? 'u' :
    value;
}

template <size_t N, size_t... I>
inline constexpr const std::array<char, N> replace (const char (&str) [N], IntegerSequence<size_t, I...>*) {
  return {{ replace (str [I])... }};
}

template <size_t N>
inline constexpr const std::array<char, N> replace (const char (&str) [N]) {
  return replace<N> (str, static_cast<GenSeq<size_t, N>*> (nullptr));
}

/// ----------

constexpr auto myString1 = replace ("Hällö Leüte");

int main () {
  puts (myString1.data ());
}

Hier werden testweise Umlaute durch die normalen Vokale ersetzt, das 
kannst du dann deinen Bedürfnissen anpassen. Die Ersetzung erfolgt zur 
Compile-Zeit und im Programm landet der fertig verarbeitete String. Zum 
Kompilieren sollte dieser Code als ISO-8859-15 gespeichert werden, denn 
bei UTF-8 nehmen Umlaute mehrere Bytes ein und 'ä' funktioniert nicht 
mehr.

Wichtig ist dass pro String-Literal eine globale/statische Variable 
(hier myString1) angelegt wird, auf der man dann später .data() aufrufen 
kann um den "const char*" zu erhalten.
Einfach nur replace ("...").data() funktioniert nicht.

[Johann L. (gjlayde)]

Niklas G. schrieb:
> In C++11 gehts auch ganz ohne Präprozessor:

Boah, wer will solchen Monstercode lesen, pflegen oder verstehen?

Und mit avr-gcc übersetzbar ist er auch nicht...

[Klaus (Gast)]

Vielleicht fällt ja noch jemandem was ein, wenn der TO mal die 
Bezeichnung des Dipslays postet - oder sogar so nett ist und das 
Datenblatt verlinkt.

[Niklas G. (erlkoenig)]

Johann L. schrieb:
> Boah, wer will solchen Monstercode lesen, pflegen oder verstehen?
Nicht so schlimm wenn man C++ kann.
> Und mit avr-gcc übersetzbar ist er auch nicht...
Stimmt, weil dem AVR-GCC ein paar C++ Header Files fehlen. Im Anhang 
eine Version die std::array nachbildet und auch mit dem AVR-GCC 
funktioniert, und für die Grundlagen die C-Header verwendet.

Habe außerdem noch ein Makro hinzugefügt das Lambdas missbraucht um die 
Verwendung zu vereinfachen (doch keine globale Variable nötig):

puts (LCD_REPLACE_STR("Hällö Leüte"));

[Klaus (Gast)]

Ansonsten hätte ich einfach mal einen Perl-Script geschrieben, der die 
Zeichen ersetzt. Die Strings einfach in eine separate Header-Datei 
schreiben und mit dem Script die relevanten Zeichen ersetzen.

(sed, awk und Konsorten gingen natürlich auch).