GENERATION DE L'EXPRESSION REGULIERE (REGEXP) POUR MANGER JUSQU'A UNE CHAINE

#include <string>
#include <iostream>

using namespace std;

static const string to_escape   = "^\\*+()[]{}$"; // Tous les caracteres qui ont besoin d'etre echapp?
static const char   escape_char = '\\';
static const string parent_open   = "(?:"; // Parenthese ouvrante non capturante pour ne pas gener les matchs, (en general "(?:")
static const char   parent_close  = ')';
static const char   bracket_open  = '[';
static const char   bracket_close = ']'; // A placer au debut de classe d'intervalle
static const char   bracket_not   = '^'; // Parfois egal a '!'

typedef string (*func)(const string& word, int length);

// Echappe simplement les caracteres
// Contrainte : length >= 1 && word.length >= length

static string ESCAPE(const string& word, int length)
{
  string res;

  for (int i = 0; i < length; ++i)
  {
    if (string::npos != to_escape.find(word[i]))
      res += escape_char;
    res += word[i];
  }
  return res;
}

// Appelle ESCAPE
// ET ajoute une subtilit?
// Contrainte : <les memes que ESCAPE>
static string WITH(const string& word, int length)
{
  string res = ESCAPE(word, length);
  return res.insert(1 + (res[0] == escape_char), 1, '+'); // LA petite subtilit? :)
}

// Permet de construire une regexp qui mange tout et s'arrete apres une chaine donn?e
// Exemple pour matcher un commentaire en c++ : "/*" + UNTIL("*/") + "*/"
// Facile non ?
static string UNTIL_WITH(const string& word)
{
  unsigned int n = word.length();
  string res = n > 1 ? parent_open : "";
  unsigned int i = 1;

  while (i < word.length() && word[0] == word[i])
      ++i;
  func Subtility = i < word.length() ? WITH : ESCAPE;

  // Optionnel, il s'agit d'un pronostic sur la taille probable
  // Ce pronostic optimise un peu ...
  // Le pronostic est inferieur ? la taille r?elle si des caract?res doivent etre echapp? !
  // Comptons les caracteres ( n == word.length() )
  // 1 : parenthese ouvrante
  // n - 1 : Nombre de '|'
  // n * 3 : Nombre de '[^]'
  // n * 2 - 1 : Nombre de caracteres dans les crochets
  // (n-1) * n / 2 + n -1 : Nombre de caracteres en dehors des crochets (somme de 0 a n - 1) et n-1 fois le '+'
  // 1 + 1 : parenthese fermante et etoile
  // n + 1 : Mot a manger a la fin avec le '+'
  // Soit au final :
  // {
   res.reserve((15 + n) * n / 2 + 1);
  // Version ou le pronostic >= taille reelle (considere que tous les caracteres ont besoin d'etre echapp?s) !
  // res.reserve((n + 9) * n);
  // }

  for (i = 0; i < n; ++i)
  {
    if (i)
    {
      res += '|';
      res += Subtility(word, i);
    }
    res += bracket_open;
    res += bracket_not;
    if (word[0] == word[i])
      res += word[i];
    else if (word[i] == bracket_close)
    {
      res += word[i];
      res += word[0];
    }
    else
    {
      res += word[0];
      res += word[i];
    }
    res += bracket_close;
  }
  if (n > 1)
    res += parent_close;
  res += '*' + Subtility(word, i);
  return res;
}

// M?me chose que UNTIL mais pour s'arreter apres la premiere des deux chaines trouv?e
// Cette fonction est la fonction de base permetant de construire des listes de chaines devant lesquelles s'arreter.
// ( Certes UNTIL avec S n'existe pas mais tant pis :p )
static string UNTILS_WITH(const string& word_1, const string& word_2)
{
  return parent_open + UNTIL_WITH(word_1) + "|" + UNTIL_WITH(word_2) + parent_close;
}






int main()
{
  cout << "Commentaire C++, php ... :" << endl;
=>cout << "/\\*" + UNTIL_WITH("*/") << endl;
  cout << endl;
  cout << endl;

  // Matcher un commentaire HTML selon la norme W3C
  // format : <!-- blablabla -- blablabla >
  // Et oui ! normalement -- et > ne sont pas forcement coll? :
  cout << "Commentaire HTML (selon la norme W3C) :" << endl;
  cout << "<!--" + UNTIL_WITH("--") + UNTIL_WITH(">") << endl;
  cout << endl;
  cout << endl;

  cout << "jusqu'a \"abc\" :" << endl;
  cout << UNTIL_WITH("abc") << endl;
  cout << endl;
  cout << endl;

  return EXIT_SUCCESS;
}