kverbos/kverbos/verbspanish.cpp

   1 /***************************************************************************
   2                           verbspanish.cpp  -  description
   3                              -------------------
   4     begin                : Sun Dec 23 2001
   5     copyright            : (C) 2001 by Arnold Kraschinski
   6     email                : arnold.k67@gmx.de
   7  ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 #include "verbspanish.h"
  19
  20 // include files for Qt
  21
  22 // application specific includes
  23
  24 endingsArray verbSpanish::verbEndings = { { {"o", "as", "a", "amos", "áis", "an"}, /* presente */
  25                           {"o", "es", "e", "emos", "éis", "en"},
  26                           {"o", "es", "e", "imos", "ís", "en"}},
  27                         { {"aba", "abas", "aba", "ábamos", "abais", "aban"}, /*imperfecto */
  28                           {"ía", "ías", "ía", "íamos", "íais", "ían"},
  29                           {"ía", "ías", "ía", "íamos", "íais", "ían"}},
  30                         { {"é", "aste", "ó", "amos", "asteis", "aron"}, /* indefinido */
  31                           {"í", "iste", "ió", "imos", "isteis", "ieron"},
  32                           {"í", "iste", "ió", "imos", "isteis", "ieron"}},
  33                         { {"é", "ás", "á", "emos", "éis", "án"}, /* futuro */
  34                           {"é", "ás", "á", "emos", "éis", "án"},
  35                           {"é", "ás", "á", "emos", "éis", "án"}},
  36                         { {"ía", "ías", "ía", "íamos", "íais", "ían"}, /* condicional */
  37                           {"ía", "ías", "ía", "íamos", "íais", "ían"},
  38                           {"ía", "ías", "ía", "íamos", "íais", "ían"}},
  39                         { {"e", "es", "e", "emos", "éis", "en"}, /* subjuntivo presente */
  40                           {"a", "as", "a", "amos", "áis", "an"},
  41                           {"a", "as", "a", "amos", "áis", "an"}},
  42                         { {"-", "-", "-", "-", "-", "-"}, /* subjuntivo pasado */
  43                           {"-", "-", "-", "-", "-", "-"},
  44                           {"-", "-", "-", "-", "-", "-"}},
  45                         { {"%", "%", "%", "%", "%", "%"}, /* subjuntivo futuro */
  46                           {"%", "%", "%", "%", "%", "%"},
  47                           {"%", "%", "%", "%", "%", "%"}},
  48                         { {"+", "+", "+", "+", "+", "+"}, /* imperativo */
  49                           {"+", "+", "+", "+", "+", "+"},
  50                           {"+", "+", "+", "+", "+", "+"}}
  51                       };
  52
  53 QString verbSpanish::refPron[PERSONEN] = {"me", "te", "se", "nos", "os", "se"};
  54 QString verbSpanish::estar[MAX_TIEMPOS][PERSONEN] =
  55                             { {"estoy", "estás", "está", "estamos", "estáis", "están"},
  56                               {"estaba", "estabas", "estaba", "estábamos", "estabais", "estaban"},
  57                               {"estuve", "estuviste", "estuvo", "estuvimos", "estuvisteis", "estuvieron"},
  58                               {"estaré", "estarás", "estará", "estaremos", "estaréis", "estarán"},
  59                               {"estaría", "estaría", "estaría", "estaríamos", "estarías", "estarían"},
  60                               {"esté", "estés", "esté", "estemos", "estéis", "estén"},
  61                               {"estuviera o estuviese", "estuvieras o stuvieses", "estuviera o estuviese",
  62                                "estuviéramos o estuviésemos", "estuvierais o estuvieseis", "estuvieran o estuviesen"},
  63                               {"estuviere", "estuvieres", "estuviere", "estuviéremos", "estuviereis", "estuvieren"},
  64                               {"", "está", "esté", "estemos", "estad", "estén"}
  65                             };
  66
  67 QString verbSpanish::haber[MAX_TIEMPOS][PERSONEN] =
  68                               { {"he", "has", "ha", "hemos", "habéis", "han"},
  69                               {"había", "habías", "había", "habíamos", "habíais", "habían"},
  70                               {"hube", "hubiste", "hubo", "hubimos", "hubisteis", "hubieron"},
  71                               {"habré", "habrás", "habrá", "habremos", "habréis", "habrán"},
  72                               {"habría", "habrías", "habría", "habríamos", "habríais", "habrían"},
  73                               {"haya", "hayas", "haya", "hayamos", "hayáis", "hayan"},
  74                               {"hubiera o hubiese", "hubieras o hubieses", "hubiera o hubiese",
  75                                "hubiéramos o hubiésemos", "hubierais o hubieseis", "hubieran o hubiesen"},
  76                               {"hubiere", "hubieres", "hubiere", "hubiéremos", "hubiereis", "hubieren"},
  77                               {"", "he", "haya", "hayamos", "habed", "hayan"}
  78                             };
  79
  80 QString verbSpanish::timeNames[MAX_TIEMPOS*MAX_SUBTYPES] =
  81                         {"presente", "imperfecto", "indefinido", "futuro", "condicional",
  82                          "subjuntivo presente", "subjuntivo pasado", "subjuntivo futuro", "imperativo",
  83                          "presente progresivo", "imperfecto progresivo", "indefinido progresivo", "futuro progresivo", "condicional progresivo",
  84                          "subjuntivo presente progresivo", "subjuntivo pasado progresivo", "subjuntivo futuro progresivo", "error:form doesn't exist",
  85                          "presente perfecto", "imperfecto perfecto", "error:form doesn't exist", "futuro perfecto", "condicional perfecto",
  86                          "subjuntivo presente perfecto", "subjuntivo pasado perfecto", "subjuntivo futuro perfecto", "error:form doesn't exist",
  87                         };
  88
  89 QString verbSpanish::groupNames[MAX_GRUPPEN] =
  90                         {"regular", "irregular", "e > ie", "o > ue", "u > ue", "e > i",
  91                          "c > qu",  "g > gu", "z > c", "gu > gü", "c > z", "g > j",
  92                          "gu > g",  "qu > c", "accent like 'enviar'",
  93                          "accent like 'continuar'", "missing i"};
  94
  95
  96 int verbSpanish::maxTiempos = MAX_TIEMPOS;
  97 int verbSpanish::maxSubtypes = MAX_SUBTYPES;
  98 int verbSpanish::persons = PERSONEN;
  99 int verbSpanish::maxForms = MAX_TIEMPOS * MAX_SUBTYPES;
 100
 101
 102 verbSpanish::verbSpanish()
 103 {
 104         foreign = "";
 105         spanish = "";
 106         gerund = "";
 107         partizip = "";
 108         group = REGULAR;
 109         conjugated = false;
 110         error = false;
 111         int z;
 112         int p;
 113         for (z = presente; z <= imperativo; z++)
 114         {
 115                 for (p = yo; p <= ellos; p++)
 116                 {
 117                         forms[z][p] = "";
 118                 };
 119         };
 120 }
 121
 122 verbSpanish::verbSpanish(const verbSpanish& v)
 123 {
 124         foreign = v.foreign;
 125         spanish = v.spanish;
 126         group = v.group;
 127         if (IRREGULAR != group)
 128         {
 129                 gerund = "";
 130                 partizip = "";
 131                 conjugated = false;
 132                 error = v.error;
 133                 int z;
 134                 int p;
 135                 for (z = presente; z <= imperativo; z++)
 136                         for (p = yo; p <= ellos; p++)
 137                                 forms[z][p] = "";
 138         }
 139         else
 140         {
 141                 gerund = v.gerund;
 142                 partizip = v.partizip;
 143                 error = v.error;
 144                 conjugated = v.conjugated;
 145                 int z;
 146                 int p;
 147                 for (z = presente; z <= imperativo; z++)
 148                         for (p = yo; p <= ellos; p++)
 149                                 forms[z][p] = v.forms[z][p];
 150         };
 151 }
 152
 153 verbSpanish::~verbSpanish()
 154 {
 155         // momentan hat die Klasse gar keine dynamisch erstellten
 156         // Elemente, insofern ist auch der Destruktor recht arbeitslos
 157 }
 158
 159 verbSpanish& verbSpanish::operator= (const verbSpanish& v)
 160 {
 161         if (this == &v)
 162                 return *this;                                           // Selbstzuweisung abfangen
 163         foreign = v.foreign;
 164         spanish = v.spanish;
 165         group = v.group;
 166         error = v.error;
 167         if (group != IRREGULAR)
 168         {
 169                 gerund = "";
 170                 partizip = "";
 171                 conjugated = false;
 172                 int z;
 173                 int p;
 174                 for (z = presente; z <= imperativo; z++)
 175                         for (p = yo; p <= ellos; p++)
 176                                 forms[z][p] = "";
 177         }
 178         else
 179         {
 180                 gerund = v.gerund;
 181                 partizip = v.partizip;
 182                 conjugated = v.conjugated;
 183                 int z;
 184                 int p;
 185                 for (z = presente; z <= imperativo; z++)
 186                         for (p = yo; p <= ellos; p++)
 187                                 forms[z][p] = v.forms[z][p];
 188         };
 189         return *this;
 190 }
 191
 192 // Der Vergleichsoperator prüft, ob zwei verb-Objekte das gleiche Verb meinen. Dazu
 193 // werden die spanische und die fremdsprachliche Form geprüft.
 194 bool verbSpanish::operator== (const verbSpanish& v) const
 195 {
 196         return ((spanish == v.spanish) && vergleich(foreign, v.foreign));
 197 }
 198
 199 // prüft ob der QString mit der spanischen Form übereinstimmt.
 200 bool verbSpanish::operator== (const QString& s) const
 201 {
 202         return (spanish == s);
 203 }
 204
 205 // prüft die alphabetische Reihenfolge zweier Verben, dabei werden die spanischen Verben als
 206 // Vergleichskriterium verwendet.
 207 bool verbSpanish::operator< (const verbSpanish& v) const
 208 {
 209         return (spanish < v.spanish) || ((spanish == v.spanish) && (foreign < v.foreign));
 210 }
 211
 212
 213 // Vergleicht die beiden Verbobjekte komplett, mit allen Formen und Feldern.
 214 bool verbSpanish::allEqual(verbSpanish v)
 215 {
 216         bool result = ((spanish == v.spanish) && (foreign == v.foreign) && (group == v.group));
 217         if (result && (IRREGULAR == group))
 218         {
 219                 if (!conjugated)
 220                         conjugateAll();
 221                 if (v.conjugated)
 222                         v.conjugateAll();
 223                 result = ((delAutoForm(gerund) == delAutoForm(v.gerund)) && (delAutoForm(partizip) == delAutoForm(v.partizip)));
 224                 if (result)
 225                 {
 226                         int z;
 227                         int p;
 228                         for (z = presente; z <= imperativo; z++)
 229                                 for (p = yo; p <= ellos; p++)
 230                                         if (delAutoForm(forms[z][p]) != delAutoForm(v.forms[z][p]))
 231                                                 result = false;
 232                 };
 233         };
 234         return result;
 235 }
 236
 237 // prüft, ob alle Stringfelder des Objektes leere Strings sind.
 238 bool verbSpanish::isEmpty() const
 239 {
 240         bool result = (spanish.isEmpty() && foreign.isEmpty());
 241         if (result && (IRREGULAR == group))
 242         {
 243                 result = (gerund.isEmpty() && partizip.isEmpty());
 244                 if (result)
 245                 {
 246                         int z;
 247                         int p;
 248                         for (z = presente; z <= imperativo; z++)
 249                                 for (p = yo; p <= ellos; p++)
 250                                         if (!forms[z][p].isEmpty())
 251                                                 result = false;
 252                 };
 253         };
 254         return result;
 255 }
 256
 257 // Gibt den Verbstamm zurück. Dazu werden die letzten beiden Zeichen abgetrennt,
 258 // handelt es sich um ein reflexives Verb, dann sind es vier Zeichen.
 259 // Hier werden auch die Stammveränderungen der Gruppenverben durchgeführt.
 260 QString verbSpanish::getStem() const
 261 {
 262         int ab = 2;
 263         if (isReflexiv())
 264                 ab += 2;
 265         QString s = spanish;
 266         s.truncate(s.length()-ab);
 267         return s;
 268 }
 269
 270 // gibt das Verb in der nicht spanischen Sprache zurück
 271 QString verbSpanish::getForeign() const
 272 {
 273         return foreign;
 274 }
 275
 276 // Setzt die nicht-spanische Bedeutung des Verbes. Dabei werden alle führenden und
 277 // folgenden whitespaces gelöscht und alle im string enthaltenen whitespaces zu einem
 278 // Leerzeichen umgewandelt.
 279 // Die Funktion hat den Nebeneffekt, dass auch der String aus dem aufrufenden Program-
 280 // code umgewandelt wird.
 281 // Es wird nicht geprüft, ob der string keine Leerzeichen mehr enthält, denn das
 282 // dürfte eigentlich nicht vorkommen.
 283 void verbSpanish::setForeign(const QString &s)
 284 {
 285         foreign = s.simplifyWhiteSpace();
 286 }
 287
 288 // gibt das Verb auf spanisch zurück
 289 QString verbSpanish::getSpanish() const
 290 {
 291         return spanish;
 292 }
 293
 294 // Setzt die spanische Bedeutung des Verbes.
 295 // Siehe auch die Bemerkungen zur Arbeitsweise der Funktionbei der setForeign Funktion.
 296 void verbSpanish::setSpanish(const QString &s)
 297 {
 298         spanish = s.simplifyWhiteSpace();
 299 }
 300
 301 // gibt die Gerundform des Verbes zurück. Dabei gilt: Alle Gruppenverben haben einen
 302 // regelmäßigen Gerund. Nur die irregulären Verben haben eventuell auch eine andere Gerundform
 303 QString verbSpanish::getGerund()
 304 {
 305         if (!conjugated)
 306                 conjugateAll();
 307         return delAutoForm(gerund);
 308 }
 309
 310 // setzt die Gerundform des Verbes
 311 // Siehe auch die Bemerkungen zur Arbeitsweise der Funktionbei der setForeign Funktion.
 312 void verbSpanish::setGerund(const QString &s)
 313 {
 314         gerund = s.simplifyWhiteSpace();
 315 }
 316
 317 // gibt die Partizipform der Verbes zurück.Dabei gilt: Alle Gruppenverben haben ein
 318 // regelmäßiges Partizip. Nur die irregulären Verben haben eventuell auch eine andere Partizipform
 319 QString verbSpanish::getPartizip()
 320 {
 321         if (!conjugated)
 322                 conjugateAll();
 323         return delAutoForm(partizip);
 324 }
 325
 326 // setzt die Partizipform der Verbes
 327 // Siehe auch die Bemerkungen zur Arbeitsweise der Funktionbei der setForeign Funktion.
 328 void verbSpanish::setPartizip(const QString &s)
 329 {
 330         partizip = s.simplifyWhiteSpace();
 331 }
 332
 333 // gibt die Endung des Verbes zurück.
 334 endings verbSpanish::getEnding(bool& good)
 335 {
 336         if (spanish.isEmpty())
 337                 return empty;
 338         endings en = empty;
 339         QString endung = "";
 340         if (isReflexiv())
 341         {
 342                 endung = spanish.mid(spanish.length()-4, 2);
 343         }
 344         else
 345         {
 346                 endung = spanish.right(2);
 347         };
 348         if (endung == "ar")
 349         {
 350                 en = ar;
 351         }
 352         else
 353                 if ((endung == "ir")||(endung == "ír"))
 354                 {
 355                         en = ir;
 356                 }
 357                 else
 358                         if (endung == "er")
 359                         {
 360                                 en = er;
 361                         }
 362                         else
 363                         {
 364                                 good = false;
 365                                 // qWarning("The class verb couldn't find the ending of the verb " + spanish + ".");
 366                         };
 367         return en;
 368 }
 369
 370 // gibt zurück, ob das Verb reflexiv ist. Dazu werden die letzten beiden Zeichen
 371 // untersucht. Sind diese beiden 'se', dann ist es ein reflexives Verb.
 372 bool verbSpanish::isReflexiv() const
 373 {
 374         return (spanish.right(2) == "se");
 375 }
 376
 377 // gibt das Reflexivpronomen zurück, das zu der angegebenen Person gehört.
 378 QString verbSpanish::getRefPron(int i)
 379 {
 380         return refPron[i];
 381 }
 382
 383 // prüft, ob es ein unregelmäßiges Verb ist
 384 bool verbSpanish::isGroupVerb()
 385 {
 386         return (IRREGULAR != group);
 387 }
 388
 389 // setzen, ob ein Verb regelmäßig oder unregelmäßig ist
 390 void verbSpanish::setGroup(const int g)
 391 {
 392         group = g;
 393 }
 394
 395 // Gibt die angeforderte Verbform des Verbes zurück, die durch die Zeit t,
 396 // die Person p und den Untertyp typ angegeben wird. Mit dieser Funktion können auch
 397 // die zusammengesetzten Zeitforms erfragt werden.
 398 // parts[0] = ref. Pron. part[1] = Hilfsverb parts[2] = verb
 399 bool verbSpanish::getForm(int t, int p, int typ, QString parts[])
 400 {
 401         bool good = !error;
 402         if (good)
 403         {
 404                 if (!conjugated)
 405                         good = conjugateAll();
 406                 // sich um das Reflexivpronomen kümmern
 407                 if (isReflexiv())
 408                 {
 409                         parts[0] = getRefPron(p);
 410                 }
 411                 else
 412                         parts[0] = "";
 413                 // die anderen Teile der Form sammeln
 414                 switch (typ)
 415                 {
 416                         // die normale Zeitenbildung: kein Hilfsverb, Zeitform
 417                 case 0:
 418                         parts[1] = "";
 419                         parts[2] = forms[t][p];
 420                         break;
 421                         // die Verlaufsform der Zeitenbildung
 422                 case 1:
 423                         parts[1] = estar[t][p];
 424                         parts[2] = gerund;
 425                         break;
 426                         // die Perfektform der Zeitenbildung
 427                 case 2:
 428                         parts[1] = haber[t][p];
 429                         parts[2] = partizip;
 430                         break;
 431                 default:
 432                         good = false;
 433                 };
 434                 // Das '#' bei den automatisch erstellten Formen löschen.
 435                 parts[2] = delAutoForm(parts[2]);
 436         };
 437         return good;
 438 }
 439
 440 // Eine überladene Funktion, die einen String zurückgibt.
 441 QString verbSpanish::getForm(int t, int p)
 442 {
 443         QString st[3];
 444         if (getForm(t, p, normal, st))
 445                 return st[2];
 446         return "";
 447 }
 448
 449 // setzt die angegebene Verbform mit int als Parameter
 450 // Siehe auch die Bemerkungen zur Arbeitsweise der Funktion bei der setForeign Funktion.
 451 void verbSpanish::setForm(int t, int p, QString s)
 452 {
 453         forms[t][p] = s.simplifyWhiteSpace();
 454 }
 455
 456 // bildet die Formen, d.h. hängt die Endungen an den unveränderlichen
 457 // Teil an.
 458 // Die Form muss bisher ein leerer String sein.
 459 bool verbSpanish::conjugateTime(const int t, const QString &s)
 460 {
 461         bool good = true;
 462         for (int i = yo; i <=ellos; i++)
 463         {
 464                 if (forms[t][i].isEmpty())
 465                 {
 466                         forms[t][i] = s + verbEndings[t][getEnding(good)][i]+'#';
 467                         if (group > IRREGULAR)
 468                                 good = groupVerb(forms[t][i], t, i);
 469                 };
 470         };
 471         return good;
 472 }
 473
 474 // bildet die Formen des Präsens
 475 // dazu wird an den Verbstamm die entsprechende Endung angehängt
 476 bool verbSpanish::conjugatePresente()
 477 {
 478         QString s = getStem();
 479         return conjugateTime(presente, s);
 480 }
 481
 482 // bildet die Formen des Imperfecto
 483 // dazu wird an den Verbstamm die entsprechende Endung angehängt
 484 bool verbSpanish::conjugateImperfecto()
 485 {
 486         QString s = getStem();
 487         return conjugateTime(imperfecto, s);
 488 }
 489
 490 // bildet die Formen des Indefinido
 491 // dazu wird an den Verbstamm die entsprechende Endung angehängt
 492 bool verbSpanish::conjugateIndefinido()
 493 {
 494         QString s = getStem();
 495         return conjugateTime(indefinido, s);
 496 }
 497
 498 // bildet die Formen des Futuro
 499 // dazu wird die entsprechende Endung an den Infinitiv angehängt. Bei den reflexiven
 500 // Verben muss das 'se' abgetrennt werden.
 501 bool verbSpanish::conjugateFuturo()
 502 {
 503         QString s = getSpanish();
 504         if (isReflexiv())
 505                 s = s.left(s.length()-2);
 506         return conjugateTime(futuro, s);
 507 }
 508
 509 // bildet die Formen des Conditional
 510 // diese Formen werden ebenfalls vom Infinitiv des Verbes abgeleitet
 511 bool verbSpanish::conjugateCondicional()
 512 {
 513         QString s = getSpanish();
 514         if (isReflexiv())
 515                 s = s.left(s.length()-2);
 516         return conjugateTime(condicional, s);
 517 }
 518
 519 // IM ctor der Optionen-Klasse und beim Lesen der Optionen werden die nicht
 520 // fertigen Zeiten abegewählt. NIcht vergessen!
 521 bool verbSpanish::conjugateSubPresente()
 522 {
 523         // qWarning("Not yet implemented.");
 524         return true;
 525 }
 526
 527 bool verbSpanish::conjugateSubPasado()
 528 {
 529         // qWarning("Not yet implemented.");
 530         return true;
 531 }
 532
 533 bool verbSpanish::conjugateImperativo()
 534 {
 535         // qWarning("Not yet implemented.");
 536         return true;
 537 }
 538
 539 // konjugiert alle Zeitenformen
 540 bool verbSpanish::conjugateAll()
 541 {
 542         bool good = true;
 543         good = good && conjugatePresente();
 544         good = good && conjugateImperfecto();
 545         good = good && conjugateIndefinido();
 546         good = good && conjugateFuturo();
 547         good = good && conjugateCondicional();
 548         good = good && conjugateSubPresente();
 549         good = good && conjugateSubPasado();
 550         good = good && conjugateImperativo();
 551         if (partizip.isEmpty())
 552         {
 553                 partizip = getStem();
 554                 switch (getEnding(good))
 555                 {
 556                 case ar:
 557                         partizip += "ado#";
 558                         break;
 559                 case er:
 560                 case ir:
 561                         partizip += "ido#";
 562                         break;
 563                 default:
 564                         good = false;
 565                 };
 566         };
 567         if (gerund.isEmpty())
 568         {
 569                 gerund = getStem();
 570                 switch (getEnding(good))
 571                 {
 572                 case ar:
 573                         gerund += "ando#";
 574                         break;
 575                 case er:
 576                 case ir:
 577                         // Bei den Verben der Gruppe 16 fällt das i weg.
 578                         if (getGroup() == 16)
 579                                 gerund += "endo#";
 580                         else
 581                         {
 582                                 // Bei Verben der Gruppe 5 ändert sich der Stamm für den Gerund
 583                                 if (getGroup() == 5)
 584                                 {
 585                                         int pos = gerund.findRev("e");
 586                                         if (pos>=0)
 587                                         {
 588                                                 gerund.replace(pos, 1, "i");
 589                                         };
 590                                 }
 591                                 gerund += "iendo#";
 592                         };
 593                         break;
 594                 default:
 595                         good = false;
 596                 };
 597         };
 598         conjugated = true;
 599         error = !good;
 600         return good;
 601 }
 602
 603 // Stringvergleich, bei dem es nur auf ähnlich Bestandteile ankommt.
 604 // Bestandteile sind durch Komma getrennt.
 605 bool verbSpanish::vergleich(const QString& s1, const QString& s2) const
 606 {
 607         bool gleich=false;
 608         unsigned int l=0;
 609         int r=s1.find(",", l);
 610         while ((l<s1.length()) && (false==gleich))
 611         {
 612                 if (-1 == r)
 613                   r = s1.length();
 614                 if (s2.find(s1.mid(l, r-l).simplifyWhiteSpace(), 0) != -1)
 615                 {
 616                   gleich = true;
 617                 }
 618                 else
 619                 {
 620                         l = r+1;
 621                         r=s1.find(",", l);
 622                 };
 623         };
 624         return gleich;
 625 }
 626
 627 // returns true if the form is automatic generated and has a '#' on the right end.
 628 bool verbSpanish::isAutoForm(QString& s) const
 629 {
 630         if ("#" == s.right(1))
 631                 return true;
 632         return false;
 633 }
 634
 635 // löscht das '#' einer automatisch generierten Form
 636 QString verbSpanish::delAutoForm(QString s) const
 637 {
 638         if (isAutoForm(s))
 639                 s = s.left(s.length()-1);
 640         return s;
 641 }
 642
 643 // does the changes for group verbs
 644 //  The verbs are divided in several groups:
 645 //       0 -> regular
 646 //     1 -> irregular
 647 //     2 -> <e -> ie>
 648 //     3 -> <o -> ue>
 649 //     4 -> <u -> ue>
 650 //     5 -> <e -> i>
 651 //     6 -> <c -> qu>
 652 //     7 -> <g -> gu>
 653 //     8 -> <z -> c>
 654 //     9 -> <gu -> gü>
 655 //    10 -> <c -> z>
 656 //    11 -> <g -> j>
 657 //    12 -> <gu -> g>
 658 //    13 -> <qu -> c>
 659 //    14 -> <accent like 'enviar'>
 660 //    15 -> <accent like 'continuar'>
 661 //    16 -> <missing i>
 662 //
 663 bool verbSpanish::groupVerb(QString &s, int time/*=-1*/, int person/*=-1*/)
 664 {
 665         bool good = true;
 666         int pos;
 667         switch (group)
 668         {
 669         case 2: // <e -> ie>
 670                 // betrifft den Presente und den Subjuntivo Presente und einige Imperativformen
 671                 // dabei jeweils die Personen 1-3 im Singular und die 3. Person Plural.
 672                 // Subjuntivo Presente wird hier nicht bearbeitet, weil der von der ersten Person
 673                 // Singular abgeleitet wird und die sollte schon richtig sein.
 674                 if ((presente == time) || (imperativo == time))
 675                 {
 676                         if ((nosotros != person) && (vosotros != person))
 677                         {
 678                                 pos = s.findRev("e");
 679                                 if (pos>=0)
 680                                         s.replace(pos, 1, "ie");
 681                         };
 682                 };
 683                 break;
 684         case 3: // <o -> ue>
 685                 // betrifft den Presente und den Subjuntivo Presente und einige Imperativformen
 686                 // dabei jeweils die Personen 1-3 im Singular und die 3. Person Plural.
 687                 // Subjuntivo Presente wird hier nicht bearbeitet, weil der von der ersten Person
 688                 // Singular abgeleitet wird und die sollte schon richtig sein.
 689                 if ((presente == time) || (imperativo == time))
 690                 {
 691                         if ((nosotros != person) && (vosotros != person))
 692                         {
 693                                 pos = s.findRev("o", -3);
 694                                 if (pos>=0)
 695                                         s.replace(pos, 1, "ue");
 696                         };
 697                 };
 698                 break;
 699         case 4: // <u -> ue>
 700                 // betrifft den Presente und den Subjuntivo Presente und einige Imperativformen
 701                 // dabei jeweils die Personen 1-3 im Singular und die 3. Person Plural.
 702                 // Subjuntivo Presente wird hier nicht bearbeitet, weil der von der ersten Person
 703                 // Singular abgeleitet wird und die sollte schon richtig sein.
 704                 if ((presente == time) || (imperativo == time))
 705                 {
 706                         if ((nosotros != person) && (vosotros != person))
 707                         {
 708                                 pos = s.findRev("u");
 709                                 if (pos>=0)
 710                                         s.replace(pos, 1, "ue");
 711                         };
 712                 };
 713                 break;
 714         case 5: // <e -> i>
 715                 // Betrifft Präsens (1.-3. Pers Singular und 3. Person Plural)
 716                 // die Gerundform, die wird allerdings nicht hier behandelt, sondern in conjugateAll()
 717                 // indefinido 3. Person Sg und Pl.
 718                 // alle subjuntivo Formen und den imperativo
 719                 if ((presente == time) && (person != nosotros) && (person != vosotros))
 720                 {
 721                         QString st = getStem();
 722                         pos = st.findRev("e");
 723                         if (pos>=0)
 724                         {
 725                                 st.replace(pos, 1, "i");
 726                                 s = st + verbEndings[time][getEnding(good)][person];
 727                         };
 728                 }
 729                 else
 730                 if ((indefinido == time) && ((el == person)||(ellos == person)))
 731                 {
 732                         QString st = getStem();
 733                         pos = st.findRev("e");
 734                         if (pos>=0)
 735                         {
 736                                 st.replace(pos, 1, "i");
 737                                 s = st + verbEndings[time][getEnding(good)][person];
 738                         };
 739                 }
 740                 else
 741                         if (imperativo == time)
 742                         {
 743                                 good = false;
 744                                 // qWarning("Imperativo for group verbs isn't ready.");
 745                         };
 746                 break;
 747         case 6: // <c -> qu> (vor e wird c zu qu)
 748                 pos = s.findRev("ce");
 749                 if (pos>=0)
 750                         s.replace(pos, 2, "que");
 751                 else
 752                 {
 753                         pos = s.findRev("cé");
 754                         if (pos>=0)
 755                                 s.replace(pos, 2, "qué");
 756                 }
 757                 break;
 758         case 7: // <g -> gu> (vor e wird g zu gu)
 759                 pos = s.findRev("ge");
 760                 if (pos>=0)
 761                         s.replace(pos, 2, "gue");
 762                 else
 763                 {
 764                         pos = s.findRev("gé");
 765                         if (pos>=0)
 766                                 s.replace(pos, 2, "gué");
 767                 }
 768                 break;
 769         case 8: // <z -> c> (vor e wird z zu c)
 770                 pos = s.findRev("ze");
 771                 if (pos>=0)
 772                         s.replace(pos, 2, "ce");
 773                 else
 774                 {
 775                         pos = s.findRev("zé");
 776                         if (pos>=0)
 777                                 s.replace(pos, 2, "cé");
 778                 }
 779                 break;
 780         case 9: // <gu -> gü> (vor e wird gu zu gü)
 781                 pos = s.findRev("gue");
 782                 if (pos>=0)
 783                         s.replace(pos, 3, "güe");
 784                 else
 785                 {
 786                         pos = s.findRev("gué");
 787                         if (pos>=0)
 788                                 s.replace(pos, 3, "güé");
 789                 }
 790         break;
 791         case 10: // <c -> z> (vor o und a wird c zu z)
 792                 pos = s.findRev("co");
 793                 if (pos>=0)
 794                         s.replace(pos, 2, "zo");
 795                 else
 796                 {
 797                         pos = s.findRev("ca");
 798                         if (pos>=0)
 799                                 s.replace(pos, 2, "za");
 800                 };
 801                 break;
 802         case 11: // <g -> j> (vor o und a wird g zu j)
 803                 pos = s.findRev("ga");
 804                 if (pos>=0)
 805                         s.replace(pos, 2, "ja");
 806                 else
 807                 {
 808                         pos = s.findRev("go");
 809                         if (pos>=0)
 810                                 s.replace(pos, 2, "jo");
 811                 };
 812                 break;
 813         case 12: // <gu -> g> (vor o und a wird gu zu g)
 814                 pos = s.findRev("guo");
 815                 if (pos>=0)
 816                         s.replace(pos, 3, "go");
 817                 else
 818                 {
 819                         pos = s.findRev("gua");
 820                         if (pos>=0)
 821                                 s.replace(pos, 3, "ga");
 822                 };
 823                 break;
 824         case 13: // <qu -> c> (vor o und a wird qu zu c)
 825                 pos = s.findRev("quo");
 826                 if (pos>=0)
 827                         s.replace(pos, 3, "co");
 828                 else
 829                 {
 830                         pos = s.findRev("qua");
 831                         if (pos>=0)
 832                                 s.replace(pos, 3, "ca");
 833                 };
 834                 break;
 835         case 14: // <accent like 'enviar'>
 836                 // Änderungen betreffen die Präsensformen außer nosotros und vosotros. Außerdem den
 837                 // Subjuntivo presente, der von der 1.Person singular abgeleitet wird und daher hier nicht
 838                 // behandelt werden muss. Des Weiteren sind einige Imperativformen betroffen.
 839                 if (presente == time)
 840                 {
 841                         switch (person)
 842                         {
 843                         case yo:
 844                                 s = s.left(s.length()-3) + "ío#";
 845                                 break;
 846                         case tu:
 847                                 s = s.left(s.length()-4) + "ías#";
 848                                 break;
 849                         case el:
 850                                 s = s.left(s.length()-3) + "ía#";
 851                                 break;
 852                         case ellos:
 853                                 s = s.left(s.length()-4) + "ían#";
 854                                 break;
 855                         default:
 856                                 {};
 857                         };
 858                 }
 859                 else
 860                         if (imperativo == time)
 861                         {
 862                                 switch (person)
 863                                 {
 864                                 case tu:
 865                                         s = s.left(s.length()-3) + "ía#";
 866                                         break;
 867                                 case el:
 868                                         s = s.left(s.length()-3) + "íe#";
 869                                         break;
 870                                 case ellos:
 871                                         s = s.left(s.length()-4) + "íen#";
 872                                         break;
 873                                 default:
 874                                         {};
 875                                 };
 876                         };
 877                 break;
 878         case 15: // <accent like 'continuar'>
 879                 // Änderungen betreffen die Präsensformen außer nosotros und vosotros. Außerdem den
 880                 // Subjuntivo presente, der von der 1.Person singular abgeleitet wird und daher hier nicht
 881                 // behandelt werden muss. Des Weiteren sind einige Imperativformen betroffen.
 882                 if (presente == time)
 883                 {
 884                         switch (person)
 885                         {
 886                         case yo:
 887                                 s = s.left(s.length()-3) + "úo#";
 888                                 break;
 889                         case tu:
 890                                 s = s.left(s.length()-4) + "úas#";
 891                                 break;
 892                         case el:
 893                                 s = s.left(s.length()-3) + "úa#";
 894                                 break;
 895                         case ellos:
 896                                 s = s.left(s.length()-4) + "úan#";
 897                                 break;
 898                         default:
 899                                 {};
 900                         };
 901                 }
 902                 else
 903                         if (imperativo == time)
 904                         {
 905                                 switch (person)
 906                                 {
 907                                 case tu:
 908                                         s = s.left(s.length()-3) + "úa#";
 909                                         break;
 910                                 case el:
 911                                         s = s.left(s.length()-3) + "úe#";
 912                                         break;
 913                                 case ellos:
 914                                         s = s.left(s.length()-4) + "úen#";
 915                                         break;
 916                                 default:
 917                                         {};
 918                                 };
 919                         };
 920                 break;
 921         case 16: // <missing i>
 922                 // Änderungen betreffen die Gerund-Form, den Indefinido in der 3. Person Singular
 923                 // und Plural und den Subjuntivo Pasado. Hier wird der Subjuntivo nicht bearbeitet,
 924                 // weil er von der 3. Person des Indefinido abgeleitet wird. Diese Form sollte bereits
 925                 // geändert sein. Ebenso wird der Gerund in der ConjugateAll()-Funktion behandelt.
 926                 if ("ió#" == s.right(3))
 927                 {
 928                         s = s.left(s.length()-3) + "ó#";
 929                 }
 930                 else
 931                         if ("ieron#" == s.right(6))
 932                         {
 933                                 s = s.left(s.length()-6) + "eron#";
 934                         };
 935                 break;
 936         default:
 937                 good = false;
 938         };
 939         return good;
 940 }
 941
 942
 943