source: lliurex-jocomunico/trunk/fuentes/lliurex-jocomunico.install/var/lib/application/libraries/Mypattern.php @ 5728

Last change on this file since 5728 was 5728, checked in by joamuran, 3 years ago

Added zero-installed and updated jocomunico

  • Property svn:executable set to *
File size: 234.1 KB
Line 
1<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); 
2
3class Mypattern {
4   
5    var $id;
6    var $idverb;
7    var $pronominal = false;
8    var $pseudoimpersonal = false;
9    var $copulatiu = false;
10    var $verbless = false; // per quan no han introduït verb i s'afegeix després amb les columnes
11                           // defaultverb o els verbless patterns
12    var $impersonal = false;
13   
14    var $tipusfrase;
15    var $defaulttense = null;
16    var $verbpeticio;
17    var $partpreguntabona = false;
18   
19    var $subverb = false; // Tindrà el nom de l'slot que accepta el subverb
20    var $allowstime = false; // diu si el pattern accepta expressions de temps
21    var $timeexpr = array(); // Array amb les expressions de temps
22    var $exprsarray = array(); // array amb les expressions introduïdes que omplen el pattern [0] text [1] front
23    var $needexpr = false; // indica si una expressió és obligatòria al pattern
24   
25    var $exemple;
26   
27    var $slotarray = array(); // És un array de slots
28    var $hasslot = array(); // Array amb booleans que diuen si aquest pattern té una categoria d'slot
29    var $virtualslotsort = array(); // ordenats per la importància de fer fill
30   
31    var $puntuaciofinal = 100; // Guarda la puntuació final del pattern
32   
33    // PER SI HI HA SLOTS DE SUBVERB; PROPIETATS DE L?ESTRUCTURA DEL SUBVERB
34    var $id2 = null;
35    var $idverb2 = null;
36    var $pronominal2 = null;
37    var $pseudoimpersonal2 = null;
38   
39    var $tipusfrase2 = null;
40    var $defaulttense2 = null;
41    var $verbpeticio2 = null;
42   
43    var $paraules = array();
44   
45    /*
46     * VARIABLES PEL GENERADOR
47     */
48   
49    var $ordrefrase = array(); // array amb els keys dels slots plens (o obligatoris no plens amb els default value) que formaran la frase final ja ordenats
50    var $frasefinal = " "; // string final construït a partir dels slotstring de cada slot
51    var $questiontypequant = false; // ens indica si hi ha partícules de pregunta que es comporten com "quant"
52    var $frasenegativa = false; // serveix per conjugar l'imperatiu quan és negatiu com a present de subjuntiu
53   
54    var $isfem = false; // ens diu si l'usuari és una dona
55   
56    var $perssubj1 = 1;
57    var $genmascsubj1 = true;
58    var $plsubj1 = false;
59   
60    var $perssubj2 = 1;
61    var $genmascsubj2 = true;
62    var $plsubj2 = false;
63   
64    var $subjsiguals = false; // si hi ha dos subjectes, diu si són iguals
65   
66    function __construct() {}
67   
68    public function initialise($patternbbdd, $verbless, $subjdef) 
69    {
70        $CI = &get_instance();
71        $CI->load->library('Myslot');
72       
73        $this->id = $patternbbdd->patternid;
74        $this->idverb = $patternbbdd->verbid;
75        $this->verbless = $verbless;
76        // els verbless patterns quan competeixen amb patrons no verbless, que comencin amb menys punts
77        // que només els agafi si no en troba de millors
78        if ($this->idverb == '0') $this->puntuaciofinal = 90;
79       
80        if ($patternbbdd->pronominal == '1') $this->pronominal = true;
81        if ($patternbbdd->pseudoimpersonal == '1') $this->pseudoimpersonal = true;
82        if ($patternbbdd->copulatiu == '1') $this->copulatiu = true;
83       
84        $this->tipusfrase = $patternbbdd->tipusfrase;
85        $this->defaulttense = $patternbbdd->defaulttense;
86        $this->verbpeticio = $patternbbdd->verbpeticio;
87       
88        if ($patternbbdd->subverb == '1') $this->subverb = true;
89       
90        $this->exemple = $patternbbdd->exemple;
91       
92        // Slot SUBJECT
93        if ($patternbbdd->subj != '0') {
94            $subjecte = new Myslot();
95            $subjecte->category = "Subject";
96            $subjecte->grade = "1";
97            $subjecte->type = $patternbbdd->subj;
98            $subjecte->defvalue = $patternbbdd->subjdef;
99            $subjecte->slotPuntsInicials();
100            $subjecte->verbless = $verbless;
101           
102            // sobreescrivim el subjecte per defecte, si s'envia des de la columna subdef dels adjectius
103            if ($subjdef) {
104                $subjecte->defvalue = $subjdef;
105            }
106
107            if ($subjecte->type == "verb") $this->subverb = "Subject";
108            $this->hasslot["Subject"] = true;
109
110            $this->slotarray["Subject"] = $subjecte;
111        }
112        // si no té subjecte
113        else {
114            $this->impersonal = true;
115        }
116       
117        // Slot ROOT
118        $rootslot = new Myslot();
119        $rootslot->category = "Main Verb";
120        $rootslot->grade = "1";
121        $rootslot->type = "verb";
122        $rootslot->slotPuntsInicials();
123       
124        $this->slotarray["Main Verb"] = $rootslot;
125        $this->hasslot["Main Verb"] = true;
126       
127        // Després d'inicialitzar tot el pattern, s'omple l'slot de Main Verb amb el Verb principal
128                       
129        // Slot THEME
130        if ($patternbbdd->theme != '0') {
131           
132            $theme = new Myslot();
133            $theme->category = "Theme";
134            $theme->grade = $patternbbdd->theme;
135            $theme->slotPuntsInicials();
136
137            $theme->type = $patternbbdd->themetipus;
138            if ($theme->grade == '1') $theme->defvalue = $patternbbdd->themedef;
139            if ($patternbbdd->themeprep != "") $theme->prep = $patternbbdd->themeprep;
140            if ($patternbbdd->themeart != "NULL") $theme->art = $patternbbdd->themeart;
141           
142            if ($theme->type == "verb") $this->subverb = "Theme";
143            $this->hasslot["Theme"] = true;
144           
145            $this->slotarray["Theme"] = $theme;
146        }
147       
148        // Slot RECEIVER
149        if ($patternbbdd->receiver != '0') {
150           
151            $receiver = new Myslot();
152            $receiver->category = "Receiver";
153            $receiver->grade = $patternbbdd->receiver;
154            $receiver->slotPuntsInicials();
155
156            $receiver->type = "human";
157            if ($receiver->grade == '1') $receiver->defvalue = $patternbbdd->receiverdef;
158            if ($patternbbdd->receiverprep != "") $receiver->prep = $patternbbdd->receiverprep;
159           
160            if ($receiver->type == "verb") $this->subverb = "Receiver";
161            $this->hasslot["Receiver"] = true;
162           
163            $this->slotarray["Receiver"] = $receiver;
164        }
165       
166        // Slot BENEFICIARY
167        if ($patternbbdd->benef != '0') {
168           
169            $benef = new Myslot();
170            $benef->category = "Beneficiary";
171            $benef->grade = $patternbbdd->benef;
172            $benef->slotPuntsInicials();
173
174            $benef->type = $patternbbdd->beneftipus;
175            if ($benef->grade == '1') $benef->defvalue = $patternbbdd->benefdef;
176            if ($patternbbdd->benefprep != "") $benef->prep = $patternbbdd->benefprep;
177           
178            if ($benef->type == "verb") $this->subverb = "Beneficiary";
179            $this->hasslot["Beneficiary"] = true;
180           
181            $this->slotarray["Beneficiary"] = $benef;
182        }
183       
184        // Slot ACOMP
185        if ($patternbbdd->acomp != '0') {
186           
187            $acomp = new Myslot();
188            $acomp->category = "Company";
189            $acomp->grade = $patternbbdd->acomp;
190            $acomp->slotPuntsInicials();
191
192            $acomp->type = "animate";
193            if ($acomp->grade == '1') $acomp->defvalue = $patternbbdd->acompdef;
194            if ($patternbbdd->acompprep != "") $acomp->prep = $patternbbdd->acompprep;
195           
196            if ($acomp->type == "verb") $this->subverb = "Company";
197            $this->hasslot["Company"] = true;
198           
199            $this->slotarray["Company"] = $acomp;
200        }
201       
202        // Slot TOOL
203        if ($patternbbdd->tool != '0') {
204           
205            $tool = new Myslot();
206            $tool->category = "Tool";
207            $tool->grade = $patternbbdd->tool;
208            $tool->slotPuntsInicials();
209
210            $tool->type = "tool";
211            if ($tool->grade == '1') $tool->defvalue = $patternbbdd->tooldef;
212            if ($patternbbdd->toolprep != "") $tool->prep = $patternbbdd->toolprep;
213           
214            if ($tool->type == "verb") $this->subverb = "Tool";
215            $this->hasslot["Tool"] = true;
216           
217            $this->slotarray["Tool"] = $tool;
218        }
219       
220        // Slot MANNER
221        if ($patternbbdd->manera != '0') {
222           
223            $manera = new Myslot();
224            $manera->category = "Manner";
225            $manera->grade = $patternbbdd->manera;
226            $manera->slotPuntsInicials();
227
228            if ($patternbbdd->maneratipus == 'adv') $manera->type = "manera";
229            else $manera->type = $patternbbdd->maneratipus;
230            if ($manera->grade == '1') $manera->defvalue = $patternbbdd->maneradef;
231           
232            if ($manera->type == "verb") $this->subverb = "Manner";
233            $this->hasslot["Manner"] = true;
234           
235            $this->slotarray["Manner"] = $manera;
236        }
237       
238        // Slot LOCTO
239        if ($patternbbdd->locto != '0') {
240           
241            $locto = new Myslot();
242            $locto->category = "LocTo";
243            $locto->grade = $patternbbdd->locto;
244            $locto->slotPuntsInicials();
245
246            if ($patternbbdd->loctotipus != "verb") $locto->type = "lloc";
247            else $locto->type = $patternbbdd->loctotipus;
248            if ($locto->grade == '1') $locto->defvalue = $patternbbdd->loctodef;
249            if ($patternbbdd->loctoprep != "") $locto->prep = $patternbbdd->loctoprep;
250           
251            if ($locto->type == "verb") $this->subverb = "LocTo";
252            $this->hasslot["LocTo"] = true;
253           
254            $this->slotarray["LocTo"] = $locto;
255        }
256       
257        // Slot LOCFROM
258        if ($patternbbdd->locfrom != '0') {
259           
260            $locfrom = new Myslot();
261            $locfrom->category = "LocFrom";
262            $locfrom->grade = $patternbbdd->locfrom;
263            $locfrom->slotPuntsInicials();
264
265            if ($patternbbdd->locfromtipus != "verb") $locfrom->type = "lloc";
266            else $locfrom->type = $patternbbdd->locfromtipus;
267            if ($locfrom->grade == '1') $locfrom->defvalue = $patternbbdd->locfromdef;
268            if ($patternbbdd->locfromprep != "") $locfrom->prep = $patternbbdd->locfromprep;
269           
270            if ($locfrom->type == "verb") $this->subverb = "LocFrom";
271            $this->hasslot["LocFrom"] = true;
272           
273            $this->slotarray["LocFrom"] = $locfrom;
274        }
275       
276        // Slot LOCAT
277        if ($patternbbdd->locat != '0') {
278           
279            $locat = new Myslot();
280            $locat->category = "LocAt";
281            $locat->grade = $patternbbdd->locat;
282            $locat->slotPuntsInicials();
283
284            $locat->type = "lloc";
285            if ($locat->grade == '1') $locat->defvalue = $patternbbdd->locatdef;
286            if ($patternbbdd->locatprep != "") $locat->prep = $patternbbdd->locatprep;
287           
288            if ($locat->type == "verb") $this->subverb = "LocAt";
289            $this->hasslot["LocAt"] = true;
290           
291            $this->slotarray["LocAt"] = $locat;
292        }
293       
294        // Slot TIME: Només es fa servir pels noms, estil dies de la setmana, mesos...
295        // Pels adverbis de temps fem servir l'array timeexpr
296        if ($patternbbdd->time != '0') {
297            $this->allowstime = true;
298            $time = new Myslot();
299            $time->category = "Time";
300            $time->grade = "opt";
301            $time->type = "time";
302            $time->slotPuntsInicials();
303           
304            $this->hasslot["Time"] = true;
305            $this->slotarray["Time"] = $time;
306        }
307       
308        // Slot EXPRESSIONS
309        if ($patternbbdd->expressio == '1') $this->needexpr = true;
310        else if ($patternbbdd->expressio != "") {
311            $aux = array();
312            $aux[0] = $patternbbdd->expressio;
313            $aux[1] = '0';
314            $this->exprsarray[] = $aux;
315        }
316        $this->hasslot["Expression"] = true;
317                               
318    }
319   
320    public function forceFillSlot($slotname, $word, $penalty, $indexclassfinalword)
321    {       
322        // DEBUG
323        // echo $slotname." ".$word->text."<br /><br />";
324       
325        $word->slotfinal = $slotname;
326               
327        $word->used = true; // marquem la paraula com ja adjudicada
328       
329        $slotaux = new Myslot();
330       
331        $slotaux = &$this->slotarray[$slotname];
332               
333        $slotaux->paraulafinal = $word; 
334               
335        $slotaux->puntsguanyats = $slotaux->puntsfinal - $penalty;
336       
337        $slotaux->puntsfinal = $penalty;
338       
339        $slotaux->full = true;
340       
341        $slotaux->indexclassfinalword = $indexclassfinalword;
342               
343        // $this->slotarray[$slotname]->paraulestemp = array();
344    }
345   
346    // Les noves keys de l'array de slots acabaran en 1 ó 2,
347    // depenent de si venen del pattern principal o el secundari
348    public function fusePatterns($pattern2)
349    {       
350        $CI = &get_instance();
351        $CI->load->library('Myslot');
352               
353        $auxpatternresultat = new Mypattern();
354                       
355        foreach ($this->slotarray as $slots1) {
356                       
357            // Si l'slot és el subverb, insertem els slots del 2on pattern
358            if ($slots1->type == "verb" && $slots1->category != "Main Verb") {
359               
360                foreach ($pattern2->slotarray as $slots2) {
361                    $slots2->level = 2;
362                    $slots2->parent = $slots1->category;
363                    if ($slots2->category == "Main Verb") {
364                        $slots2->category = "Secondary Verb";
365                        // i passem, si n'hi ha, la preposició que ha d'anar davant del subverb
366                        if ($slots1->prep != null) {
367                            $slots2->prep = $slots1->prep;
368                        }
369                    }
370                    $auxpatternresultat->slotarray[$slots2->category." 2"] = $slots2;
371                    $auxpatternresultat->hasslot[$slots2->category." 2"] = true;
372                }
373            }
374            else {
375                $auxpatternresultat->slotarray[$slots1->category." 1"] = $slots1;
376                $auxpatternresultat->hasslot[$slots1->category." 1"] = true;
377            }
378        }
379               
380        $this->slotarray = array();
381        $this->slotarray = $auxpatternresultat->slotarray;
382                       
383        $this->hasslot = array();
384        $this->hasslot = $auxpatternresultat->hasslot;
385       
386        // Passem les propietats del pattern del subverb
387        $this->id2 = $pattern2->id;
388        $this->idverb2 = $pattern2->idverb;
389        $this->pronominal2 = $pattern2->pronominal;
390        $this->pseudoimpersonal2 = $pattern2->pseudoimpersonal;
391       
392        $this->tipusfrase2 = $pattern2->tipusfrase;
393        $this->defaulttense2 = $pattern2->defaulttense;
394        $this->verbpeticio2 = $pattern2->verbpeticio;
395       
396        $this->allowstime = ($this->allowstime || $pattern2->allowstime);
397        $this->needexpr = ($this->needexpr || $pattern2->needexpr);
398       
399        // S'acumulen les expressions, si n'hi ha
400        foreach ($pattern2->exprsarray as $expr) {
401            $this->exprsarray[] = $expr;
402        }
403               
404    }
405   
406    // Posa la partícula a l'slot corresponent
407    public function fillPartPregunta($particula)
408    { 
409        $CI = &get_instance();
410        $CI->load->library('Myslot');
411       
412        $classe1 = null;
413        $classe2 = null;
414        $classeaux1 = "null";
415        $classeaux2 = "null";
416        $particulabona = false;
417       
418        $numclasses = count($particula->classes);
419       
420        for($i=0; $i<$numclasses; $i++) {
421            if ($i==0) $classe1 = $particula->classes[0];
422            else if ($i==1) $classe2 = $particula->classes[1];
423        }
424       
425        if ($classe1 == null && $classe2 == null) {
426            $particulabona = true; // és una partícula que no va a un slot
427                       
428            // creem un slot per la particula
429            $slotpartpregunta = new Myslot();
430            $slotpartpregunta->category = "PartPreguntaNoSlot";
431            $slotpartpregunta->grade = '1';
432            $slotpartpregunta->type = "questpart";
433            $slotpartpregunta->full = true;
434            $slotpartpregunta->paraulafinal = $particula;
435            $slotpartpregunta->puntsfinal = -7;
436            $slotpartpregunta->level = 1;
437           
438            $keyaux = "PartPreguntaNoSlot";
439            if (isset($this->slotarray["Secondary Verb 2"])) $keyaux .= " 1";
440            $this->slotarray[$keyaux] = $slotpartpregunta;
441           
442        }
443        else if ($numclasses >= 1) {
444            if ($this->subverb) { 
445                $classeaux1 = $classe1." 2";
446                $classe1 .= " 1";
447                $classeaux2 = $classe2." 2";
448                $classe2 .= " 1";
449            }
450           
451            // Provem si hi ha la mena d'slot i omplim l'slot, primer del subverb, si n'hi ha, i primer de la 1era classe
452            if (array_key_exists($classeaux1, $this->slotarray)) {
453                    $this->forceFillSlot($classeaux1, $particula, 0, 0);
454                    $particulabona = true;
455            }
456            else if (array_key_exists($classe1, $this->slotarray)) {
457                $this->forceFillSlot($classe1, $particula, 0, 0);
458                $particulabona = true;
459            }
460            else if (array_key_exists($classeaux2, $this->slotarray)) {
461                $this->forceFillSlot($classeaux2, $particula, 0, 1);
462                $particulabona = true;
463            }
464            else if (array_key_exists($classe2, $this->slotarray)) {
465                $this->forceFillSlot($classe2, $particula, 0, 1);
466                $particulabona = true;
467            }
468        }
469               
470        $this->partpreguntabona = $particulabona;
471        return $particulabona;
472    }
473   
474   
475    public function solveNouns($arrayNouns)
476    {       
477        $unusedNouns = array(); // noms no utilitzats a la primera ronda d'intents de fit
478        $usedNouns = array();
479       
480        $numNouns = count($arrayNouns);
481               
482        for ($i=0; $i<$numNouns; $i++) {
483           
484            $word = $arrayNouns[$i];
485                       
486            foreach ($this->slotarray as $keyslot => $slot) {
487                               
488                $fittype = 0; // 1, si fit slot, 0 si no
489               
490                // passem el key de l'slot per si de cas hi ha subverb i els slots són de l'estil "Theme 1|2"
491                $fittype = $slot->nounFitsSlot($word, $keyslot);
492               
493                if ($fittype == 0) $unusedNouns[] = $word; // si no ha pogut anar a cap slot, no el fem servir
494                else $usedNouns[] = $word;
495               
496            }
497           
498            // MIREM SI LA PARAULA NOMÉS HA POGUT FER FILL D'UN ÚNIC SLOT PER FER EL BLOCK CHAINING
499            // SI L'ÚNIC SLOT ÉS DE NC JA SE LI ASSIGNA
500            $this->chainBlockingSlotsType1($word, "NC");
501        }
502               
503        // QUAN JA TENIM POSADES TOTES LES PARAULES, RESOLEM ELS SLOTS ENCARA NO RESOLTS
504        // HI HAURÂ SLOTS AMB JA NOMÉS UNA PARAULA O ALTRES SLOTS AMB VÀRIES PARAULES
505       
506        $mand2level = array();
507        $mand1level = array();
508        $subjectes = array();
509        $opts = array();
510       
511        // Ordenem els slots en differents arrays Mandatory 2on nivell, Mandatory 1er nivell, subjecte, opts
512        foreach ($this->slotarray as $keyslot => $slot) {
513           
514            if ($slot->level == 2) {
515                if ($slot->category == 'Subject') $subjectes[$keyslot] = $slot;
516                else if ($slot->grade == '1') $mand2level[$keyslot] = $slot;
517                else $opts[] = $slot;
518            }
519            else {
520                if ($slot->category == 'Subject') $subjectes[$keyslot] = $slot;
521                else if ($slot->grade == '1') $mand1level[$keyslot] = $slot;
522                else $opts[$keyslot] = $slot;
523            }
524        }
525       
526        // ordenem els slots per importància, per anar-los desambiguant per ordre
527        $this->calculateVirtualOrder();
528        $this->disambiguateSlotsNew("NC");
529       
530        // Primer els obligatoris de 2on nivell
531        // $this->disambiguateSlots($mand2level, "NC");
532        // Després els obligatoris del 1er nivell
533        // $this->disambiguateSlots($mand1level, "NC");
534        // Després els de subjecte
535        // $this->disambiguateSlots($subjectes, "NC");
536        // Finalment els optatius
537        // $this->disambiguateSlots($opts, "NC");
538       
539        $CI = &get_instance();
540        $langnouncorder = $CI->session->userdata('uinterfacelangncorder');
541       
542        $langtype = $CI->session->userdata('uinterfacelangtype');
543        $svo = true;
544        if ($langtype != 'svo') $svo = false;
545               
546        // un cop desambiguats tots els slots, veiem si alguna paraula aniria millor com a NC
547        // en comptes de com a opt.
548        // Per cada slot optatiu mirem si la paraula que fa el fit podia fer de NC
549        foreach ($opts as $keyslotopt => $slotopt) {
550            // Només si l'slot és full i no té un altre complement assignat, que aleshores no el podem eliminar
551            if ($slotopt->full && !$slotopt->NCassigned) {
552               
553                // si no era un perfect fill o si els dos noms anaven contigus abans del verb (en cas de SVO)
554                // i la frase no era pseudoimpersonal o de pregunta que tenen els valors de subverb invertits
555                if ($slotopt->puntsfinal > 0  || 
556                        ($svo && $slotopt->paraulafinal->beforeverb && !$this->pseudoimpersonal && !$this->partpreguntabona)) {
557                   
558                    $wordfill = $slotopt->paraulafinal;
559                                                           
560                    $i=0;
561                    $chosencompl = false;
562                   
563                    // trobem si aquella paraula podia fer de NC d'una altra paraula
564                    while($i<count($wordfill->slotstemps) && !$chosencompl) {
565                       
566                        $keycompl = -1;
567                        $keyaux = null;
568                   
569                        $keyaux = $wordfill->slotstemps[$i];
570                       
571                        // DEBUG
572                        // echo $wordfill->text." ".$keyaux."<br /><br />";
573                                               
574                        // Si és de compl. de nom (cada paraula només pot ser NC d'una altra paraula: de la precedent)
575                        if(strpos($keyaux, "NC")) $keycompl = $i;
576                        $i++;
577                                           
578                        if ($keycompl != -1) {
579                            $auxstring = explode(" ", $keyaux);
580
581                            // agafem el key de l'slot que podia tenir el NC
582                            $numpartskeycompl = count($auxstring);
583                            if ($numpartskeycompl > 0) {
584                                $keyparent = null;
585                                // per si el compl era d'un slot de 2on nivell
586                                if ($numpartskeycompl == 4) $keyparent = $auxstring[0]." ".$auxstring[1];
587                                else $keyparent = $auxstring[0];
588
589                                // mirem si és d'un slot que està ple i que la paraula que l'omple sigui la que complia la condició
590                                // de ser l'anterior a la paraula que fa de complement (si langnouncorder == 1) o posterior (si langnouncorder == 0)
591                                if ($this->slotarray[$keyparent]->full && 
592                                        (($langnouncorder == '1' && ($this->slotarray[$keyparent]->paraulafinal->inputorder - $wordfill->inputorder == -1))
593                                        || ($langnouncorder == '0' && ($this->slotarray[$keyparent]->paraulafinal->inputorder - $wordfill->inputorder == 1)))) {
594
595                                    // fem el canvi: dessassignem slotopt
596                                    $slotopt->full = false;
597                                    $slotopt->paraulafinal = null;
598                                    $slotopt->puntsfinal = 7;
599                                    $slotopt->indexclassfinalword = 0;
600
601                                    // posem que complementa a l'altra slot com a NC
602                                    $wordfill->slotfinal = $keyparent;
603                                    $wordfill->used = true; // en principi ja estava a true
604                                    // indiquem que ara aquest slot té un NC assignat
605                                    $this->slotarray[$keyparent]->NCassigned = true;
606                                    $this->slotarray[$keyparent]->NCassignedkey = $keyaux;
607                                    $chosencompl = true;
608                                }
609                            }
610                        }
611                    }
612                }
613            }
614        } // Fi de per cada slot optatiu mirar si la paraula que el fit fa millor de NC
615       
616        // Si han quedat noms sense slot, mirar si poden fer de NC
617        for ($i=0; $i<$numNouns; $i++) {
618            $word = $arrayNouns[$i];
619           
620            if ($word->slotfinal == null) {
621           
622                $slotstemps = $word->slotstemps;
623               
624                foreach ($slotstemps as $num => $keyslot) {
625                    if (strpos($keyslot, " NC")) {
626                       
627                        $str = explode(" NC", $keyslot);
628                       
629                        // si l'slot on podia fer de complement existeix, té un nucli i
630                        // no té ja un complement assignat
631                        if (isset($this->slotarray[$str[0]]) && $this->slotarray[$str[0]]->full
632                                && !$this->slotarray[$str[0]]->NCassigned) {
633                           
634                            // comprovem que el nucli estés a la distància de NC
635                            if ((($langnouncorder == '1' && $this->slotarray[$str[0]]->paraulafinal->inputorder == $word->inputorder - 1))
636                                    || (($langnouncorder == '0' && $this->slotarray[$str[0]]->paraulafinal->inputorder == $word->inputorder + 1))) {
637                           
638                                $word->used = true;
639                                // indiquem que ara l'slot superior té un NC assignat
640                                $this->slotarray[$str[0]]->NCassigned = true;
641                                $this->slotarray[$str[0]]->NCassignedkey = $keyslot;
642
643                                // un cop trobem el que compleix les condicions, ja no seguim amb el foreach
644                                break;
645                            }
646                        }
647                    }
648                }
649            }
650        } // fi si han quedat noms sense slot
651    }
652   
653    public function solveAdverbs($arrayadverbs)
654    {
655        $unusedAdverbs = array(); // adverbis no utilitzats a la primera ronda d'intents de fit
656        $usedAdverbs = array();
657       
658        $numAdverbs = count($arrayadverbs);
659                       
660        for ($i=0; $i<$numAdverbs; $i++) {
661           
662            $word = $arrayadverbs[$i];
663           
664            // Si és un adverbi de temps, només pot anar a un slot de temps
665            if ($word->isClass("temps")) {
666                if ($this->allowstime) {
667                    $this->timeexpr[] = $word;
668                    $word->used = true;
669                    $word->slotfinal = "Time Expr"; // està a l'array d'expressions de temps
670                    $usedAdverbs[] = $word;
671                }
672                else $unusedAdverbs[] = $word;
673            }
674            else { // Pels altres adverbis
675                foreach ($this->slotarray as $keyslot => $slot) {
676                               
677                    $fittype = 0; // 1, si fit slot, 0 si no
678
679                    // passem el key de l'slot per si de cas hi ha subverb i els slots són de l'estil "Theme 1|2"
680                    $fittype = $slot->adverbFitsSlot($word, $keyslot);
681
682                    if ($fittype == 0) $unusedAdverbs[] = $word; // si no ha pogut anar a cap slot, no el fem servir
683                    else $usedAdverbs[] = $word;
684                }
685
686                // MIREM SI LA PARAULA NOMÉS HA POGUT FER FILL D'UN ÚNIC SLOT PER FER EL BLOCK CHAINING
687                $this->chainBlockingSlotsType1($word, "ADV");
688            }
689                       
690        }
691       
692        // QUAN JA TENIM POSADES TOTES ELS ADVERBIS, RESOLEM ELS SLOTS ENCARA NO RESOLTS
693        // HI HAURÂ SLOTS AMB JA NOMËS UNA PARAULA O ALTRES SLOTS AMB VÀRIES PARAULES
694       
695        $this->calculateVirtualOrder();
696        $this->disambiguateSlotsNew("ADV");
697               
698        // un cop desambiguats tots els slots, veiem si alguna paraula aniria millor com a NC ADV
699        // en comptes de com a opt.
700        for ($i=0; $i<$numAdverbs; $i++) {
701           
702            $indexmillor = -1;
703            $bestdistance = 1000;
704            $bestpoints = 1000;
705           
706            $word = $arrayadverbs[$i];
707            // si la paraula està en un slot (no de temps), mirem si aquest slot és opt i el comparem amb els
708            // slots als que l'adv pot fer de complement, si no, compararem només els slots als
709            // que pot fer de complement entre ells
710            if ($word->used && !$word->isClass("temps")) {
711                $keyslotaux = $word->slotfinal;
712               
713                $slotaux = $this->slotarray[$keyslotaux];
714                if ($slotaux->grade == "opt") {
715                    $bestdistance = 0;
716                    $bestpoints = $slotaux->puntsfinal;
717                }
718            }
719           
720            for ($j=0; $j<count($word->slotstemps); $j++) {
721                $aux = explode(" ADV", $word->slotstemps[$j]);
722               
723                // comprovem que l'slot sigui del tipus ADV que complementa a nom, ja que
724                // els altres opts als que pugui fer fit, com ara els de manner, també hi seran
725                if (count($aux) > 1) {
726               
727                    $keyslotnoun = $aux[0];
728                    $slotnoun = $this->slotarray[$keyslotnoun];
729
730                    // si no té ja un adverbi assignat
731                    if (!$slotnoun->CAdvassigned) {
732
733                        $slotadv = $slotnoun->cmpAdvs[$word->slotstemps[$j]];
734                        $distance = $slotnoun->paraulafinal->inputorder - $word->inputorder;
735                        $points = $slotadv->puntsfinal + abs($distance);
736
737                        if ($points < $bestpoints) {
738                            $bestdistance = $distance;
739                            $bestpoints = $points;
740                            $indexmillor = $word->slotstemps[$j];
741                        }
742                        else if ($points == $bestpoints) {
743                            // en cas d'empat ens quedem amb la que tenia distància positiva,
744                            // que vol dir un adverbi de lloc que vagi abans del nom al que complementa
745                            if ($distance > $bestdistance) {
746                                $bestdistance = $distance;
747                                $bestpoints = $points;
748                                $indexmillor = $word->slotstemps[$j];
749                            }
750                        }
751                    }
752                }
753            }
754           
755            // si hem trobat un slot millor fem la substitució
756            if ($indexmillor != -1) {
757               
758                // si l'adverbi que hem seleccionat feia fill a un altre slot (optatiu, com hem comprovat abans)
759                // que no fos ja de complement el desassignem a l'slot que feia fill
760                if ($word->slotfinal != null && !strpos($word->slotfinal, "ADV")) {
761
762                    $keyslotfinal = $word->slotfinal;
763                    $this->slotarray[$keyslotfinal]->full = false;
764                    $this->slotarray[$keyslotfinal]->paraulafinal = null;
765                    $this->slotarray[$keyslotfinal]->puntsfinal = 7;
766                    $this->slotarray[$keyslotfinal]->indexclassfinalword = 0;
767                }
768               
769                $word->slotfinal = $indexmillor;
770                if (!$word->used) $usedAdverbs[] = $word;
771                $word->used = true;
772                $word->assignadaAComplement = true;
773               
774                $aux2 = explode(" ADV", $indexmillor);
775                $keyslotnoun = $aux2[0];               
776               
777                $this->slotarray[$keyslotnoun]->CAdvassigned = true;
778                $this->slotarray[$keyslotnoun]->CAdvassignedkey = $indexmillor;
779                // treiem la preposició que anava davant de l'slot, si n'hi havia
780                $this->slotarray[$keyslotnoun]->prep = null;
781
782                // no cal que l'esborrem de les altres cues de complements xq només acceptàvem paraules que no estessin
783                // ja assignades a un altre complement
784               
785            }
786           
787        } // fi for per cada adverbi
788               
789    }
790   
791   
792    public function solveAdjs($arrayAdjs)
793    {
794        $unusedAdjs = array(); // noms no utilitzats a la primera ronda d'intents de fit
795        $usedAdjs = array();
796       
797        $numAdjs = count($arrayAdjs);
798                       
799        // Per cada adjectiu
800        for ($i=0; $i<$numAdjs; $i++) {
801           
802            $word = $arrayAdjs[$i];
803                       
804            foreach ($this->slotarray as $keyslot => $slot) {
805                               
806                $fittype = 0; // 1, si fit slot, 0 si no
807                               
808                // passem el key de l'slot per si de cas hi ha subverb i els slots són de l'estil "Theme 1|2"
809                $fittype = $slot->adjFitsSlot($word, $keyslot);
810               
811                if ($fittype == 0) $unusedAdjs[] = $word; // si no ha pogut anar a cap slot, no el fem servir
812                else $usedAdjs[] = $word;
813               
814            }
815           
816            // MIREM SI LA PARAULA NOMÉS HA POGUT FER FILL D'UN ÚNIC SLOT PER FER EL BLOCK CHAINING
817            $this->chainBlockingSlotsType1($word, "ADJ");
818        }
819       
820        // QUAN JA TENIM POSADES TOTES LES PARAULES, RESOLEM ELS SLOTS ENCARA NO RESOLTS
821        // HI HAURÂ SLOTS AMB JA NOMËS UNA PARAULA O ALTRES SLOTS AMB VÀRIES PARAULES
822       
823        $mand2level = array();
824        $mand1level = array();
825        $subjectes = array();
826        $opts = array();
827       
828        // Ordenem els slots en differents arrays Mandatory 2on nivell, Mandatory 1er nivell, subjecte, opts
829        foreach ($this->slotarray as $keyslot => $slot) {
830           
831            if ($slot->level == 2) {
832                if ($slot->category == 'Subject') $subjectes[$keyslot] = $slot;
833                else if ($slot->grade == '1') $mand2level[$keyslot] = $slot;
834                else $opts[] = $slot;
835            }
836            else {
837                if ($slot->category == 'Subject') $subjectes[$keyslot] = $slot;
838                else if ($slot->grade == '1') $mand1level[$keyslot] = $slot;
839                else $opts[$keyslot] = $slot;
840            }
841        }
842       
843        $this->calculateVirtualOrder();
844        $this->disambiguateSlotsNew("ADJ");
845       
846        // un cop desambiguats tots els slots, veiem a quin slot fan millor de complements
847        // els adjs que no estan omplint ja un slot obligatori
848        // si estan omplint un slot opt, mirem si és millor com a slotopt o com a complement
849        // PER CADA ADJ
850        foreach ($arrayAdjs as $wordadj) {
851           
852            $slotfinalobl = false;
853            $slotfinalopt = false;
854            $keyslotfinal = $wordadj->slotfinal;
855           
856            // mirem si l'slot final, que no sigui de tipus complement, és obligatori o optatiu
857            if ($keyslotfinal != null) {
858                if (!strpos($keyslotfinal, "ADJ")) {
859                    if ($this->slotarray[$keyslotfinal]->grade == '1') {
860                        $slotfinalobl = true;
861                    }
862                    else if ($this->slotarray[$keyslotfinal]->grade == 'opt') {
863                        $slotfinalopt = true;
864                    }
865                }
866            }
867           
868            // si no és obligatori, busquem el millor slot al que pot complementar l'adj
869            if (!$slotfinalobl) {
870               
871                $puntsmillor = -1000;
872                $keymillor = null;
873                $keyparentmillor = null;
874                               
875                // per cada slot al llistat de temporals
876                foreach ($wordadj->slotstempsext as $auxtupla) {
877                   
878                    $keyaux = $auxtupla[0];
879                    $auxpunts = $auxtupla[1];
880                       
881                    // en cas d'empat volem els slot complements que entren més tard que els opts
882                    if ($auxpunts > $puntsmillor) {
883
884                        // extreiem també la key del parent slot al que complementa
885                        $auxstring = explode(" ", $keyaux);
886                        $keyparentaux;
887
888                        // agafem el key de l'slot que podia tenir el NC
889                        $numpartskeycompl = count($auxstring);
890                        if ($numpartskeycompl > 0) {
891                            // per si el compl era d'un slot de 2on nivell
892                            if ($numpartskeycompl == 4) $keyparentaux = $auxstring[0]." ".$auxstring[1];
893                            else $keyparentaux = $auxstring[0];
894                        }
895                       
896                        // si l'slot no té ja assignat un altre adj el podem escollir provisionalment
897                        if (!$this->slotarray[$keyparentaux]->CAdjassigned) {
898                            $puntsmillor = $auxpunts;
899                            $keymillor = $keyaux;
900                            $keyparentmillor = $keyparentaux;
901                        }                       
902                    }
903                }
904               
905                // si hem trobat el millor slot, el posem com a final de la paraula
906                // i a l'slot parent el posem al llistat de modificadors assignats
907                if ($puntsmillor > -1000) {
908                   
909                    // si omplia un slot opt, mirem si el fit és millor de complement que opt
910                    if ($slotfinalopt) {
911                       
912                        $slotopt = $this->slotarray[$keyslotfinal];
913                       
914                        // si el fit és millor, fem tot el procés de desassignar i assignar
915                        if ($puntsmillor >= $slotopt->puntsguanyats) {
916                           
917                            // desassignem
918                            $slotopt->full = false;
919                            $slotopt->paraulafinal = null;
920                            $slotopt->puntsfinal = 7;
921                            $slotopt->indexclassfinalword = 0;
922                           
923                            // assignem
924                            $wordadj->slotfinal = $keymillor;
925                            $wordadj->used = true;
926                            $wordadj->assignadaAComplement = true;
927
928                            $slotparent = $this->slotarray[$keyparentmillor];
929                            $slotparent->CAdjassigned = true;
930                            $slotparent->CAdjassignedkey = $keymillor;
931                        }
932                    }
933                    else {                       
934                        $wordadj->slotfinal = $keymillor;
935                        $wordadj->used = true;
936                        $wordadj->assignadaAComplement = true;
937
938                        $slotparent = $this->slotarray[$keyparentmillor];
939                        $slotparent->CAdjassigned = true;
940                        $slotparent->CAdjassignedkey = $keymillor;
941                    }
942                }
943            }
944        } // Fi de buscar per cada adj, a on fan millor de complement
945     
946    }
947   
948    public function solveModifs($arrayModifs)
949    {
950        $unusedModifs = array(); // noms no utilitzats a la primera ronda d'intents de fit
951        $usedModifs = array();
952       
953        $numModifs = count($arrayModifs);
954       
955        $verbless = false;
956                       
957        // Per cada modificador
958        for ($i=0; $i<$numModifs; $i++) {
959           
960            $word = $arrayModifs[$i];
961           
962            // si és de frase, i no és verbless, l'assignem al verb principal i ja està
963            if ($word->tipus == "modifier" && $word->propietats->scope == "phrase" && $this->defaulttense != "verbless") {
964               
965                $keymainverb = "Main Verb";
966               
967                if (isset ($this->slotarray["Main Verb 1"])) $keymainverb = "Main Verb 1";
968               
969                $slotverb = $this->slotarray[$keymainverb];
970               
971                $nummodsslot = count($slotverb->cmpMod);
972
973                $newslot = new Myslot();
974                $word->slotfinal = $keymainverb." MOD ".$nummodsslot; // per dir que està de compl.
975                $newslot->category = $slotverb->category." MOD";
976                $newslot->grade = "opt";
977                $newslot->full = true;
978                $newslot->paraulafinal = $word;
979                $newslot->level = $slotverb->level + 1;
980                $newslot->parent = $keymainverb;
981                $newslot->puntsfinal = 7; // Són els punts que resten un NC sobre 100
982                $newslot->indexclassfinalword = 0;
983
984                $slotverb->cmpMod[$keymainverb." MOD ".$nummodsslot] = $newslot;
985                $slotverb->CModassigned = true;
986                $slotverb->CModassignedkey[] = $keymainverb." MOD ".$nummodsslot;
987
988                $word->used = true;
989                $word->assignadaAComplement = true;
990               
991            }
992           
993            else {
994               
995                foreach ($this->slotarray as $keyslot => $slot) {
996                               
997                    $fittype = 0; // 1, si fit slot, 0 si no
998
999                    // passem el key de l'slot per si de cas hi ha subverb i els slots són de l'estil "Theme 1|2"
1000                    $fittype = $slot->modifFitsSlot($word, $keyslot);
1001
1002                    if ($fittype == 0) $unusedModifs[] = $word; // si no ha pogut anar a cap slot, no el fem servir
1003                    else $usedModifs[] = $word;
1004                }
1005
1006                // MIREM SI LA PARAULA NOMÉS HA POGUT FER FILL D'UN ÚNIC SLOT PER FER EL BLOCK CHAINING
1007                $this->chainBlockingSlotsType1($word, "MOD");
1008               
1009            }
1010                       
1011        }
1012       
1013        // QUAN JA TENIM POSADES TOTES LES PARAULES, RESOLEM ELS SLOTS ENCARA NO RESOLTS
1014        // HI HAURÂ SLOTS AMB JA NOMËS UNA PARAULA O ALTRES SLOTS AMB VÀRIES PARAULES
1015       
1016        $this->calculateVirtualOrder();
1017        $this->disambiguateSlotsNew("MOD");
1018                       
1019        // un cop desambiguats tots els slots, veiem a quin slot fan millor de complements
1020        // els modifs que no estan omplint ja un slot obligatori
1021        // PER CADA MODIF
1022       
1023        foreach ($arrayModifs as $wordmodif) {
1024           
1025            $slotfinalobl = false;
1026            $slotfinalopt = false;
1027            $slotfinaloptpunts = -1000;
1028            $keyslotfinal = $wordmodif->slotfinal;
1029           
1030            // mirem si l'slot final, que no sigui de tipus complement, és obligatori o optatiu
1031            if ($keyslotfinal != null) {
1032                if (!strpos($keyslotfinal, "MOD")) {
1033                    if ($this->slotarray[$keyslotfinal]->grade == '1') {
1034                        $slotfinalobl = true;
1035                    }
1036                    else if ($this->slotarray[$keyslotfinal]->grade == 'opt') {
1037                        $slotfinalopt = true;
1038                        $slotfinaloptpunts = $this->slotarray[$keyslotfinal]->puntsguanyats-0; 
1039                        // -0 -> en cas d'empat ja agafa el complement vs l'slot optatiu
1040                        // amb -1 ho penalitzaríem més perquè en cas d'altres empats
1041                        // es quedés amb el complement i no amb l'slot optatiu
1042                    }
1043                }
1044            }
1045           
1046            // si no és obligatori, busquem el millor slot al que pot complementar el modif
1047            // i si aquest slot supera a l'slot opt que ja hi ha
1048            if (!$slotfinalobl) {
1049               
1050                $puntsmillor = $slotfinaloptpunts;
1051                $keymillor = null;
1052                $keyparentmillor = null;
1053                $slotmillorat = false;
1054               
1055                // per cada slot al llistat de temporals
1056                foreach ($wordmodif->slotstempsext as $auxtupla) {
1057                                       
1058                    $keyaux = $auxtupla[0];
1059                    $auxpunts = $auxtupla[1];
1060                   
1061                    // si és de tipus complement
1062                    if (strpos($keyaux, "MOD")) {
1063                       
1064                        if ($auxpunts > $puntsmillor) {
1065                            // extreiem també la key del parent slot al que complementa
1066                            $auxstring = explode(" ", $keyaux);
1067                            $keyparentprov;
1068
1069                            // agafem el key de l'slot que podia tenir el NC
1070                            $numpartskeycompl = count($auxstring);
1071                            if ($numpartskeycompl > 0) {
1072                                // per si el compl era d'un slot de 2on nivell
1073                                if ($numpartskeycompl == 4) $keyparentprov = $auxstring[0]." ".$auxstring[1];
1074                                else $keyparentprov = $auxstring[0];
1075                            }
1076                           
1077                            // si no té un adverbi que ja el quantifiqui
1078                            if (isset($this->slotarray[$keyparentprov]) && !$this->slotarray[$keyparentprov]->CAdvassigned) {
1079                                $puntsmillor = $auxpunts;
1080                                $keymillor = $keyaux;
1081                                $keyparentmillor = $keyparentprov;
1082                                $slotmillorat = true;
1083                            }
1084                        }
1085                    }
1086                }
1087               
1088                // si hem trobat el millor slot, el posem com a final de la paraula
1089                // i a l'slot parent el posem al llistat de modificadors assignats
1090                if ($slotmillorat) {
1091                   
1092                    // si omplia un slot opt, desassignem la paraula d'aquest slot
1093                    if ($slotfinalopt) {
1094                       
1095                        $slotopt = $this->slotarray[$keyslotfinal];
1096                       
1097                        $slotopt->full = false;
1098                        $slotopt->paraulafinal = null;
1099                        $slotopt->puntsfinal = 7;
1100                        $slotopt->indexclassfinalword = 0;
1101                    }
1102                   
1103                    $wordmodif->slotfinal = $keymillor;
1104                    $wordmodif->used = true;
1105                    $wordmodif->assignadaAComplement = true;
1106                   
1107                    $slotparent = $this->slotarray[$keyparentmillor];
1108                    $slotparent->CModassigned = true;
1109                    $slotparent->CModassignedkey[] = $keymillor;
1110                }
1111            }
1112        } // Fi de buscar per cada modif, a on fan millor de complement
1113                       
1114    }
1115   
1116   
1117    function calculateVirtualOrder()
1118    {
1119        $this->virtualslotsort = array();
1120       
1121        foreach ($this->slotarray as $keyslot => $slot) {
1122           
1123            $aux = array();
1124            $aux[0] = $keyslot;
1125            $aux[1] = $slot->slotCalcPuntsGuanyats();
1126            $aux[2] = $slot->grade;
1127            $aux[3] = $slot->level;
1128           
1129            if (!$slot->full && count($slot->paraulestemp) > 0) $this->virtualslotsort[] = $aux;
1130        }
1131               
1132        $this->mySort($this->virtualslotsort);
1133       
1134        // DEBUG:
1135        // print_r($this->virtualslotsort);
1136        // echo "<br /><br />";
1137       
1138    }
1139   
1140    function mySort($virtualslotorder)
1141    {
1142        $auxorder = array();
1143       
1144        for ($i=0; $i<count($virtualslotorder); $i++) {
1145           
1146            $infoaux = $virtualslotorder[$i]; 
1147            $j=0;
1148            $indexinsert = 0;
1149            $found = false;
1150           
1151            while(!$found) {
1152               
1153                $numauxorder = count($auxorder);
1154               
1155                // si hem arribat al final d'auxorder
1156                if ($j == $numauxorder) {
1157                    $indexinsert = $j;
1158                    $found = true;
1159                }
1160                else {
1161                    $infoactual = $auxorder[$j];
1162                    // si és més gran volem que l'inserti abans
1163                    if ($infoaux[1] > $infoactual[1]) {
1164                        $indexinsert = $j;
1165                        $found = true;
1166                    }
1167                    else if ($infoaux[1] == $infoactual[1]) {
1168                       
1169                        // DEBUG:
1170                        // echo "Infoaux: "; print_r($infoaux); echo "/ Infoactual: "; print_r($infoactual);
1171                       
1172                       
1173                        // en cas d'empat, si és són del mateix grade i del mateix nivell o el Receiver té més grade,
1174                        // el receiver té prioritat sobre el qualsevol slot, excepte el Theme, si no és pseudoimpersonal
1175                        if (strpos($infoaux[0], "Receiver") === 0 && !($infoaux[3] == 2 && (strpos($infoactual[0], "Subject 1") === 0))
1176                                && !($infoaux[2] == "opt" && $infoactual[2] == '1') 
1177                                && !(strpos($infoactual[0], "Theme") === 0) && !$this->pseudoimpersonal) {
1178                            $indexinsert = $j;
1179                            $found = true;
1180                        }
1181                        // els slots secundaris tenen preferència sobre els de primer nivell
1182                        // menys si és el subjecte
1183                        else if (strpos($infoaux[0], "2") != 0 && !(strpos($infoactual[0], "Subject") === 0) && !$this->pseudoimpersonal) {
1184                            $indexinsert = $j;
1185                            $found = true;
1186                        }
1187                        // si és pseudoimpersonal el Receiver 1 té més importància que els slots de segon nivell
1188                        else if ($this->pseudoimpersonal && strpos($infoaux[0], "Receiver") === 0 && strpos($infoactual[0], "2") != 0) {
1189                            $indexinsert = $j;
1190                            $found = true;   
1191                        }
1192                    }
1193                }
1194                $j++;
1195            }
1196           
1197            array_splice($auxorder, $indexinsert, 0, array($infoaux)); // construim l'array ordenat
1198        }
1199        $this->virtualslotsort = $auxorder;
1200    }
1201   
1202    // Per quan una paraula només fa fit a 1 slot (no NC, ADJ, ADV, MOD)
1203    function chainBlockingSlotsType1($word, $stringCMP)
1204    {       
1205       
1206        if (count($word->slotstemps) == 1) {
1207                           
1208            $slotkey = $word->slotstemps[0];
1209            $word->slotfinal = $slotkey;
1210            $word->slotstemps = array(); // esborrem el llistat d'slots
1211           
1212            // DEBUG
1213            // echo $word->text;
1214           
1215            if (isset($this->slotarray[$slotkey])) { // si trobem l'slot dins el pattern. Els NC no es troben
1216                                                     // però com que se'n crea un per paraula, ja estan tractats
1217               
1218                $slotaux = $this->slotarray[$slotkey];
1219               
1220                if (!$slotaux->full) { // si no ha estat ja tractat
1221                   
1222                    // Passem la paraula com a final de l'slot (+ tot el que calgui) i bloquegem l'slot
1223                    $indexinslot = $slotaux->searchIndexWordInSlot($word);
1224                   
1225                    $penalty = $slotaux->paraulestemp[$indexinslot][1];
1226                   
1227                    $indexclassfinalword = $slotaux->paraulestemp[$indexinslot][2];
1228                   
1229                    $this->forceFillSlot($slotkey, $word, $penalty, $indexclassfinalword);
1230                   
1231                    // Esborrem la paraula del llistat temporal i reiniciem els index de l'array de paraulestemp
1232                    // unset($slotaux->paraulestemp[$indexinslot]);
1233                   
1234                    array_splice($slotaux->paraulestemp, $indexinslot, 1);
1235                    // $slotaux->paraulestemp = array_values($slotaux->paraulestemp);
1236                   
1237                    $wordaux;
1238                   
1239                    // per cada paraula que hi havia al llistat temporal
1240                    for ($i=0; $i<count($slotaux->paraulestemp); $i++) {
1241                       
1242                        $wordaux = $slotaux->paraulestemp[$i][0];
1243                       
1244                        // Buscar l'slot, esborrar l'slot i fer chainblocking de la paraula
1245                        $indexslot = $wordaux->searchSlotIndex($slotkey);
1246                       
1247                        if ($indexslot != -1) {
1248                            array_splice($wordaux->slotstemps, $indexslot, 1);
1249                            // $wordaux->slotstemps = array_values($wordaux->slotstemps);
1250                           
1251                            $this->chainBlockingSlotsType1($wordaux, $stringCMP);
1252                        }
1253                    }
1254                }
1255            }
1256            else if ($stringCMP == "NC") { // si era de NC
1257               
1258                $word->used = true;
1259                $keyparent = null;
1260                $auxstring = explode(" ", $slotkey);
1261                // agafem el key de l'slot que podia tenir el NC
1262                $numpartskeycompl = count($auxstring);
1263                if ($numpartskeycompl > 0) {
1264                    // per si el compl era d'un slot de 2on nivell
1265                    if ($numpartskeycompl == 4) $keyparent = $auxstring[0].$auxstring[1];
1266                    else $keyparent = $auxstring[0];
1267                }
1268               
1269                if ($keyparent != null) {
1270
1271                    // indiquem que ara l'slot superior té un NC assignat
1272                    $this->slotarray[$keyparent]->NCassigned = true;
1273                    $this->slotarray[$keyparent]->NCassignedkey = $slotkey;
1274                }
1275            }
1276        }
1277    }
1278   
1279   
1280    // Per quan una paraula podia anar a varis slots i un és el seleccionat com a millor opció
1281    function chainBlockingSlotsType2($word)
1282    {
1283       
1284    }
1285   
1286   
1287    /*function disambiguateSlots($arraySlots, $stringCMP)
1288    {
1289        foreach ($arraySlots as $keyslot => $slot) {
1290            $indexselect = -1;
1291            $penalty = 1000;
1292           
1293            if (!$slot->full && count($slot->paraulestemp) > 0) {
1294                // per cada paraula que podia anar a l'slot busquem la que fa millor fit
1295                for ($i=0; $i<count($slot->paraulestemp); $i++) {
1296                    if ($slot->paraulestemp[$i][1] < $penalty) {
1297                        $penalty = $slot->paraulestemp[$i][1];
1298                        $indexselect = $i;
1299                    }
1300                    // si dues paraules estan empatades i omplen igual de bé l'slot
1301                    else if ($slot->paraulestemp[$i][1] == $penalty) {
1302                        if ($slot->category != "Subjecte") { // si l'slot no és de categoria subjecte
1303                            if (!$slot->paraulestemp[$i][0]->beforeverb && $slot->paraulestemp[$indexselect][0]->beforeverb) {
1304                                $penalty = $slot->paraulestemp[$i][1];
1305                                $indexselect = $i;
1306                            }
1307                            // potser no cal xq les paraules han estat introduïdes en ordre als slots
1308                            else if ($slot->paraulestemp[$i][0]->inputorder < $slot->paraulestemp[$indexselect][0]->inputorder) {
1309                                $penalty = $slot->paraulestemp[$i][1];
1310                                $indexselect = $i;
1311                            }
1312                        }
1313                        else { // si és de categoria subjecte
1314                            // només fem el canvi si la nova és before verb i l'altre no
1315                            if ($slot->paraulestemp[$i][0]->beforeverb && !$slot->paraulestemp[$indexselect][0]->beforeverb) {
1316                                $penalty = $slot->paraulestemp[$i][1];
1317                                $indexselect = $i;
1318                            }
1319                        }
1320                    }
1321                }
1322
1323                // Ja tenim la paraula seleccionada
1324                $wordaux = $slot->paraulestemp[$indexselect][0];
1325                $this->forceFillSlot($keyslot, $wordaux, $slot->paraulestemp[$indexselect][1], $slot->paraulestemp[$indexselect][2]);
1326               
1327                // esborrem la paraula del llistat de paraulestemp de l'slot
1328                array_splice($slot->paraulestemp, $indexselect, 1);
1329               
1330                // esborrem l'slot del llistat d'slots temps de la paraula
1331                $indexslotaux = $wordaux->searchSlotIndex($keyslot);
1332                if ($indexslotaux != -1) array_splice($wordaux->slotstemps, $indexslotaux, 1);
1333               
1334                // per la resta d'slots que quedin esborrem la paraula del llistat de paraulestemp
1335                for ($i=0; $i<count($wordaux->slotstemps); $i++) {
1336                    $keyaux = $wordaux->slotstemps[$i];
1337                    // Si no és de tipus NC que tractarem més endavant
1338                    if (!strpos($keyaux, $stringCMP)) {
1339                        $slotaux = $this->slotarray[$keyaux];
1340                        $indexinslot = $slotaux->searchIndexWordInSlot($wordaux);
1341
1342                        // esborrem la paraula seleccionada
1343                        if ($indexinslot != -1) array_splice($slotaux->paraulestemp, $indexinslot, 1);
1344                    }
1345                }
1346               
1347                // per la resta de paraules que podien anar a l'slot esborrem l'slot del llistat de slotstemps
1348                for ($i=0; $i<count($slot->paraulestemp); $i++) {
1349                    $wordaux2 = $slot->paraulestemp[$i][0];
1350                    $indexslotaux2 = $wordaux2->searchSlotIndex($keyslot);
1351                   
1352                    if ($indexslotaux2 != -1) array_splice($wordaux2->slotstemps, $indexslotaux2, 1);
1353                }
1354            }   // Fi si l'slot no estava ja ple i almenys tenia alguna paraula que podia fer fit         
1355        } // Fi de per cada slot
1356    }
1357    */
1358   
1359    function disambiguateSlotsNew($stringCMP)
1360    {
1361        $CI = &get_instance();
1362       
1363        // agafem el tipus d'idioma, ja que per desambiguar si l'idioma és svo
1364        // les paraules que vagin abans del verb tindran punts extra per fer de subjecte
1365        // i les que vagin darrere per fer dels altres slots
1366        $langtype = $CI->session->userdata('uinterfacelangtype');
1367       
1368        $svo = true;
1369        if ($langtype != 'svo') $svo = false;
1370       
1371        $numslots = count($this->virtualslotsort);
1372       
1373        $slotsleft = true;
1374        if ($numslots == 0) $slotsleft = false;
1375       
1376        while ($slotsleft) {
1377           
1378            // DEBUG
1379            // echo "Pattern id ".$this->id.": ";
1380            // print_r($this->virtualslotsort); echo '<br />';
1381                                           
1382            $infoslot = $this->virtualslotsort[0];
1383            $keyslot = $infoslot[0];
1384            $slot = $this->slotarray[$keyslot];
1385           
1386            $indexselect = -1;
1387            $penalty = 1000;
1388                       
1389            if (!$slot->full && count($slot->paraulestemp) > 0) {
1390               
1391                // per cada paraula que podia anar a l'slot busquem la que fa millor fit
1392                for ($i=0; $i<count($slot->paraulestemp); $i++) {
1393                    // si la paraula no ha estat ja utilitzada
1394                    if (!$slot->paraulestemp[$i][0]->used) {
1395                   
1396                        if ($slot->paraulestemp[$i][1] < $penalty) {
1397                            $penalty = $slot->paraulestemp[$i][1];
1398                            $indexselect = $i;
1399                        }
1400                        // si dues paraules estan empatades i omplen igual de bé l'slot
1401                        else if ($slot->paraulestemp[$i][1] == $penalty) {
1402                            // si l'idioma té estructura SVO
1403                            if ($svo) {
1404                                if ($slot->category != "Subjecte") { // si l'slot no és de categoria subjecte
1405                                    if (!$slot->paraulestemp[$i][0]->beforeverb && $slot->paraulestemp[$indexselect][0]->beforeverb) {
1406                                        $penalty = $slot->paraulestemp[$i][1];
1407                                        $indexselect = $i;
1408                                    }
1409                                    // potser no cal xq les paraules han estat introduïdes en ordre als slots
1410                                    else if ($slot->paraulestemp[$i][0]->inputorder < $slot->paraulestemp[$indexselect][0]->inputorder) {
1411                                        $penalty = $slot->paraulestemp[$i][1];
1412                                        $indexselect = $i;
1413                                    }
1414                                }
1415                                else { // si és de categoria subjecte
1416                                    // només fem el canvi si la nova és before verb i l'altre no
1417                                    if ($slot->paraulestemp[$i][0]->beforeverb && !$slot->paraulestemp[$indexselect][0]->beforeverb) {
1418                                        $penalty = $slot->paraulestemp[$i][1];
1419                                        $indexselect = $i;
1420                                    }
1421                                }
1422                            }
1423                            // si no té estructura SVO
1424                            else {
1425                                // es quedarà amb la primera paraula que podia fer fit a l'slot
1426                                if ($slot->paraulestemp[$i][0]->inputorder < $slot->paraulestemp[$indexselect][0]->inputorder) {
1427                                    $penalty = $slot->paraulestemp[$i][1];
1428                                    $indexselect = $i;
1429                                }
1430                            }
1431                        }
1432                    }
1433                }
1434               
1435                if ($indexselect == -1 ) $indexselect = 0;
1436                               
1437                // Ja tenim la paraula seleccionada
1438                $wordaux = $slot->paraulestemp[$indexselect][0];
1439                $this->forceFillSlot($keyslot, $wordaux, $slot->paraulestemp[$indexselect][1], $slot->paraulestemp[$indexselect][2]);
1440                               
1441                // esborrem la paraula del llistat de paraulestemp de l'slot
1442                array_splice($slot->paraulestemp, $indexselect, 1);
1443                                               
1444                // esborrem l'slot del llistat d'slots temps de la paraula
1445                $indexslotaux = $wordaux->searchSlotIndex($keyslot);
1446                if ($indexslotaux != -1) array_splice($wordaux->slotstemps, $indexslotaux, 1);
1447                               
1448                // per la resta d'slots que quedin esborrem la paraula del llistat de paraulestemp
1449                for ($i=0; $i<count($wordaux->slotstemps); $i++) {
1450                    $keyaux = $wordaux->slotstemps[$i];
1451                    // Si no és de tipus NC que tractarem més endavant
1452                    if (!strpos($keyaux, $stringCMP)) {
1453                        $slotaux = $this->slotarray[$keyaux];
1454                        $indexinslot = $slotaux->searchIndexWordInSlot($wordaux);
1455                       
1456                        // esborrem la paraula seleccionada
1457                        if ($indexinslot != -1) array_splice($slotaux->paraulestemp, $indexinslot, 1);
1458                    }
1459                }
1460               
1461                // per la resta de paraules que podien anar a l'slot esborrem l'slot del llistat de slotstemps
1462                for ($i=0; $i<count($slot->paraulestemp); $i++) {
1463                    $wordaux2 = $slot->paraulestemp[$i][0];
1464                    $indexslotaux2 = $wordaux2->searchSlotIndex($keyslot);
1465                   
1466                    if ($indexslotaux2 != -1) array_splice($wordaux2->slotstemps, $indexslotaux2, 1);
1467                }
1468                $slot->paraulestemp = array(); // eliminem totes les paraules que podien anar a l'slot
1469            }   // Fi si l'slot no estava ja ple i almenys tenia alguna paraula que podia fer fit   
1470           
1471            // recalculem la preferència dels slots
1472            $this->calculateVirtualOrder();
1473                       
1474            if (count($this->virtualslotsort) == 0) $slotsleft = false;
1475           
1476        } // Fi de per cada slot
1477    }
1478   
1479    public function calcPuntsFinalPattern()
1480    {
1481        // ens diu si una paraula introduïda no s'ha utilitzat al patró
1482        $paraulanoposada = false;
1483               
1484        foreach ($this->slotarray as $slot) {
1485                       
1486            if ($slot->full) {
1487                // compensem que si un slot obligatori és un perfect fill, que el triï sobre un slot opt d'un altre patró
1488                if ($slot->grade == '1' && $slot->puntsfinal == 0) $this->puntuaciofinal += 1;
1489                else $this->puntuaciofinal -= $slot->puntsfinal;
1490               
1491                // echo $slot->category.": ".$slot->puntsfinal." (".$slot->paraulafinal->text.')<br />';
1492                // punts de coordinacions
1493                $wordaux = $slot->paraulafinal;
1494                if (count($wordaux->paraulacoord) > 0) $this->puntuaciofinal += 7;
1495               
1496                if ($slot->NCassigned) {
1497                    $slotcomp = $slot->complements[$slot->NCassignedkey];
1498                    $this->puntuaciofinal += $slotcomp->puntsfinal;
1499                   
1500                    // echo $slot->NCassignedkey.": ".$slotcomp->puntsfinal.'<br />';
1501                    // punts de coordinacions
1502                    $wordaux = $slotcomp->paraulafinal;
1503                    if ($wordaux->paraulacoord != null) $this->puntuaciofinal += 7;
1504                }
1505                if ($slot->CAdvassigned) {
1506                    $slotcomp = $slot->cmpAdvs[$slot->CAdvassignedkey];
1507                    $this->puntuaciofinal += $slotcomp->puntsfinal;
1508                   
1509                    // echo $slot->CAdvassignedkey.": ".$slotcomp->puntsfinal.'<br />';
1510                    // punts de coordinacions
1511                    $wordaux = $slotcomp->paraulafinal;
1512                    if (count($wordaux->paraulacoord) > 0) $this->puntuaciofinal += 7;
1513                }
1514                if ($slot->CAdjassigned) {
1515                    $slotcomp = $slot->cmpAdjs[$slot->CAdjassignedkey];
1516                    $this->puntuaciofinal += $slotcomp->puntsfinal;
1517                   
1518                    // echo $slot->CAdjassignedkey.": ".$slotcomp->puntsfinal.'<br />';
1519                    // punts de coordinacions
1520                    $wordaux = $slotcomp->paraulafinal;
1521                    if (count($wordaux->paraulacoord) > 0) $this->puntuaciofinal += 7;
1522                }
1523                if ($slot->CModassigned) {
1524                    // un slot pot tenir varis modificadors assignats
1525                    foreach ($slot->CModassignedkey as $keymod) {
1526                        $slotcomp = $slot->cmpMod[$keymod];
1527                        $this->puntuaciofinal += $slotcomp->puntsfinal;
1528                        // punts de coordinacions
1529                        $wordaux = $slotcomp->paraulafinal;
1530                        if (count($wordaux->paraulacoord) > 0) $this->puntuaciofinal += 7;
1531                    }
1532                }
1533               
1534                // sumem les expressions de temps (advs)
1535                $numtemps = count($this->timeexpr);
1536                for ($i=0; $i<$numtemps; $i++) $this->puntuaciofinal += 7;
1537               
1538                $numexprs = count($this->exprsarray);
1539               
1540                // si necessitava una expressió i no hi és, li restem 25 punts
1541                if ($this->needexpr && $numexprs == 0) $this->puntuaciofinal -= 25;
1542                // si no, sumem 1 punt per expressió
1543                else {
1544                    for ($i=0; $i<$numexprs; $i++) $this->puntuaciofinal += 1;
1545                }
1546               
1547            }
1548            else {
1549                // restem els punts dels slots no plens
1550                // els optatius de time, manera, locat, locfrom que la majoria poden tenir no els restem
1551                // perquè si no els patterns amb pocs slots, que no els tenen tindrien avantatge
1552                if ($slot->grade == '1' || ($slot->category != "Manner" && $slot->category != "Time" 
1553                        && $slot->category != "LocAt" && $slot->category != "LocFrom" && $slot->category != "Company" && $slot->category != "Tool")) {
1554                    $this->puntuaciofinal -= $slot->puntsfinal;
1555                    // echo $slot->category.": -".$slot->puntsfinal.'<br />';
1556                }
1557                // que resti un punt pels slots anteriors no plens
1558                else if ($slot->category == "Company" || $slot->category == "Tool") {
1559                    $this->puntuaciofinal -= 1;
1560                }
1561            }
1562        } // Fi per cada slot
1563               
1564        // restem els punts de les paraules no fetes servir (les expressions no conten i
1565        // les preguntes tampoc (aquestes ja es tracten prèviament si no hi ha lloc per la
1566        // partícula de la pregunta)
1567        for ($i=0; $i<count($this->paraules); $i++) {
1568            if ($this->paraules[$i]->used == false && $this->paraules[$i]->tipus != "expression"
1569                    && $this->paraules[$i]->tipus != "questpart") {
1570                $this->puntuaciofinal -= 25;
1571                $paraulanoposada = true;
1572            }
1573        }
1574       
1575        // retorna un array on [0] = puntuaciofinal i [1] = si no ha pogut posar alguna paraula
1576        $aux = array();
1577        $aux[0] = $this->puntuaciofinal;
1578        $aux[1] = $paraulanoposada;
1579               
1580        return $aux;
1581    }
1582
1583
1584    // Imprimir el pattern
1585    public function printPattern()
1586    {
1587        $string = "";
1588       
1589        $string = "+++++++++++BEGIN PATTERN+++++++++++++<br /><br />";
1590       
1591        $string .= "Score: ".$this->puntuaciofinal.' --> Pattern ID: '.$this->id.'<br /><br />';
1592       
1593        foreach ($this->slotarray as $keyslot => $slot) {
1594           
1595            if ($slot->full) {
1596                $string .= "Slot: ".$keyslot." = ".$slot->paraulafinal->text;
1597                // tractem les coordinacions
1598                $wordaux = $slot->paraulafinal;
1599                if (count($wordaux->paraulacoord) > 0) {
1600                    for ($k=0; $k<count($wordaux->paraulacoord); $k++) {
1601                        $string .= " (i ".$wordaux->paraulacoord[$k]->text.")";
1602                    }
1603                }
1604               
1605                if ($slot->NCassigned) {
1606                    $slotcomp = $slot->complements[$slot->NCassignedkey];
1607                    $string .= " --> NC = ".$slotcomp->paraulafinal->text;
1608                    // tractem les coordinacions
1609                    $wordaux = $slotcomp->paraulafinal;
1610                    if (count($wordaux->paraulacoord) > 0) {
1611                        for ($k=0; $k<count($wordaux->paraulacoord); $k++) {
1612                            $string .= " (i ".$wordaux->paraulacoord[$k]->text.")";
1613                        }
1614                    }
1615                }
1616                if ($slot->CAdvassigned) {
1617                    $slotcomp = $slot->cmpAdvs[$slot->CAdvassignedkey];
1618                    $string .= " --> ADV = ".$slotcomp->paraulafinal->text;
1619                    // tractem les coordinacions
1620                    $wordaux = $slotcomp->paraulafinal;
1621                    if (count($wordaux->paraulacoord) > 0) {
1622                        for ($k=0; $k<count($wordaux->paraulacoord); $k++) {
1623                            $string .= " (i ".$wordaux->paraulacoord[$k]->text.")";
1624                        }
1625                    }                }
1626                if ($slot->CAdjassigned) {
1627                    $slotcomp = $slot->cmpAdjs[$slot->CAdjassignedkey];
1628                    $string .= " --> ADJ = ".$slotcomp->paraulafinal->text;
1629                    // tractem les coordinacions
1630                    $wordaux = $slotcomp->paraulafinal;
1631                    if (count($wordaux->paraulacoord) > 0) {
1632                        for ($k=0; $k<count($wordaux->paraulacoord); $k++) {
1633                            $string .= " (i ".$wordaux->paraulacoord[$k]->text.")";
1634                        }
1635                    }
1636                }
1637                if ($slot->CModassigned) {
1638                    // un slot pot tenir varis modificadors assignats
1639                    foreach ($slot->CModassignedkey as $keymod) {
1640                        $slotcomp = $slot->cmpMod[$keymod];
1641                        $string .= " --> MOD = ".$slotcomp->paraulafinal->text;
1642                        // tractem les coordinacions
1643                        $wordaux = $slotcomp->paraulafinal;
1644                        if (count($wordaux->paraulacoord) > 0) {
1645                            for ($k=0; $k<count($wordaux->paraulacoord); $k++) {
1646                                $string .= " (i ".$wordaux->paraulacoord[$k]->text.")";
1647                            }
1648                        }
1649                    }
1650                }
1651                $string .= "<br /><br />";
1652            }
1653        }
1654       
1655        // escrivim els adverbis de temps
1656        $numtemps = count($this->timeexpr);
1657        if ($numtemps > 0) {
1658            $string .= "Slot: Time Expr = ";
1659            for ($i=0; $i<$numtemps; $i++) {
1660                $string .= $this->timeexpr[$i]->text."; ";
1661            }
1662            $string .= '<br /><br />';
1663        }
1664       
1665        // escrivim les expressions
1666        $numexpr = count($this->exprsarray);
1667        if ($numexpr > 0) {
1668            $string .= "Slot: Expressions = ";
1669            for ($i=0; $i<$numexpr; $i++) {
1670                $string .= $this->exprsarray[$i][0]."; ";
1671            }
1672            $string .= '<br /><br />';
1673        }
1674       
1675        $string .= "+++++++++++END PATTERN++++++++++++++<br />";
1676       
1677        return $string;
1678    }
1679   
1680    public function printAllPattern()
1681    {
1682        // PER DEBUG
1683        echo "<br />++++++++++++++++++++BEGIN PATTERN+++++++++++++++++++++++<br /><br />";
1684       
1685        foreach ($this->slotarray as $keyslot => $slot) {
1686           
1687                echo "Slot: ".$keyslot." = ".$slot->puntsfinal.' / '.$slot->puntsguanyats;
1688                if ($slot->full) echo " FULL";
1689                if (count($slot->cmpAdjs) > 0) {
1690                    foreach ($slot->cmpAdjs as $slotcomp) {
1691                       echo " --> ADJ = ".$slotcomp->paraulafinal->text; 
1692                    }
1693                }
1694                echo "<br /><br />";
1695        }
1696       
1697        echo "++++++++++++++++++++END PATTERN++++++++++++++++++++++++<br /><br /><br />";
1698    }
1699   
1700   
1701    /*
1702     * FUNCIONS PEL GENERADOR
1703     */
1704   
1705    // Ordena els slots de la frase: ÉS EL PRIMER PAS DEL GENERADOR
1706    public function ordenarSlotsFrase($propietatsfrase)
1707    {
1708        $CI = &get_instance();
1709        $CI->load->library('Mymatching');
1710        $CI->load->library('Myslot');
1711        $CI->load->library('Myword');
1712        $matching = new Mymatching();
1713       
1714        //agafem si l'usuari parla en masculí o en femení pel generador
1715        if ($CI->session->userdata('isfem') == '1') $this->isfem = true;
1716       
1717        // agafem si la frase és negativa
1718        $this->frasenegativa = $propietatsfrase['negativa'];
1719               
1720        // ADVS TEMPS
1721
1722        // mirar adverbis de temps, per si n'hi ha dels que van a davant de la frase
1723        $numadvstemps = count($this->timeexpr);
1724       
1725        for ($i=0; $i<$numadvstemps; $i++) {
1726            $wordaux = $this->timeexpr[$i];
1727           
1728            if ($matching->isFrontAdvTemps($wordaux->text)) {
1729
1730                // el posem davant de la frase
1731                $this->frasefinal .= $wordaux->text." ";
1732            }
1733        }
1734       
1735       
1736        // SI SUBJ2 == JO -> SUBJ2 = SUBJ1
1737       
1738        // si hi ha subverb i el subjecte 2 no està definit, si el defvalue era "jo", que el subj2 s'ompli
1739        // amb el subj1 (defvalue o word que fa fill)
1740        if ($this->subverb) {
1741            if (isset($this->slotarray["Subject 2"])) {
1742                if (!$this->slotarray["Subject 2"]->full && $this->slotarray["Subject 2"]->defvalue == '1') {
1743                   
1744                    // si el subj1 tindrà un defvalue assignat passem aquest valor al subj2
1745                    if (isset($this->slotarray["Subject 1"]) && !$this->slotarray["Subject 1"]->full) {
1746                        $this->slotarray["Subject 2"]->defvalue = $this->slotarray["Subject 1"]->defvalue;
1747                    }
1748                    // si el subj 1 té una paraula que l'omple, passem la paraula al subj2
1749                    else if (isset($this->slotarray["Subject 1"])) {
1750                        $this->slotarray["Subject 2"]->full = true;
1751                        $this->slotarray["Subject 2"]->paraulafinal = $this->slotarray["Subject 1"]->paraulafinal;
1752                        $this->slotarray["Subject 2"]->indexclassfinalword = $this->slotarray["Subject 1"]->indexclassfinalword;
1753                    }
1754                   
1755                }
1756            }
1757        }
1758       
1759       
1760        // ORDRE NORMAL
1761       
1762        $counter = 0;
1763        $indexmainverb = 0;
1764        $indexsecondaryverb = null;
1765        $indexpartpregunta = null;
1766       
1767        // posem tots els slots en l'ordre normal
1768        foreach ($this->slotarray as $keyslot => $slot) {
1769           
1770            if ($slot->full || $slot->grade == '1') {
1771                // si no estava ple, vol dir que era un obligatori i l'omplim amb el valor per defecte
1772                if (!$slot->full) {
1773                    // si la frase és una ordre o una pregunta, el subj per defecte passa a ser "tu"
1774                    if (($propietatsfrase['tipusfrase'] == "ordre" || $propietatsfrase['tipusfrase'] == "pregunta") 
1775                            && $slot->category == "Subject" && $slot->level == 1) {
1776                        $slot->defvalue = '2';
1777                    }
1778                    $slot->full = true;
1779                    $slot->defvalueused = true;
1780                }
1781                // busquem si hi ha una partícula de pregunta, que només poden ser a slots plens
1782                else {
1783                    if ($slot->category == "PartPreguntaNoSlot" || $slot->paraulafinal->tipus == "questpart") {
1784                        $indexpartpregunta = $counter;
1785                    }
1786                }
1787                if ($slot->category == "Main Verb") $indexmainverb = $counter;
1788                if ($slot->category == "Secondary Verb") $indexsecondaryverb = $counter;
1789               
1790                $this->ordrefrase[] = $keyslot;
1791                $counter += 1;
1792            }
1793        }
1794       
1795       
1796        // MODIFICADORS INICI DE FRASE
1797       
1798        // tractem els modificadors de frase que estan enganxats al verb principal
1799        $keymainverb = "Main Verb";
1800        if (isset($this->slotarray["Secondary Verb 2"])) $keymainverb .= " 1";
1801        $slotmainverb = $this->slotarray[$keymainverb];
1802        $nummodifsfrase = count($slotmainverb->CModassignedkey);
1803        for ($i=0; $i<$nummodifsfrase; $i++) {
1804            $keymodifaux = $slotmainverb->CModassignedkey[$i];
1805            $slotmodifaux = $slotmainverb->cmpMod[$keymodifaux];
1806           
1807            // si no és del grup que va darrere el subjecte el posem al principi de la frase (ex: si, perquè, però)
1808            if (!$matching->isModAfterSubj($slotmodifaux->paraulafinal->text)) {
1809               
1810                $this->frasefinal = " ".$slotmodifaux->paraulafinal->text." ".$this->frasefinal;
1811            }
1812            // marquem si la frase és negativa pel modificador no
1813            else if ($slotmodifaux->paraulafinal->text == "no") $this->frasenegativa = true;
1814        }
1815       
1816        // THEME PRONOMINAL HO, JO, TU
1817       
1818        $indextheme1 = null;
1819        $indextheme2 = null;
1820               
1821        // busquem si té un slot de theme que sigui pronominal "ho", "jo", "tu"
1822        for($i=0; $i<count($this->ordrefrase); $i++) {
1823           
1824            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
1825            if ($slotaux->category == "Theme") {
1826                // si està en forma de pronom
1827                if ($slotaux->defvalueused && ($slotaux->defvalue == "ho" || $slotaux->defvalue == "jo"
1828                        || $slotaux->defvalue == "tu")) {
1829                    if ($slotaux->level == 1) $indextheme1 = $i;
1830                    if ($slotaux->level == 2) $indextheme2 = $i;
1831                }
1832            }
1833        }
1834       
1835        if ($indextheme1 != null) {
1836            $temp = $this->ordrefrase[$indextheme1];
1837            // esborrem el theme 1 per moure'l de lloc
1838            array_splice($this->ordrefrase, $indextheme1, 1);
1839           
1840            // si la frase és un ordre i no és negativa
1841            if ($propietatsfrase['tipusfrase'] == "ordre" && !$this->frasenegativa) {
1842                // l'insertem just després del main verb
1843                array_splice($this->ordrefrase, $indexmainverb+1, 0, $temp);
1844            }
1845            else {
1846                // l'insertem just abans del main verb
1847                array_splice($this->ordrefrase, $indexmainverb, 0, $temp);
1848            }
1849        }
1850        // fem el mateix amb el theme 2, si hi és
1851        if ($indextheme2 != null) {
1852            $temp = $this->ordrefrase[$indextheme2];
1853            // esborrem el theme 1 per moure'l de lloc
1854            array_splice($this->ordrefrase, $indextheme2, 1);
1855            // l'insertem just abans del verb secundari
1856            array_splice($this->ordrefrase, $indexsecondaryverb, 0, $temp);
1857        }
1858       
1859       
1860        // RECEIVER PRONOMINAL
1861        // anirà abans que un theme pronominal, per això va després a l'algoritme
1862       
1863        $indexreceiver1 = null;
1864        $indexreceiver2 = null;
1865               
1866        // busquem si té un slot de receiver que sigui pronominal i el posem abans del verb principal
1867        for($i=0; $i<count($this->ordrefrase); $i++) {
1868           
1869            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
1870            if ($slotaux->category == "Receiver") {
1871                $wordslotauxfinal = $slotaux->paraulafinal;
1872                // si està en forma de pronom (només de tu, jo)
1873                if ($slotaux->defvalueused || $wordslotauxfinal->isClass("pronoun")) {
1874                    if ($slotaux->level == 1) $indexreceiver1 = $i;
1875                    if ($slotaux->level == 2) $indexreceiver2 = $i;
1876                }
1877            }
1878        }
1879       
1880        if ($indexreceiver1 != null) {
1881            $temp = $this->ordrefrase[$indexreceiver1];
1882            // esborrem el receiver 1 per moure'l de lloc
1883            array_splice($this->ordrefrase, $indexreceiver1, 1);
1884           
1885            // si la frase és un ordre
1886            if ($propietatsfrase['tipusfrase'] == "ordre" && !$this->frasenegativa) {
1887                // l'insertem just després del main verb
1888                array_splice($this->ordrefrase, $indexmainverb+1, 0, $temp);
1889            }
1890            else {
1891                // l'insertem just abans del main verb
1892                array_splice($this->ordrefrase, $indexmainverb, 0, $temp);
1893            }
1894        }
1895        // fem el mateix amb el receiver 2, si hi és
1896        if ($indexreceiver2 != null) {
1897            $temp = $this->ordrefrase[$indexreceiver2];
1898            // esborrem el receiver 1 per moure'l de lloc
1899            array_splice($this->ordrefrase, $indexreceiver2, 1);
1900            // l'insertem just abans del verb secundari
1901            array_splice($this->ordrefrase, $indexsecondaryverb, 0, $temp);
1902        }
1903       
1904        // THEME PRONOMINAL -> JO / TU / ELL... si no té una preposició davant
1905               
1906        $indextheme1 = null;
1907        $indextheme2 = null;
1908               
1909        // busquem si té un slot de theme que sigui pronominal i el posem abans del verb principal
1910        for($i=0; $i<count($this->ordrefrase); $i++) {
1911           
1912            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
1913                       
1914            if ($slotaux->category == "Theme" && $slotaux->prep == null) {
1915                               
1916                $wordslotauxfinal = $slotaux->paraulafinal;
1917                // si està en forma de pronom
1918                if (!$slotaux->defvalueused && $wordslotauxfinal->isClass("pronoun")) {
1919                    if ($slotaux->level == 1) $indextheme1 = $i;
1920                    if ($slotaux->level == 2) $indextheme2 = $i;
1921                }
1922            }
1923        }
1924       
1925        if ($indextheme1 != null) {
1926            $temp = $this->ordrefrase[$indextheme1];
1927            // esborrem el receiver 1 per moure'l de lloc
1928            array_splice($this->ordrefrase, $indextheme1, 1);
1929           
1930            // si la frase és un ordre
1931            if ($propietatsfrase['tipusfrase'] == "ordre" && !$this->frasenegativa) {
1932                // l'insertem just després del main verb
1933                array_splice($this->ordrefrase, $indexmainverb+1, 0, $temp);
1934            }
1935            else {
1936                // l'insertem just abans del main verb
1937                array_splice($this->ordrefrase, $indexmainverb, 0, $temp);
1938            }
1939        }
1940        // fem el mateix amb el receiver 2, si hi és
1941        if ($indextheme2 != null) {
1942            $temp = $this->ordrefrase[$indextheme2];
1943            // esborrem el receiver 1 per moure'l de lloc
1944            array_splice($this->ordrefrase, $indextheme2, 1);
1945            // l'insertem just abans del verb secundari
1946            array_splice($this->ordrefrase, $indexsecondaryverb, 0, $temp);
1947        }
1948       
1949               
1950        // DESIRE
1951       
1952        // si és un desig afegir el verb voler a un slot Desire
1953        if ($propietatsfrase['tipusfrase'] == "desig") {
1954                       
1955            $slotvoler = new Myslot();
1956            $slotvoler->category = "Desire";
1957            $slotvoler->type = "verb";
1958            $slotvoler->full = true;
1959            $slotvoler->level = 0;
1960           
1961            $auxtupla[0] = "vull";
1962            $auxtupla[1] = null;
1963           
1964            $slotvoler->slotstring[] = $auxtupla;
1965           
1966            $this->slotarray["Desire"] = $slotvoler;
1967            array_unshift($this->ordrefrase, "Desire");
1968           
1969            // afegir si us plau: de moment NO
1970            // $aux = array();
1971            // $aux[0] = "si us plau";
1972            // $aux[1] = '0';
1973            // $this->exprsarray[] = $aux;
1974        }
1975       
1976       
1977        // PERMISSION
1978       
1979        // si és un permís afegir el verb poder a un slot Permission
1980        if ($propietatsfrase['tipusfrase'] == "permis") {
1981                       
1982            $slotpoder = new Myslot();
1983            $slotpoder->category = "Permission";
1984            $slotpoder->type = "verb";
1985            $slotpoder->full = true;
1986            $slotpoder->level = 0;
1987           
1988            $auxtupla[0] = "puc";
1989            $auxtupla[1] = null;
1990           
1991            $slotpoder->slotstring[] = $auxtupla;
1992           
1993            $this->slotarray["Permission"] = $slotpoder;
1994            array_unshift($this->ordrefrase, "Permission");
1995            // afegir si us plau
1996            $aux = array();
1997            $aux[0] = "si us plau";
1998            $aux[1] = '0';
1999            $this->exprsarray[] = $aux;
2000        }
2001       
2002       
2003        // CONDITIONAL PHRASE
2004       
2005        // si és una frsse condicional, afegim el "si" a davant (però darrere els advs de temps
2006        // i modificadors de frase que vagin a l'inici de frase)
2007        if ($propietatsfrase['tipusfrase'] == "condicional") {
2008           
2009            $this->frasefinal .= "si ";
2010        }
2011       
2012       
2013        // QUESTION PARTICLE
2014       
2015        // si hi ha una partícula de pregunta, posem el seu slot a davant de tot
2016        if ($indexpartpregunta != null) {
2017            $temp = $this->ordrefrase[$indexpartpregunta];
2018            // esborrem l'slot de la part pregunta per moure'l de lloc
2019            array_splice($this->ordrefrase, $indexpartpregunta, 1);
2020            // l'insertem a l'inici de la frase
2021            array_splice($this->ordrefrase, 0, 0, $temp);
2022        }
2023       
2024       
2025        // SI HI HA UNA PREGUNTA DE "QUANT"
2026        if (isset($this->slotarray["PartPreguntaNoSlot"])) {
2027           
2028            if ($this->slotarray["PartPreguntaNoSlot"]->paraulafinal->text == "quant") {
2029                // si hi ha dos verbs a la frase, només passem el theme 2 davant del subjecte
2030                if (isset($this->slotarray["Secondary Verb 2"])) {
2031                   
2032                    $indexsubject1 = -1;
2033                    $indextheme2 = -1;
2034                   
2035                    for ($i=0; $i<count($this->ordrefrase); $i++) {
2036                        if ($this->ordrefrase[$i] == "Theme 2") $indextheme2 = $i;
2037                        if ($this->ordrefrase[$i] == "Subject 1") $indexsubject1 = $i;
2038                    }
2039                   
2040                    // pot ser que el verb no tingués theme 2, tot i que el "quant" aleshores no
2041                    // tindria sentit
2042                    if ($indexsubject1 != -1 && $indextheme2 != -1) {
2043                       
2044                        $temp = $this->ordrefrase[$indextheme2];
2045                        // esborrem l'slot del theme per moure'l de lloc
2046                        array_splice($this->ordrefrase, $indextheme2, 1);
2047                        // l'insertem a l'inici de la frase
2048                        array_splice($this->ordrefrase, $indexsubject1, 0, $temp); 
2049                       
2050                        $this->questiontypequant = true;
2051                    }
2052                }
2053                // si només hi ha un verb, fem swap de theme i subject
2054                else {
2055                    $indexsubject = -1;
2056                    $indextheme = -1;
2057                   
2058                    for ($i=0; $i<count($this->ordrefrase); $i++) {
2059                        if ($this->ordrefrase[$i] == "Theme") $indextheme = $i;
2060                        if ($this->ordrefrase[$i] == "Subject") $indexsubject = $i;
2061                    }
2062                    // si tenia subjecte i theme
2063                    if ($indexsubject != -1 && $indextheme != -1) {
2064                        $auxslotname = $this->ordrefrase[$indexsubject]; // guardem el subj
2065                        // posem el theme al subj
2066                        $this->ordrefrase[$indexsubject] = $this->ordrefrase[$indextheme];
2067                        // i el subj guardat al theme
2068                        $this->ordrefrase[$indextheme] = $auxslotname;
2069                       
2070                        $this->questiontypequant = true;
2071                    }
2072                }               
2073            }
2074        }
2075        // SI HI HA QUALSEVOL ALTRA PREGUNTA: passem el subjecte al final de la frase
2076        else if ($indexpartpregunta != null) {
2077            $indexsubject1 = -1;
2078            if (isset($this->slotarray["Secondary Verb 2"])) {
2079                    for ($i=0; $i<count($this->ordrefrase); $i++) {
2080                        if ($this->ordrefrase[$i] == "Subject 1") $indexsubject1 = $i;
2081                    }
2082            }
2083            else {
2084                for ($i=0; $i<count($this->ordrefrase); $i++) {
2085                        if ($this->ordrefrase[$i] == "Subject") $indexsubject1 = $i;
2086                }
2087            }
2088            if ($indexsubject1 != -1) {
2089               $temp = $this->ordrefrase[$indexsubject1];
2090                // esborrem l'slot del subjecte per moure'l de lloc
2091                array_splice($this->ordrefrase, $indexsubject1, 1);
2092                // l'insertem al final de la frase
2093                $this->ordrefrase[] = $temp; 
2094            }
2095        }
2096       
2097        // IMPERATIVE
2098        if ($propietatsfrase['tipusfrase'] == "ordre" && !$this->frasenegativa) {
2099            // afegir si us plau
2100            $aux = array();
2101            $aux[0] = "si us plau";
2102            $aux[1] = '0';
2103            $this->exprsarray[] = $aux;
2104        }
2105           
2106        // DEBUG
2107        // echo $this->printOrdreFrase()."<br /><br />";
2108    }
2109   
2110    // Ordena els slots de la frase: ÉS EL PRIMER PAS DEL GENERADOR
2111    public function ordenarSlotsFraseES($propietatsfrase)
2112    {
2113        $CI = &get_instance();
2114        $CI->load->library('Mymatching');
2115        $CI->load->library('Myslot');
2116        $CI->load->library('Myword');
2117        $matching = new Mymatching();
2118       
2119        // agafem si la frase és negativa
2120        $this->frasenegativa = $propietatsfrase['negativa'];
2121       
2122        //agafem si l'usuari parla en masculí o en femení pel generador
2123        if ($CI->session->userdata('isfem') == '1') $this->isfem = true;
2124               
2125        // ADVS TEMPS
2126
2127        // mirar adverbis de temps, per si n'hi ha dels que van a davant de la frase
2128        $numadvstemps = count($this->timeexpr);
2129       
2130        for ($i=0; $i<$numadvstemps; $i++) {
2131            $wordaux = $this->timeexpr[$i];
2132           
2133            if ($matching->isFrontAdvTempsES($wordaux->text)) {
2134
2135                // el posem davant de la frase
2136                $this->frasefinal .= $wordaux->text." ";
2137            }
2138        }
2139       
2140       
2141        // SI SUBJ2 == JO -> SUBJ2 = SUBJ1
2142       
2143        // si hi ha subverb i el subjecte 2 no està definit, si el defvalue era "jo", que el subj2 s'ompli
2144        // amb el subj1 (defvalue o word que fa fill)
2145        if ($this->subverb) {
2146            if (isset($this->slotarray["Subject 2"])) {
2147                if (!$this->slotarray["Subject 2"]->full && $this->slotarray["Subject 2"]->defvalue == '1') {
2148                   
2149                    // si el subj1 tindrà un defvalue assignat passem aquest valor al subj2
2150                    if (isset($this->slotarray["Subject 1"]) && !$this->slotarray["Subject 1"]->full) {
2151                        $this->slotarray["Subject 2"]->defvalue = $this->slotarray["Subject 1"]->defvalue;
2152                    }
2153                    // si el subj 1 té una paraula que l'omple, passem la paraula al subj2
2154                    else if (isset($this->slotarray["Subject 1"])) {
2155                        $this->slotarray["Subject 2"]->full = true;
2156                        $this->slotarray["Subject 2"]->paraulafinal = $this->slotarray["Subject 1"]->paraulafinal;
2157                        $this->slotarray["Subject 2"]->indexclassfinalword = $this->slotarray["Subject 1"]->indexclassfinalword;
2158                    }
2159                   
2160                }
2161            }
2162        }
2163       
2164       
2165        // ORDRE NORMAL
2166       
2167        $counter = 0;
2168        $indexmainverb = 0;
2169        $indexsecondaryverb = null;
2170        $indexpartpregunta = null;
2171       
2172        // posem tots els slots en l'ordre normal
2173        foreach ($this->slotarray as $keyslot => $slot) {
2174           
2175            if ($slot->full || $slot->grade == '1') {
2176                // si no estava ple, vol dir que era un obligatori i l'omplim amb el valor per defecte
2177                if (!$slot->full) {
2178                    // si la frase és una ordre o una pregunta, el subj per defecte passa a ser "tu"
2179                    if (($propietatsfrase['tipusfrase'] == "ordre" || $propietatsfrase['tipusfrase'] == "pregunta") 
2180                            && $slot->category == "Subject" && $slot->level == 1) {
2181                        $slot->defvalue = '2';
2182                    }
2183                    $slot->full = true;
2184                    $slot->defvalueused = true;
2185                }
2186                // busquem si hi ha una partícula de pregunta, que només poden ser a slots plens
2187                else {
2188                    if ($slot->category == "PartPreguntaNoSlot" || $slot->paraulafinal->tipus == "questpart") {
2189                        $indexpartpregunta = $counter;
2190                    }
2191                }
2192                if ($slot->category == "Main Verb") $indexmainverb = $counter;
2193                if ($slot->category == "Secondary Verb") $indexsecondaryverb = $counter;
2194               
2195                $this->ordrefrase[] = $keyslot;
2196                $counter += 1;
2197            }
2198        }
2199       
2200       
2201        // MODIFICADORS INICI DE FRASE
2202       
2203        // tractem els modificadors de frase que estan enganxats al verb principal
2204        $keymainverb = "Main Verb";
2205        if (isset($this->slotarray["Secondary Verb 2"])) $keymainverb .= " 1";
2206        $slotmainverb = $this->slotarray[$keymainverb];
2207        $nummodifsfrase = count($slotmainverb->CModassignedkey);
2208        for ($i=0; $i<$nummodifsfrase; $i++) {
2209            $keymodifaux = $slotmainverb->CModassignedkey[$i];
2210            $slotmodifaux = $slotmainverb->cmpMod[$keymodifaux];
2211           
2212            // si no és del grup que va darrere el subjecte el posem al principi de la frase (ex: si, perquè, pero)
2213            if (!$matching->isModAfterSubjES($slotmodifaux->paraulafinal->text)) {
2214               
2215                $this->frasefinal = " ".$slotmodifaux->paraulafinal->text." ".$this->frasefinal;
2216            }
2217            /**
2218             * INFO LANGUAGE DEPENDENT!!
2219             */
2220            // marquem si la frase és negativa pel modificador no
2221            else if ($slotmodifaux->paraulafinal->text == "no") $this->frasenegativa = true;
2222        }
2223       
2224        // THEME PRONOMINAL LO, TÚ, YO
2225       
2226        $indextheme1 = null;
2227        $indextheme2 = null;
2228               
2229        // busquem si té un slot de theme que sigui pronominal "lo", "tú", "yo"
2230        for($i=0; $i<count($this->ordrefrase); $i++) {
2231           
2232            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
2233            if ($slotaux->category == "Theme") {
2234                // si està en forma de pronom
2235                if ($slotaux->defvalueused && ($slotaux->defvalue == "lo" || $slotaux->defvalue == "tú"
2236                        || $slotaux->defvalue == "yo")) {
2237                    if ($slotaux->level == 1) $indextheme1 = $i;
2238                    if ($slotaux->level == 2) $indextheme2 = $i;
2239                }
2240            }
2241        }
2242       
2243        if ($indextheme1 != null) {
2244            $temp = $this->ordrefrase[$indextheme1];
2245            // esborrem el theme 1 per moure'l de lloc
2246            array_splice($this->ordrefrase, $indextheme1, 1);
2247           
2248            // si la frase és una ordre i no és negativa
2249            if ($propietatsfrase['tipusfrase'] == "ordre" && !$this->frasenegativa) {
2250                // l'insertem just després del main verb
2251                array_splice($this->ordrefrase, $indexmainverb+1, 0, $temp);
2252            }
2253            else {
2254                // l'insertem just abans del main verb
2255                array_splice($this->ordrefrase, $indexmainverb, 0, $temp);
2256            }
2257        }
2258        // fem el mateix amb el theme 2, si hi és
2259        if ($indextheme2 != null) {
2260            $temp = $this->ordrefrase[$indextheme2];
2261            // esborrem el theme 2 per moure'l de lloc
2262            array_splice($this->ordrefrase, $indextheme2, 1);
2263            // l'insertem just abans del verb secundari
2264            array_splice($this->ordrefrase, $indexsecondaryverb, 0, $temp);
2265        }
2266       
2267       
2268        // RECEIVER PRONOMINAL
2269        // anirà abans que un theme pronominal, per això va després a l'algoritme
2270       
2271        $indexreceiver1 = null;
2272        $indexreceiver2 = null;
2273               
2274        // busquem si té un slot de receiver que sigui pronominal i el posem abans del verb principal
2275        for($i=0; $i<count($this->ordrefrase); $i++) {
2276           
2277            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
2278            if ($slotaux->category == "Receiver") {
2279                $wordslotauxfinal = $slotaux->paraulafinal;
2280                // si està en forma de pronom (només de tu, jo)
2281                if ($slotaux->defvalueused || $wordslotauxfinal->isClass("pronoun")) {
2282                    if ($slotaux->level == 1) $indexreceiver1 = $i;
2283                    if ($slotaux->level == 2) $indexreceiver2 = $i;
2284                }
2285            }
2286        }
2287       
2288        if ($indexreceiver1 != null) {
2289            $temp = $this->ordrefrase[$indexreceiver1];
2290            // esborrem el receiver 1 per moure'l de lloc
2291            array_splice($this->ordrefrase, $indexreceiver1, 1);
2292           
2293            // si la frase és un ordre
2294            if ($propietatsfrase['tipusfrase'] == "ordre" && !$this->frasenegativa) {
2295                // l'insertem just després del main verb
2296                array_splice($this->ordrefrase, $indexmainverb+1, 0, $temp);
2297            }
2298            else {
2299                // l'insertem just abans del main verb
2300                array_splice($this->ordrefrase, $indexmainverb, 0, $temp);
2301            }
2302        }
2303        // fem el mateix amb el receiver 2, si hi és
2304        if ($indexreceiver2 != null) {
2305            $temp = $this->ordrefrase[$indexreceiver2];
2306            // esborrem el receiver 1 per moure'l de lloc
2307            array_splice($this->ordrefrase, $indexreceiver2, 1);
2308            // l'insertem just abans del verb secundari
2309            array_splice($this->ordrefrase, $indexsecondaryverb, 0, $temp);
2310        }
2311       
2312       
2313        // THEME PRONOMINAL / Yo, tu, él, etc. si no té preposició, excepte "a"
2314        // si té la preposició "a" davant, farà el canvi, però no posarà la preposició
2315       
2316        $indextheme1 = null;
2317        $indextheme2 = null;
2318               
2319        // busquem si té un slot de theme que sigui pronominal i el posem abans del verb principal
2320        for($i=0; $i<count($this->ordrefrase); $i++) {
2321           
2322            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
2323            if ($slotaux->category == "Theme" && ($slotaux->prep == null || $slotaux->prep == "a")) {
2324                $wordslotauxfinal = $slotaux->paraulafinal;
2325                // si està en forma de pronom
2326                if (!$slotaux->defvalueused && $wordslotauxfinal->isClass("pronoun")) {
2327                    if ($slotaux->level == 1) $indextheme1 = $i;
2328                    if ($slotaux->level == 2) $indextheme2 = $i;
2329                }
2330            }
2331        }
2332       
2333        if ($indextheme1 != null) {
2334            $temp = $this->ordrefrase[$indextheme1];
2335            // esborrem el theme 1 per moure'l de lloc
2336            array_splice($this->ordrefrase, $indextheme1, 1);
2337           
2338            // si la frase és un ordre
2339            if ($propietatsfrase['tipusfrase'] == "ordre" && !$this->frasenegativa) {
2340                // l'insertem just després del main verb
2341                array_splice($this->ordrefrase, $indexmainverb+1, 0, $temp);
2342            }
2343            else {
2344                // l'insertem just abans del main verb
2345                array_splice($this->ordrefrase, $indexmainverb, 0, $temp);
2346            }
2347        }
2348        // fem el mateix amb el theme 2, si hi és
2349        if ($indextheme2 != null) {
2350            $temp = $this->ordrefrase[$indextheme2];
2351            // esborrem el theme 1 per moure'l de lloc
2352            array_splice($this->ordrefrase, $indextheme2, 1);
2353            // l'insertem just abans del verb secundari
2354            array_splice($this->ordrefrase, $indexsecondaryverb, 0, $temp);
2355        }
2356       
2357               
2358        // DESIRE
2359       
2360        // si és un desig afegir el verb voler a un slot Desire
2361        if ($propietatsfrase['tipusfrase'] == "desig") {
2362                       
2363            $slotvoler = new Myslot();
2364            $slotvoler->category = "Desire";
2365            $slotvoler->type = "verb";
2366            $slotvoler->full = true;
2367            $slotvoler->level = 0;
2368           
2369            $auxtupla[0] = "quiero";
2370            $auxtupla[1] = null;
2371           
2372            $slotvoler->slotstring[] = $auxtupla;
2373           
2374            $this->slotarray["Desire"] = $slotvoler;
2375            array_unshift($this->ordrefrase, "Desire");
2376           
2377            // afegir por favor: de moment NO
2378            // $aux = array();
2379            // $aux[0] = "por favor";
2380            // $aux[1] = '0';
2381            // $this->exprsarray[] = $aux;
2382        }
2383       
2384       
2385        // PERMISSION
2386       
2387        // si és un permís afegir el verb poder a un slot Permission
2388        if ($propietatsfrase['tipusfrase'] == "permis") {
2389                       
2390            $slotpoder = new Myslot();
2391            $slotpoder->category = "Permission";
2392            $slotpoder->type = "verb";
2393            $slotpoder->full = true;
2394            $slotpoder->level = 0;
2395           
2396            $auxtupla[0] = "puedo";
2397            $auxtupla[1] = null;
2398           
2399            $slotpoder->slotstring[] = $auxtupla;
2400           
2401            $this->slotarray["Permission"] = $slotpoder;
2402            array_unshift($this->ordrefrase, "Permission");
2403            // afegir por favor
2404            $aux = array();
2405            $aux[0] = "por favor";
2406            $aux[1] = '0';
2407            $this->exprsarray[] = $aux;
2408        }
2409       
2410       
2411        // CONDITIONAL PHRASE
2412       
2413        // si és una frsse condicional, afegim el "si" a davant (però darrere els advs de temps
2414        // i modificadors de frase que vagin a l'inici de frase)
2415        if ($propietatsfrase['tipusfrase'] == "condicional") {
2416           
2417            $this->frasefinal .= "si ";
2418        }
2419       
2420       
2421        // QUESTION PARTICLE
2422       
2423        // si hi ha una partícula de pregunta, posem el seu slot a davant de tot
2424        if ($indexpartpregunta != null) {
2425            $temp = $this->ordrefrase[$indexpartpregunta];
2426            // esborrem l'slot de la part pregunta per moure'l de lloc
2427            array_splice($this->ordrefrase, $indexpartpregunta, 1);
2428            // l'insertem a l'inici de la frase
2429            array_splice($this->ordrefrase, 0, 0, $temp);
2430        }
2431       
2432       
2433        // SI HI HA UNA PREGUNTA DE "QUANT"
2434        if (isset($this->slotarray["PartPreguntaNoSlot"])) {
2435           
2436            if ($this->slotarray["PartPreguntaNoSlot"]->paraulafinal->text == "cuánto") {
2437                // si hi ha dos verbs a la frase, només passem el theme 2 davant del subjecte
2438                if (isset($this->slotarray["Secondary Verb 2"])) {
2439                   
2440                    $indexsubject1 = -1;
2441                    $indextheme2 = -1;
2442                   
2443                    for ($i=0; $i<count($this->ordrefrase); $i++) {
2444                        if ($this->ordrefrase[$i] == "Theme 2") $indextheme2 = $i;
2445                        if ($this->ordrefrase[$i] == "Subject 1") $indexsubject1 = $i;
2446                    }
2447                   
2448                    // pot ser que el verb no tingués theme 2, tot i que el "quant" aleshores no
2449                    // tindria sentit
2450                    if ($indexsubject1 != -1 && $indextheme2 != -1) {
2451                       
2452                        $temp = $this->ordrefrase[$indextheme2];
2453                        // esborrem l'slot del theme per moure'l de lloc
2454                        array_splice($this->ordrefrase, $indextheme2, 1);
2455                        // l'insertem a l'inici de la frase
2456                        array_splice($this->ordrefrase, $indexsubject1, 0, $temp); 
2457                       
2458                        $this->questiontypequant = true;
2459                    }
2460                }
2461                // si només hi ha un verb, fem swap de theme i subject
2462                else {
2463                    $indexsubject = -1;
2464                    $indextheme = -1;
2465                   
2466                    for ($i=0; $i<count($this->ordrefrase); $i++) {
2467                        if ($this->ordrefrase[$i] == "Theme") $indextheme = $i;
2468                        if ($this->ordrefrase[$i] == "Subject") $indexsubject = $i;
2469                    }
2470                    // si tenia subjecte i theme
2471                    if ($indexsubject != -1 && $indextheme != -1) {
2472                        $auxslotname = $this->ordrefrase[$indexsubject]; // guardem el subj
2473                        // posem el theme al subj
2474                        $this->ordrefrase[$indexsubject] = $this->ordrefrase[$indextheme];
2475                        // i el subj guardat al theme
2476                        $this->ordrefrase[$indextheme] = $auxslotname;
2477                       
2478                        $this->questiontypequant = true;
2479                    }
2480                }               
2481            }
2482        }
2483        // SI HI HA QUALSEVOL ALTRA PREGUNTA: passem el subjecte al final de la frase
2484        else if ($indexpartpregunta != null) {
2485            $indexsubject1 = -1;
2486            if (isset($this->slotarray["Secondary Verb 2"])) {
2487                    for ($i=0; $i<count($this->ordrefrase); $i++) {
2488                        if ($this->ordrefrase[$i] == "Subject 1") $indexsubject1 = $i;
2489                    }
2490            }
2491            else {
2492                for ($i=0; $i<count($this->ordrefrase); $i++) {
2493                        if ($this->ordrefrase[$i] == "Subject") $indexsubject1 = $i;
2494                }
2495            }
2496            if ($indexsubject1 != -1) {
2497                $temp = $this->ordrefrase[$indexsubject1];
2498                // esborrem l'slot del subjecte per moure'l de lloc
2499                array_splice($this->ordrefrase, $indexsubject1, 1);
2500                // l'insertem al final de la frase
2501                $this->ordrefrase[] = $temp; 
2502            }
2503        }
2504       
2505        // IMPERATIVE
2506        if ($propietatsfrase['tipusfrase'] == "ordre"  && !$this->frasenegativa) {
2507            // afegir por favor
2508            $aux = array();
2509            $aux[0] = "por favor";
2510            $aux[1] = '0';
2511            $this->exprsarray[] = $aux;
2512        }
2513                   
2514        // DEBUG
2515        // echo $this->printOrdreFrase()."<br /><br />";
2516    }
2517   
2518    // Agafa la Persona, Gènere i número dels subjectes del pattern
2519    public function getPersGenNumSubjs()
2520    {
2521        $keysubj1 = "Subject";
2522        $keysubj2 = null;
2523        $slotsubj1 = null; // als pseudoimpersonals que com a subj hi ha un subverb, no hi ha subj1
2524       
2525        if (isset($this->slotarray["Secondary Verb 2"])) {
2526            $keysubj1 .= " 1";
2527            $keysubj2 = "Subject 2";
2528        }
2529       
2530        // si no hi ha subjecte i el verb és impersonal
2531        if(!isset($this->slotarray[$keysubj1]) && $this->impersonal) {
2532            $keysubj1 = "Theme";
2533        }
2534       
2535        // agafem les dades del primer subjecte
2536        if (isset($this->slotarray[$keysubj1]) && $this->slotarray[$keysubj1]->full) {
2537            $slotsubj1 = $this->slotarray[$keysubj1];
2538                                               
2539            // si hi ha el subjecte per defecte
2540            if ($slotsubj1->defvalueused) {
2541                $subj1 = $slotsubj1->defvalue;
2542                               
2543                if ($subj1 == '1') {
2544                    $this->perssubj1 = 1;
2545                    if ($this->isfem) $this->genmascsubj1 = false;
2546                }
2547                else if ($subj1 == '2') $this->perssubj1 = 2;
2548                else $this->perssubj1 = 3;
2549            }
2550            // si el subjecte és una paraula
2551            // si hi ha una partícula de pregunta al subjecte o no hi havia slot subjecte
2552            // perquè era impersonal, no ha d'agafar-ne les propietats
2553            else if($slotsubj1->paraulafinal->tipus != "questpart") {
2554                $subj1 = $slotsubj1->paraulafinal;
2555                               
2556                // si és un pronom personal
2557                if ($subj1->isClass("pronoun")) {
2558                    if ($subj1->text == "jo") {
2559                        if ($subj1->fem || $this->isfem) $this->genmascsubj1 = false;
2560                        else $this->genmascsubj1 = true;
2561                        $this->plsubj1 = false;
2562                        $this->perssubj1 = 1;
2563                    }
2564                    else if ($subj1->text == "tu") {
2565                        if ($subj1->fem) $this->genmascsubj1 = false;
2566                        else $this->genmascsubj1 = true;
2567                        $this->plsubj1 = false;
2568                        $this->perssubj1 = 2;
2569                    }
2570                    else if ($subj1->text == "ell") {
2571                        $this->genmascsubj1 = true;
2572                        if ($subj1->plural) $this->plsubj1 = true;
2573                        else $this->plsubj1 = false;
2574                        $this->perssubj1 = 3;
2575                    }
2576                    else if ($subj1->text == "ella") {
2577                        $this->genmascsubj1 = false;
2578                        if ($subj1->plural) $this->plsubj1 = true;
2579                        else $this->plsubj1 = false;
2580                        $this->perssubj1 = 3;
2581                    }
2582                    else if ($subj1->text == "nosaltres") {
2583                        if ($subj1->fem) $this->genmascsubj1 = false;
2584                        else $this->genmascsubj1 = true;
2585                        $this->plsubj1 = true;
2586                        $this->perssubj1 = 1;
2587                    }
2588                    else if ($subj1->text == "vosaltres") {
2589                        if ($subj1->fem) $this->genmascsubj1 = false;
2590                        else $this->genmascsubj1 = true;
2591                        $this->plsubj1 = true;
2592                        $this->perssubj1 = 2;
2593                    }
2594                    else if ($subj1->text == "ells") {
2595                        if ($subj1->fem) $this->genmascsubj1 = false;
2596                        else $this->genmascsubj1 = true;
2597                        $this->plsubj1 = true;
2598                        $this->perssubj1 = 3;
2599                    }
2600                    // per altra mena de pronoms, tipus això, allò, posem 3a persona
2601                    else {
2602                        $this->genmascsubj1 = true;
2603                        $this->plsubj1 = false;
2604                        $this->perssubj1 = 3;
2605                    }
2606                }
2607                // si no, agafem les propietats de la paraula
2608                else {     
2609                                       
2610                    if ($subj1->tipus == "name") {
2611                        if ($subj1->propietats->mf == "fem") $this->genmascsubj1 = false;
2612                        else $this->genmascsubj1 = true;
2613                        if ($subj1->propietats->singpl == "pl") $this->plsubj1 = true;
2614                        else $this->plsubj1 = false;
2615
2616                        // hem de mirar si el subjecte té un quantificador o modificador que el fa ser plural
2617                        // la info estarà codificada a slotstring, al primer element que és nom
2618                        $i=0;
2619                        $found = false;
2620                        while ($i<count($slotsubj1->slotstring) && !$found) {
2621                            $aux = $slotsubj1->slotstring[$i];
2622
2623                            // si trobem el nucli i efectivament és un nom
2624                            if (isset($aux[2]) && $aux[2]) {
2625                                $this->genmascsubj1 = $aux[3];
2626                                $this->plsubj1 = $aux[4];
2627
2628                                $found = true;
2629                            }
2630                            $i++;
2631                        }
2632                    }
2633                    $this->perssubj1 = 3;
2634                }
2635                // si la paraula en té una altra de coordinada, passarà a plural
2636                if ($subj1->tipus == "name" && count($subj1->paraulacoord) > 0) $this->plsubj1 = true;
2637            }
2638            else if($slotsubj1->paraulafinal->tipus == "questpart") {
2639                $this->perssubj1 = 3;
2640            }
2641        }
2642       
2643        // si hi és també agafem les dades del segon subjecte
2644        if ($keysubj2 != null && isset($this->slotarray[$keysubj2])) {
2645            $slotsubj2 = $this->slotarray[$keysubj2];
2646           
2647            // si hi ha el subjecte per defecte
2648            if ($slotsubj2->defvalueused) {
2649                $subj2 = $slotsubj2->defvalue;
2650               
2651                if ($subj2 == '1')  {
2652                    $this->perssubj2 = 1;
2653                    if ($this->isfem) $this->genmascsubj2 = false;
2654                }
2655                else if ($subj2 == '2') $this->perssubj2 = 2;
2656                else $this->perssubj2 = 3;
2657            }
2658            // si el subjecte és una paraula
2659            else {
2660                $subj2 = $slotsubj2->paraulafinal;
2661               
2662                // si és un pronom personalq
2663                if ($subj2->isClass("pronoun")) {
2664                    if ($subj2->text == "jo") {
2665                        if ($subj2->fem || $this->isfem) $this->genmascsubj2 = false;
2666                        else $this->genmascsubj2 = true;
2667                        $this->plsubj2 = false;
2668                        $this->perssubj2 = 1;
2669                    }
2670                    else if ($subj2->text == "tu") {
2671                        if ($subj2->fem) $this->genmascsubj2 = false;
2672                        else $this->genmascsubj2 = true;
2673                        $this->plsubj2 = false;
2674                        $this->perssubj2 = 2;
2675                    }
2676                    else if ($subj2->text == "ell") {
2677                        $this->genmascsubj2 = true;
2678                        if ($subj2->plural) $this->plsubj2 = true;
2679                        else $this->plsubj2 = false;
2680                        $this->perssubj2 = 3;
2681                    }
2682                    else if ($subj2->text == "ella") {
2683                        $this->genmascsubj2 = false;
2684                        if ($subj2->plural) $this->plsubj2 = true;
2685                        else $this->plsubj2 = false;
2686                        $this->perssubj2 = 3;
2687                    }
2688                    else if ($subj2->text == "nosaltres") {
2689                        if ($subj2->fem) $this->genmascsubj2 = false;
2690                        else $this->genmascsubj2 = true;
2691                        $this->plsubj2 = true;
2692                        $this->perssubj2 = 1;
2693                    }
2694                    else if ($subj2->text == "vosaltres") {
2695                        if ($subj2->fem) $this->genmascsubj2 = false;
2696                        else $this->genmascsubj2 = true;
2697                        $this->plsubj2 = true;
2698                        $this->perssubj2 = 2;
2699                    }
2700                    else if ($subj2->text == "ells") {
2701                        if ($subj2->fem) $this->genmascsubj2 = false;
2702                        else $this->genmascsubj2 = true;
2703                        $this->plsubj2 = true;
2704                        $this->perssubj2 = 3;
2705                    }
2706                    // per altra mena de pronoms, tipus això, allò, posem 3a persona
2707                    else {
2708                        $this->genmascsubj2 = true;
2709                        $this->plsubj2 = false;
2710                        $this->perssubj2 = 3;
2711                    }
2712                }
2713                // si no, agafem les propietats de la paraula
2714                else {
2715                    if ($subj2->propietats->mf == "fem") $this->genmascsubj2 = false;
2716                    else $this->genmascsubj2 = true;
2717                    if ($subj2->propietats->singpl == "pl") $this->plsubj2 = true;
2718                    else $this->plsubj2 = false;
2719                   
2720                    // hem de mirar si el subjecte té un quantificador o modificador que el fa ser plural
2721                    // la info estarà codificada a slotstring, al primer element que és nom
2722                    $i=0;
2723                    $found = false;
2724                    while ($i<count($slotsubj2->slotstring) && !$found) {
2725                        $aux = $slotsubj2->slotstring[$i];
2726                       
2727                        // si trobem el nucli i efectivament és un nom
2728                        if (isset($aux[2]) && $aux[2]) {
2729                            $this->genmascsubj2 = $aux[3];
2730                            $this->plsubj2 = $aux[4];
2731                           
2732                            $found = true;
2733                        }
2734                        $i++;
2735                    }
2736                    $this->perssubj2 = 3;
2737                }
2738                // si la paraula en té una altra de coordinada, passarà a plural
2739                if (count($subj2->paraulacoord) > 0) $this->plsubj2 = true;
2740            }
2741           
2742            // sempre hi ha subj1 a no ser que a un pseudoimpersonal el subj sigui un subverb
2743            // No serveix per frases que no tenen subjecte, estil "És un pal" o "Fa sol"
2744            if ($slotsubj1 != null) {
2745                // Si hi havia dos subjectes MIREM SI ELS DOS SUBJECTES SÓN IGUALS
2746                if ($slotsubj1->paraulafinal != null && $slotsubj2->paraulafinal != null) {
2747                    if ($slotsubj1->paraulafinal->text == $slotsubj2->paraulafinal->text) $this->subjsiguals = true;
2748                }
2749                // si els dos estaven buits, seran iguals, per la funció ordenar slots
2750                else if ($slotsubj1->paraulafinal == null && $slotsubj2->paraulafinal == null) $this->subjsiguals = true;
2751                // si el primer és null i el segon no
2752                else if ($slotsubj1->paraulafinal == null && $slotsubj2->paraulafinal != null) {
2753                    if ($slotsubj1->defvalue == '1' && $slotsubj2->paraulafinal->text == "jo") $this->subjsiguals = true;
2754                    else if ($slotsubj1->defvalue == '2' && $slotsubj2->paraulafinal->text == "tu") $this->subjsiguals = true;
2755                }
2756                // si el primer no és null i el segon ho és
2757                else if ($slotsubj1->paraulafinal != null && $slotsubj2->paraulafinal == null) {
2758                    if ($slotsubj2->defvalue == '1' && $slotsubj1->paraulafinal->text == "jo") $this->subjsiguals = true;
2759                    else if ($slotsubj2->defvalue == '2' && $slotsubj1->paraulafinal->text == "tu") $this->subjsiguals = true;
2760                }
2761            }
2762            else {
2763                    $this->subjsiguals = true;
2764                    // i el subjecte és en 3a persona, ja que és una proposició
2765                    $this->perssubj1 = 3; 
2766            }
2767        }
2768       
2769        // si era pseudimpersonal amb subverb, si el receiver1 està definit i el subj2 no ho està,
2770        // que subj2 = receiver1
2771        if ($this->pseudoimpersonal && isset($this->slotarray["Receiver 1"]) && $keysubj2 != null
2772            && !isset($this->slotarray[$keysubj2]) ) {
2773                   
2774            $this->subjsiguals = true;
2775        }
2776       
2777       
2778        // Si és verbless que posi per defecte la 1a persona, per si hi ha "Desig" activat
2779        // Ex: "Desig" Poma = Vull una poma
2780        if ($this->defaulttense == "verbless") $this->perssubj1 = 1;
2781        // Serveix per frases que no tenen subjecte, estil "És un pal" o "Fa sol"
2782        else if ($slotsubj1 == null) $this->perssubj1 = 3;
2783    }
2784   
2785    // Agafa la Persona, Gènere i número dels subjectes del pattern
2786    public function getPersGenNumSubjsES()
2787    {
2788        $keysubj1 = "Subject";
2789        $keysubj2 = null;
2790        $slotsubj1 = null; // als pseudoimpersonals que com a subj hi ha un subverb, no hi ha subj1
2791       
2792        if (isset($this->slotarray["Secondary Verb 2"])) {
2793            $keysubj1 .= " 1";
2794            $keysubj2 = "Subject 2";
2795        }
2796       
2797        // si no hi ha subjecte i el verb és impersonal
2798        if(!isset($this->slotarray[$keysubj1]) && $this->impersonal) {
2799            $keysubj1 = "Theme";
2800        }
2801       
2802        // agafem les dades del primer subjecte
2803        if (isset($this->slotarray[$keysubj1]) && $this->slotarray[$keysubj1]->full) {
2804           
2805            $slotsubj1 = $this->slotarray[$keysubj1];
2806           
2807            // si hi ha el subjecte per defecte
2808            if ($slotsubj1->defvalueused) {
2809                $subj1 = $slotsubj1->defvalue;
2810               
2811                if ($subj1 == '1') {
2812                    $this->perssubj1 = 1;
2813                    if ($this->isfem) $this->genmascsubj1 = false;
2814                }
2815                else if ($subj1 == '2') $this->perssubj1 = 2;
2816                else $this->perssubj1 = 3;
2817            }
2818            // si el subjecte és una paraula
2819            // si hi ha una partícula de pregunta al subjecte o no hi havia slot subjecte
2820            // perquè era impersonal, no ha d'agafar-ne les propietats
2821            else if($slotsubj1->paraulafinal->tipus != "questpart") {
2822                $subj1 = $slotsubj1->paraulafinal;
2823               
2824                // si és un pronom personal
2825                if ($subj1->isClass("pronoun")) {
2826                    if ($subj1->text == "yo") {
2827                        if ($subj1->fem || $this->isfem) $this->genmascsubj1 = false;
2828                        else $this->genmascsubj1 = true;
2829                        $this->plsubj1 = false;
2830                        $this->perssubj1 = 1;
2831                    }
2832                    else if ($subj1->text == "tú") {
2833                        if ($subj1->fem) $this->genmascsubj1 = false;
2834                        else $this->genmascsubj1 = true;
2835                        $this->plsubj1 = false;
2836                        $this->perssubj1 = 2;
2837                    }
2838                    else if ($subj1->text == "él") {
2839                        $this->genmascsubj1 = true;
2840                        if ($subj1->plural) $this->plsubj1 = true;
2841                        else $this->plsubj1 = false;
2842                        $this->perssubj1 = 3;
2843                    }
2844                    else if ($subj1->text == "ella") {
2845                        $this->genmascsubj1 = false;
2846                        if ($subj1->plural) $this->plsubj1 = true;
2847                        else $this->plsubj1 = false;
2848                        $this->perssubj1 = 3;
2849                    }
2850                    else if ($subj1->text == "nosotros") {
2851                        if ($subj1->fem) $this->genmascsubj1 = false;
2852                        else $this->genmascsubj1 = true;
2853                        $this->plsubj1 = true;
2854                        $this->perssubj1 = 1;
2855                    }
2856                    else if ($subj1->text == "vosotros") {
2857                        if ($subj1->fem) $this->genmascsubj1 = false;
2858                        else $this->genmascsubj1 = true;
2859                        $this->plsubj1 = true;
2860                        $this->perssubj1 = 2;
2861                    }
2862                    else if ($subj1->text == "ellos") {
2863                        if ($subj1->fem) $this->genmascsubj1 = false;
2864                        else $this->genmascsubj1 = true;
2865                        $this->plsubj1 = true;
2866                        $this->perssubj1 = 3;
2867                    }
2868                    // per altra mena de pronoms, tipus això, allò, posem 3a persona
2869                    else {
2870                        $this->genmascsubj1 = true;
2871                        $this->plsubj1 = false;
2872                        $this->perssubj1 = 3;
2873                    }
2874                }
2875                // si no, agafem les propietats de la paraula
2876                else {     
2877                    if ($subj1->tipus == "name") {
2878                        if ($subj1->propietats->mf == "fem") $this->genmascsubj1 = false;
2879                        else $this->genmascsubj1 = true;
2880                        if ($subj1->propietats->singpl == "pl") $this->plsubj1 = true;
2881                        else $this->plsubj1 = false;
2882
2883                        // hem de mirar si el subjecte té un quantificador o modificador que el fa ser plural
2884                        // la info estarà codificada a slotstring, al primer element que és nom
2885                        $i=0;
2886                        $found = false;
2887                        while ($i<count($slotsubj1->slotstring) && !$found) {
2888                            $aux = $slotsubj1->slotstring[$i];
2889
2890                            // si trobem el nucli i efectivament és un nom
2891                            if (isset($aux[2]) && $aux[2]) {
2892                                $this->genmascsubj1 = $aux[3];
2893                                $this->plsubj1 = $aux[4];
2894
2895                                $found = true;
2896                            }
2897                            $i++;
2898                        }
2899                    }
2900                    $this->perssubj1 = 3;
2901                }
2902                // si la paraula en té una altra de coordinada, passarà a plural
2903                if ($subj1->tipus == "name" && count($subj1->paraulacoord) > 0) $this->plsubj1 = true;
2904            }
2905            else if($slotsubj1->paraulafinal->tipus == "questpart") {
2906                $this->perssubj1 = 3;
2907            }
2908        }
2909       
2910        // si hi és també agafem les dades del segon subjecte
2911        if ($keysubj2 != null && isset($this->slotarray[$keysubj2])) {
2912            $slotsubj2 = $this->slotarray[$keysubj2];
2913           
2914            // si hi ha el subjecte per defecte
2915            if ($slotsubj2->defvalueused) {
2916                $subj2 = $slotsubj2->defvalue;
2917               
2918                if ($subj2 == '1')  {
2919                    $this->perssubj2 = 1;
2920                    if ($this->isfem) $this->genmascsubj2 = false;
2921                }
2922                else if ($subj2 == '2') $this->perssubj2 = 2;
2923                else $this->perssubj2 = 3;
2924            }
2925            // si el subjecte és una paraula
2926            else {
2927                $subj2 = $slotsubj2->paraulafinal;
2928               
2929                // si és un pronom personal
2930                if ($subj2->isClass("pronoun")) {
2931                    if ($subj2->text == "yo") {
2932                        if ($subj2->fem || $this->isfem) $this->genmascsubj2 = false;
2933                        else $this->genmascsubj2 = true;
2934                        $this->plsubj2 = false;
2935                        $this->perssubj2 = 1;
2936                    }
2937                    else if ($subj2->text == "tú") {
2938                        if ($subj2->fem) $this->genmascsubj2 = false;
2939                        else $this->genmascsubj2 = true;
2940                        $this->plsubj2 = false;
2941                        $this->perssubj2 = 2;
2942                    }
2943                    else if ($subj2->text == "él") {
2944                        $this->genmascsubj2 = true;
2945                        if ($subj2->plural) $this->plsubj2 = true;
2946                        else $this->plsubj2 = false;
2947                        $this->perssubj2 = 3;
2948                    }
2949                    else if ($subj2->text == "ella") {
2950                        $this->genmascsubj2 = false;
2951                        if ($subj2->plural) $this->plsubj2 = true;
2952                        else $this->plsubj2 = false;
2953                        $this->perssubj2 = 3;
2954                    }
2955                    else if ($subj2->text == "nosotros") {
2956                        if ($subj2->fem) $this->genmascsubj2 = false;
2957                        else $this->genmascsubj2 = true;
2958                        $this->plsubj2 = true;
2959                        $this->perssubj2 = 1;
2960                    }
2961                    else if ($subj2->text == "vosotros") {
2962                        if ($subj2->fem) $this->genmascsubj2 = false;
2963                        else $this->genmascsubj2 = true;
2964                        $this->plsubj2 = true;
2965                        $this->perssubj2 = 2;
2966                    }
2967                    else if ($subj2->text == "ellos") {
2968                        if ($subj2->fem) $this->genmascsubj2 = false;
2969                        else $this->genmascsubj2 = true;
2970                        $this->plsubj2 = true;
2971                        $this->perssubj2 = 3;
2972                    }
2973                    // per altra mena de pronoms, tipus això, allò, posem 3a persona
2974                    else {
2975                        $this->genmascsubj2 = true;
2976                        $this->plsubj2 = false;
2977                        $this->perssubj2 = 3;
2978                    }
2979                }
2980                // si no, agafem les propietats de la paraula
2981                else {
2982                    if ($subj2->propietats->mf == "fem") $this->genmascsubj2 = false;
2983                    else $this->genmascsubj2 = true;
2984                    if ($subj2->propietats->singpl == "pl") $this->plsubj2 = true;
2985                    else $this->plsubj2 = false;
2986                   
2987                    // hem de mirar si el subjecte té un quantificador o modificador que el fa ser plural
2988                    // la info estarà codificada a slotstring, al primer element que és nom
2989                    $i=0;
2990                    $found = false;
2991                    while ($i<count($slotsubj2->slotstring) && !$found) {
2992                        $aux = $slotsubj2->slotstring[$i];
2993                       
2994                        // si trobem el nucli i efectivament és un nom
2995                        if (isset($aux[2]) && $aux[2]) {
2996                            $this->genmascsubj2 = $aux[3];
2997                            $this->plsubj2 = $aux[4];
2998                           
2999                            $found = true;
3000                        }
3001                        $i++;
3002                    }
3003                    $this->perssubj2 = 3;
3004                }
3005                // si la paraula en té una altra de coordinada, passarà a plural
3006                if (count($subj2->paraulacoord) > 0) $this->plsubj2 = true;
3007            }
3008           
3009            // sempre hi ha subj1 a no ser que a un pseudoimpersonal el subj sigui un subverb
3010            // No serveix per frases que no tenen subjecte, estil "És un pal" o "Fa sol"
3011            if ($slotsubj1 != null) {
3012                // Si hi havia dos subjectes MIREM SI ELS DOS SUBJECTES SÓN IGUALS
3013                if ($slotsubj1->paraulafinal != null && $slotsubj2->paraulafinal != null) {
3014                    if ($slotsubj1->paraulafinal->text == $slotsubj2->paraulafinal->text) $this->subjsiguals = true;
3015                }
3016                // si els dos estaven buits, seran iguals, per la funció ordenar slots
3017                else if ($slotsubj1->paraulafinal == null && $slotsubj2->paraulafinal == null) $this->subjsiguals = true;
3018                // si el primer és null i el segon no
3019                else if ($slotsubj1->paraulafinal == null && $slotsubj2->paraulafinal != null) {
3020                    if ($slotsubj1->defvalue == '1' && $slotsubj2->paraulafinal->text == "yo") $this->subjsiguals = true;
3021                    else if ($slotsubj1->defvalue == '2' && $slotsubj2->paraulafinal->text == "tú") $this->subjsiguals = true;
3022                }
3023                // si el primer no és null i el segon ho és
3024                else if ($slotsubj1->paraulafinal != null && $slotsubj2->paraulafinal == null) {
3025                    if ($slotsubj2->defvalue == '1' && $slotsubj1->paraulafinal->text == "yo") $this->subjsiguals = true;
3026                    else if ($slotsubj2->defvalue == '2' && $slotsubj1->paraulafinal->text == "tú") $this->subjsiguals = true;
3027                }
3028            }
3029            else {
3030                $this->subjsiguals = true;
3031                // i el subjecte és en 3a persona, ja que és una proposició
3032                $this->perssubj1 = 3; 
3033            }
3034        }
3035       
3036        // si era pseudimpersonal amb subverb, si el receiver1 està definit i el subj2 no ho està,
3037        // que subj2 = receiver1
3038        if ($this->pseudoimpersonal && isset($this->slotarray["Receiver 1"]) && $keysubj2 != null
3039            && !isset($this->slotarray[$keysubj2]) ) {
3040                   
3041            $this->subjsiguals = true;
3042        }
3043       
3044        // Si és verbless que posi per defecte la 1a persona, per si hi ha "Desig" activat
3045        // Ex: "Desig" Poma = Vull una poma
3046        if ($this->defaulttense == "verbless") $this->perssubj1 = 1;
3047        // Serveix per frases que no tenen subjecte, estil "És un pal" o "Fa sol"
3048        else if ($slotsubj1 == null) $this->perssubj1 = 3;
3049    }
3050
3051    // Ordena internament les paraules de cada slot i les fa concordar en gènere i nombre entre elles
3052    // PASSOS 2 I 3 DEL GENERADOR
3053    public function ordenarSlotsInternament()
3054    {
3055        $numslots = count($this->ordrefrase);
3056        $this->getPersGenNumSubjs();
3057       
3058        for ($i=0; $i<$numslots; $i++) {
3059           
3060            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
3061            // si és un slot del subverb li passem les dades del subj2
3062            if ($slotaux->level == 2) $slotaux->ordenarSlot($this->genmascsubj2, $this->plsubj2, $this->copulatiu, $this->impersonal);
3063            else $slotaux->ordenarSlot($this->genmascsubj1, $this->plsubj1, $this->copulatiu, $this->impersonal);
3064           
3065            // si acabem de tractar un subjecte, refresquem els valors de gènere i número per si no eren
3066            // pronoms, i pels possibles adjectius que hagin de concordar amb ells, que apareixeran després
3067            // pels verbs impersonals sense subjecte també ho fem
3068            if ($slotaux->category == "Subject" || ($this->impersonal && $slotaux->category == "Theme")) {
3069                $this->getPersGenNumSubjs();
3070            }
3071        }
3072       
3073        if ($this->questiontypequant) {
3074        // fer que el quant concordi en gènere i nombre amb el nucli del theme
3075            $keytheme = "Theme";
3076            if (isset($this->slotarray["Secondary Verb 2"])) $keytheme .= " 2";
3077           
3078            $thememasc = true;
3079            $themepl = false;
3080           
3081            $slottheme = $this->slotarray[$keytheme];
3082            $slotstringtheme = $slottheme->slotstring;
3083           
3084            // canviem al nucli del theme que no necessiti article i agafem les dades de concordància
3085            $i=0;
3086            $found = false;
3087            while ($i<count($slotstringtheme) && !$found) {
3088                $aux = $slotstringtheme[$i];
3089                // si trobem el nucli
3090                if (isset($aux[2]) && $aux[2]) {
3091                    $thememasc = $aux[3];
3092                    $themepl = $aux[4];
3093                    // indiquem que el nucli del theme ja no necessitarà article
3094                    $slotstringtheme[$i][5] = true;
3095                }
3096                $i++;
3097            }
3098           
3099            // esborrem l'slotstring que hi hagués i fem concordar la partícula amb el theme
3100            $slotpartquant = $this->slotarray["PartPreguntaNoSlot"];
3101            $slotpartquant->slotstring = array();
3102            $partpregunta = $slotpartquant->paraulafinal->text;
3103           
3104            $elementaux = array();
3105            if ($thememasc && !$themepl) $partpregunta = $partpregunta; // masc sing
3106            else if ($thememasc && $themepl) $partpregunta = $partpregunta."s"; // masc pl
3107            else if (!$thememasc && !$themepl) $partpregunta = $partpregunta."a"; // fem sing
3108            else $partpregunta = $partpregunta."es"; // fem pl
3109           
3110            $elementaux[0] = $partpregunta;
3111            $elementaux[1] = $slotpartquant->paraulafinal;
3112            $elementaux[2] = false;
3113           
3114            $slotpartquant->slotstring[] = $elementaux;
3115        }
3116       
3117        // DEBUG
3118        // echo $this->printFraseFinalSlotString()."<br /><br />";
3119    }
3120   
3121    // Ordena internament les paraules de cada slot i les fa concordar en gènere i nombre entre elles
3122    // PASSOS 2 I 3 DEL GENERADOR
3123    public function ordenarSlotsInternamentES()
3124    {
3125        $numslots = count($this->ordrefrase);
3126        $this->getPersGenNumSubjsES();
3127       
3128        for ($i=0; $i<$numslots; $i++) {
3129           
3130            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
3131            // si és un slot del subverb li passem les dades del subj2
3132            if ($slotaux->level == 2) $slotaux->ordenarSlotES($this->genmascsubj2, $this->plsubj2, $this->copulatiu, $this->impersonal);
3133            else $slotaux->ordenarSlotES($this->genmascsubj1, $this->plsubj1, $this->copulatiu, $this->impersonal);
3134           
3135            // si acabem de tractar un subjecte, refresquem els valors de gènere i número per si no eren
3136            // pronoms, i pels possibles adjectius que hagin de concordar amb ells, que apareixeran després
3137            // pels verbs impersonals sense subjecte també ho fem
3138            if ($slotaux->category == "Subject" || ($this->impersonal && $slotaux->category == "Theme")) {
3139                $this->getPersGenNumSubjsES();
3140            }
3141        }
3142       
3143        if ($this->questiontypequant) {
3144        // fer que el quant concordi en gènere i nombre amb el nucli del theme
3145            $keytheme = "Theme";
3146            if (isset($this->slotarray["Secondary Verb 2"])) $keytheme .= " 2";
3147           
3148            $thememasc = true;
3149            $themepl = false;
3150           
3151            $slottheme = $this->slotarray[$keytheme];
3152            $slotstringtheme = $slottheme->slotstring;
3153           
3154            // canviem al nucli del theme que no necessiti article i agafem les dades de concordància
3155            $i=0;
3156            $found = false;
3157            while ($i<count($slotstringtheme) && !$found) {
3158                $aux = $slotstringtheme[$i];
3159                // si trobem el nucli i el nucli és un nom
3160                if (isset($aux[2]) && $aux[2]) {
3161                    $thememasc = $aux[3];
3162                    $themepl = $aux[4];
3163                    // indiquem que el nucli del theme ja no necessitarà article
3164                    $slotstringtheme[$i][5] = true;
3165                }
3166                $i++;
3167            }
3168           
3169            // esborrem l'slotstring que hi hagués i fem concordar la partícula amb el theme
3170            $slotpartquant = $this->slotarray["PartPreguntaNoSlot"];
3171            $slotpartquant->slotstring = array();
3172            $partpregunta = $slotpartquant->paraulafinal->text;
3173           
3174            $elementaux = array();
3175            if ($thememasc && !$themepl) $partpregunta = $partpregunta; // masc sing
3176            else if ($thememasc && $themepl) $partpregunta = $partpregunta."s"; // masc pl
3177            else if (!$thememasc && !$themepl) $partpregunta = substr($partpregunta, 0, -1)."a"; // fem sing
3178            else $partpregunta = substr($partpregunta, 0, -1)."as"; // fem pl
3179           
3180            $elementaux[0] = $partpregunta;
3181            $elementaux[1] = $slotpartquant->paraulafinal;
3182            $elementaux[2] = false;
3183           
3184            $slotpartquant->slotstring[] = $elementaux;
3185        }
3186       
3187        // DEBUG
3188        // echo $this->printFraseFinalSlotString()."<br /><br />";
3189    }
3190
3191    // Posa els articles als noms que hi ha a la frase, segons les propietats del nom
3192    // i el tipus d'slot on es trobi
3193    public function putArticlesToNouns($tipusfrase)
3194    { 
3195        // per cada slot
3196        for ($i=0; $i<count($this->ordrefrase); $i++) {
3197            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
3198            $slotaux->putArticles($tipusfrase, $this->questiontypequant);
3199        }
3200        // DEBUG
3201        // echo $this->printFraseFinalSlotString()."<br /><br />";
3202    }
3203   
3204    // Posa els articles als noms que hi ha a la frase, segons les propietats del nom
3205    // i el tipus d'slot on es trobi
3206    public function putArticlesToNounsES($tipusfrase)
3207    { 
3208        // per cada slot
3209        for ($i=0; $i<count($this->ordrefrase); $i++) {
3210            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
3211            $slotaux->putArticlesES($tipusfrase, $this->questiontypequant);
3212        }
3213        // DEBUG
3214        // echo $this->printFraseFinalSlotString()."<br /><br />";
3215    }
3216   
3217    // Conjuga els verbs principals, els secundaris i els de desig i permís, segons
3218    // el context (paraules de temps) i tipus de frase i els modificadors de temps
3219    public function conjugarVerbs($propietatsfrase)
3220    {
3221        $CI = &get_instance();
3222        $CI->load->model('Lexicon');
3223        $CI->load->library('Mymatching');
3224        $matching = new Mymatching();
3225               
3226        // agafem el default tense. Si no n'hi ha, perquè la frase és verbless, el posarem a present
3227        // per si ha seleccionat l'opció de desig
3228        if ($this->defaulttense == "verbless") $tense = "present";
3229        else $tense = $this->defaulttense;
3230               
3231        // per ORDRE d'importància, anem mirant si agafem un tense diferent del default
3232        if ($propietatsfrase['tipusfrase'] == "ordre") {
3233            if ($this->frasenegativa) $tense = "prsubj";
3234            else $tense = "imperatiu";
3235        }
3236        else {
3237            // si està definit el temps des de l'input, té preferència
3238            if ($propietatsfrase['tense'] != "defecte") $tense = $propietatsfrase['tense'];
3239            // si no, trajecte normal
3240            else {
3241                // si hi ha expressions de temps, la primera afegida que tingui associat
3242                // un temps verbal, és la que té preferència
3243                $found = false;
3244                $i=0;
3245                while ($i<count($this->timeexpr) && !$found) {
3246                    if (isset($matching->advsTempsTense[$this->timeexpr[$i]->text])) {
3247                        $tense = $matching->advsTempsTense[$this->timeexpr[$i]->text];
3248                        $found = true;
3249                        $tenseadvs = true;
3250                    }
3251                    $i++;
3252                }
3253            }
3254        }
3255       
3256        // Variables de persona i número dels verbs
3257        $persona = $this->perssubj1;
3258        $numero = "sing";
3259        if ($this->plsubj1) $numero = "pl";
3260       
3261        $persona2 = $this->perssubj2;
3262        $numero2 = "sing";
3263        if ($this->plsubj2) $numero2 = "pl";
3264       
3265        $desig = false;
3266        $permis = false;
3267        $subverb = false;
3268       
3269        // si el tense era imperatiu per primera persona, que no és possible, ho passem a present
3270        if ($tense == "imperatiu" && $persona == 1) $tense = "present";
3271       
3272        if ($propietatsfrase['tipusfrase'] == "desig") $desig = true;
3273        else if ($propietatsfrase['tipusfrase'] == "permis") $permis = true;
3274       
3275        if (isset($this->slotarray["Secondary Verb 2"])) $subverb = true;
3276       
3277        // conjuguem els verbs de desig o permís
3278        if ($desig || $permis) {
3279           
3280            // si el tense era imperatiu o present de subjuntiu, per una ordre positiva
3281            // o negativa, el canviem a present
3282            if ($tense == 'imperatiu' || $tense == "prsubj") $tense = "present";
3283           
3284            $slotaux;
3285            $verbid;
3286           
3287            if ($desig) {
3288                $slotaux = $this->slotarray["Desire"];
3289                $verbid = 99; // id del verb voler
3290            }
3291            if ($permis) {
3292                $slotaux = $this->slotarray["Permission"];
3293                $verbid = 104; // id del verb poder
3294            }
3295           
3296            // Els modificadors de tipuis de frase de permís o desig són per fer frases
3297            // en 1a persona "Vull que vagis a comprar" o "Puc menjar un gelat?".
3298            $verbconjugat = $CI->Lexicon->conjugar($verbid, $tense, 1, "sing", false);
3299           
3300            $auxtupla[0] = $verbconjugat."@VERBUM";
3301            $auxtupla[1] = null;
3302           
3303            $slotaux->slotstring = array();
3304            $slotaux->slotstring[] = $auxtupla;
3305            $slotaux->isInfinitive = false;
3306        }
3307       
3308        $mainverbslot;
3309        if (!$subverb) $mainverbslot = $this->slotarray["Main Verb"];
3310        else $mainverbslot = $this->slotarray["Main Verb 1"];
3311       
3312        // si era verbless, no el tractarem
3313        if ($mainverbslot->paraulafinal->text == "verbless") $mainverbslot = null;
3314       
3315        $secondaryverbslot = null;
3316        if ($subverb) $secondaryverbslot = $this->slotarray["Secondary Verb 2"];
3317       
3318        // si no era verbless
3319        if ($mainverbslot != null) {
3320           
3321            // si la frase era de permís (verb poder), tant el mainverb com el secondary verb van en infinitiu
3322            if ($permis) {
3323
3324                $verbconjugat = $CI->Lexicon->conjugar($mainverbslot->paraulafinal->id, 'infinitiu', $persona, $numero, $this->pronominal);
3325
3326                $auxtupla[0] = $verbconjugat."@VERBUM";
3327                $auxtupla[1] = $mainverbslot->paraulafinal;
3328
3329                $mainverbslot->slotstring[] = $auxtupla; // omplim l'slotstring
3330                $mainverbslot->isInfinitive = true;
3331               
3332                if ($secondaryverbslot != null) {
3333                    $verbconjugat = $CI->Lexicon->conjugar($secondaryverbslot->paraulafinal->id, 'infinitiu', $persona2, $numero2, $this->pronominal2);
3334
3335                    // posem la preposició que va davant del verb secundari, si n'hi havia
3336                    if ($secondaryverbslot->prep != null) {
3337                        $auxtupla[0] = $secondaryverbslot->prep;
3338                        $auxtupla[1] = null;
3339
3340                        // la preposició del verb secundari va darrere del verb principal
3341                       
3342                        $mainverbslot->slotstring[] = $auxtupla;
3343                    }
3344                   
3345                    $auxtupla[0] = $verbconjugat."@VERBUM";
3346                    $auxtupla[1] = $secondaryverbslot->paraulafinal;
3347
3348                    $secondaryverbslot->slotstring[] = $auxtupla;
3349                    $secondaryverbslot->isInfinitive = true;
3350                }
3351            } // Fi permís
3352            // si era un desig, el mainverb va en infinitiu (si el subjecte1 era en primera persona,
3353            // si no va en subjuntiu) i el secondary verb segons el subjecte2
3354            else if ($desig) {
3355               
3356                if ($persona == 1 && $numero == "sing") {
3357                    $verbconjugat = $CI->Lexicon->conjugarES($mainverbslot->paraulafinal->id, 'infinitiu', $persona, $numero, $this->pronominal);
3358                    $mainverbslot->isInfinitive = true;
3359                }
3360                else {
3361                    $verbconjugat = $CI->Lexicon->conjugarES($mainverbslot->paraulafinal->id, 'prsubj', $persona, $numero, $this->pronominal);
3362                   
3363                    // afegim la partícula QUE després del "Vull"
3364                    $auxtupla[0] = "que";
3365                    $auxtupla[1] = null;
3366                   
3367                    $slotaux = $this->slotarray["Desire"];
3368                    $slotaux->slotstring[] = $auxtupla;
3369                }
3370
3371                $auxtupla[0] = $verbconjugat."@VERBUM";
3372                $auxtupla[1] = $mainverbslot->paraulafinal;
3373
3374                $mainverbslot->slotstring[] = $auxtupla; // omplim l'slotstring
3375               
3376                if ($secondaryverbslot != null) {
3377                   
3378                    // si els subjectes eren iguals, també va en infinitiu
3379                    if ($this->subjsiguals) {
3380                        $verbconjugat = $CI->Lexicon->conjugar($secondaryverbslot->paraulafinal->id, 'infinitiu', $persona2, $numero2, $this->pronominal2);
3381                       
3382                        $secondaryverbslot->isInfinitive = true;
3383                       
3384                        // posem la preposició que va davant del verb secundari, si n'hi havia
3385                        if ($secondaryverbslot->prep != null) {
3386                            $auxtupla[0] = $secondaryverbslot->prep;
3387                            $auxtupla[1] = null;
3388
3389                            $secondaryverbslot->slotstring[] = $auxtupla;
3390                        }
3391                    }
3392                    // si no, aleshores va en subjuntiu (si fos en passat hauria d'anar en passat
3393                    // de subjuntiu, però el sistema encara no ho té
3394                    else {
3395                        $verbconjugat = $CI->Lexicon->conjugar($secondaryverbslot->paraulafinal->id, 'prsubj', $persona2, $numero2, $this->pronominal2);
3396                       
3397                        // posem la preposició que va darrer del verb principal, si n'hi havia
3398                        if ($secondaryverbslot->prep != null) {
3399                            $auxtupla[0] = $secondaryverbslot->prep;
3400                            $auxtupla[1] = null;
3401
3402                            $mainverbslot->slotstring[] = $auxtupla;
3403                        }
3404                       
3405                        // afegim la partícula QUE després del main verb
3406                        $auxtupla[0] = "que";
3407                        $auxtupla[1] = null;
3408                        $mainverbslot->slotstring[] = $auxtupla;
3409                    }
3410                   
3411                    $auxtupla[0] = $verbconjugat."@VERBUM";
3412                    $auxtupla[1] = $secondaryverbslot->paraulafinal;
3413
3414                    $secondaryverbslot->slotstring[] = $auxtupla;
3415                }
3416            } // Fi desig
3417           
3418            // si no, CONJUGACIÓ NORMAL
3419            else {
3420                $verbconjugat = $CI->Lexicon->conjugar($mainverbslot->paraulafinal->id, $tense, $persona, $numero, $this->pronominal);
3421
3422                $auxtupla[0] = $verbconjugat."@VERBUM";
3423                $auxtupla[1] = $mainverbslot->paraulafinal;
3424                $auxtupla[8] = true;
3425                $mainverbslot->isInfinitive = ($tense == "infinitiu"); // pel perifràstic no cal posar
3426                                        // els pronoms febles a darrere, ja que a davant hi queden millor
3427               
3428                $mainverbslot->slotstring[] = $auxtupla; // omplim l'slotstring
3429               
3430                if ($secondaryverbslot != null) {
3431                   
3432                    // si els subjectes eren iguals, també va en infinitiu
3433                    if ($this->subjsiguals) {
3434                        $verbconjugat = $CI->Lexicon->conjugar($secondaryverbslot->paraulafinal->id, 'infinitiu', $persona2, $numero2, $this->pronominal2);
3435                       
3436                        $secondaryverbslot->isInfinitive = true;
3437                       
3438                        // posem la preposició que va davant del verb secundari, si n'hi havia
3439                        if ($secondaryverbslot->prep != null) {
3440                            $auxtupla[0] = $secondaryverbslot->prep;
3441                            $auxtupla[1] = null;
3442
3443                            $secondaryverbslot->slotstring[] = $auxtupla;
3444                        }
3445                    }
3446                    // si no, aleshores va en subjuntiu (si fos en passat hauria d'anar en passat
3447                    // de subjuntiu, però el sistema encara no ho té
3448                    else {
3449                        $verbconjugat = $CI->Lexicon->conjugar($secondaryverbslot->paraulafinal->id, 'prsubj', $persona2, $numero2, $this->pronominal2);
3450                       
3451                        // posem la preposició que va darrer del verb principal, si n'hi havia
3452                        if ($secondaryverbslot->prep != null) {
3453                            $auxtupla[0] = $secondaryverbslot->prep;
3454                            $auxtupla[1] = null;
3455
3456                            $mainverbslot->slotstring[] = $auxtupla;
3457                        }
3458                       
3459                        // afegim la partícula QUE després del main verb
3460                        $auxtupla[0] = "que";
3461                        $auxtupla[1] = null;
3462                        $mainverbslot->slotstring[] = $auxtupla;
3463                    }
3464                                       
3465                    $auxtupla[0] = $verbconjugat."@VERBUM";
3466                    $auxtupla[1] = $secondaryverbslot->paraulafinal;
3467
3468                    $secondaryverbslot->slotstring[] = $auxtupla;
3469                }
3470            } // Fi conjugació normal
3471           
3472           
3473        } // Fi si no era verbless     
3474       
3475        // DEBUG
3476        // echo $this->printFraseFinalSlotString()."<br /><br />";
3477    }
3478   
3479    // Conjuga els verbs principals, els secundaris i els de desig i permís, segons
3480    // el context (paraules de temps) i tipus de frase i els modificadors de temps
3481    public function conjugarVerbsES($propietatsfrase)
3482    {
3483        $CI = &get_instance();
3484        $CI->load->model('Lexicon');
3485        $CI->load->library('Mymatching');
3486        $matching = new Mymatching();
3487               
3488        // agafem el default tense. Si no n'hi ha, perquè la frase és verbless, el posarem a present
3489        // per si ha seleccionat l'opció de desig
3490        if ($this->defaulttense == "verbless") $tense = "present";
3491        else $tense = $this->defaulttense;
3492               
3493        // per ORDRE d'importància, anem mirant si agafem un tense diferent del default
3494        if ($propietatsfrase['tipusfrase'] == "ordre") {
3495            if ($this->frasenegativa) $tense = "prsubj";
3496            else $tense = "imperatiu";
3497        }
3498        else {
3499            // si està definit el temps des de l'input, té preferència
3500            if ($propietatsfrase['tense'] != "defecte") $tense = $propietatsfrase['tense'];
3501            // si no, trajecte normal
3502            else {
3503                // si hi ha expressions de temps, la primera afegida que tingui associat
3504                // un temps verbal, és la que té preferència
3505                $found = false;
3506                $i=0;
3507                while ($i<count($this->timeexpr) && !$found) {
3508                    if (isset($matching->advsTempsTenseES[$this->timeexpr[$i]->text])) {
3509                        $tense = $matching->advsTempsTenseES[$this->timeexpr[$i]->text];
3510                        $found = true;
3511                        $tenseadvs = true;
3512                    }
3513                    $i++;
3514                }
3515            }
3516        }
3517       
3518        // Variables de persona i número dels verbs
3519        $persona = $this->perssubj1;
3520        $numero = "sing";
3521        if ($this->plsubj1) $numero = "pl";
3522       
3523        $persona2 = $this->perssubj2;
3524        $numero2 = "sing";
3525        if ($this->plsubj2) $numero2 = "pl";
3526       
3527        $desig = false;
3528        $permis = false;
3529        $subverb = false;
3530       
3531        // En castellà no hi ha perifràstic, és passat
3532        if ($tense == "perifrastic") $tense = "passat";
3533       
3534        // si el tense era imperatiu per primera persona, que no és possible, ho passem a present
3535        if ($tense == "imperatiu" && $persona == 1) $tense = "present";
3536       
3537        if ($propietatsfrase['tipusfrase'] == "desig") $desig = true;
3538        else if ($propietatsfrase['tipusfrase'] == "permis") $permis = true;
3539       
3540        if (isset($this->slotarray["Secondary Verb 2"])) $subverb = true;
3541       
3542        // conjuguem els verbs de desig o permís
3543        if ($desig || $permis) {
3544           
3545            // si el tense era imperatiu o present de subjuntiu, per una ordre positiva
3546            // o negativa, el canviem a present
3547            if ($tense == 'imperatiu' || $tense == "prsubj") $tense = "present";
3548           
3549            $slotaux;
3550            $verbid;
3551           
3552            if ($desig) {
3553                $slotaux = $this->slotarray["Desire"];
3554                $verbid = 99; // id del verb voler
3555            }
3556            if ($permis) {
3557                $slotaux = $this->slotarray["Permission"];
3558                $verbid = 104; // id del verb poder
3559            }
3560           
3561            // Els modificadors de tipuis de frase de permís o desig són per fer frases
3562            // en 1a persona "Vull que vagis a comprar" o "Puc menjar un gelat?".
3563            $verbconjugat = $CI->Lexicon->conjugarES($verbid, $tense, 1, "sing", false);
3564           
3565            $auxtupla[0] = $verbconjugat."@VERBUM";
3566            $auxtupla[1] = null;
3567           
3568            $slotaux->slotstring = array();
3569            $slotaux->slotstring[] = $auxtupla;
3570            $slotaux->isInfinitive = false;
3571        }
3572       
3573        $mainverbslot;
3574        if (!$subverb) $mainverbslot = $this->slotarray["Main Verb"];
3575        else $mainverbslot = $this->slotarray["Main Verb 1"];
3576       
3577        // si era verbless, no el tractarem
3578        if ($mainverbslot->paraulafinal->text == "verbless") $mainverbslot = null;
3579       
3580        $secondaryverbslot = null;
3581        if ($subverb) $secondaryverbslot = $this->slotarray["Secondary Verb 2"];
3582       
3583        // si no era verbless
3584        if ($mainverbslot != null) {
3585           
3586            // si la frase era de permís (verb poder), tant el mainverb com el secondary verb van en infinitiu
3587            if ($permis) {
3588
3589                $verbconjugat = $CI->Lexicon->conjugarES($mainverbslot->paraulafinal->id, 'infinitiu', $persona, $numero, $this->pronominal);
3590
3591                $auxtupla[0] = $verbconjugat."@VERBUM";
3592                $auxtupla[1] = $mainverbslot->paraulafinal;
3593
3594                $mainverbslot->slotstring[] = $auxtupla; // omplim l'slotstring
3595                $mainverbslot->isInfinitive = true;
3596               
3597                if ($secondaryverbslot != null) {
3598                    $verbconjugat = $CI->Lexicon->conjugarES($secondaryverbslot->paraulafinal->id, 'infinitiu', $persona2, $numero2, $this->pronominal2);
3599
3600                    // posem la preposició que va davant del verb secundari, si n'hi havia
3601                    if ($secondaryverbslot->prep != null) {
3602                        $auxtupla[0] = $secondaryverbslot->prep;
3603                        $auxtupla[1] = null;
3604
3605                        // la preposició del verb secundari va darrere del verb principal
3606                       
3607                        $mainverbslot->slotstring[] = $auxtupla;
3608                    }
3609                   
3610                    $auxtupla[0] = $verbconjugat."@VERBUM";
3611                    $auxtupla[1] = $secondaryverbslot->paraulafinal;
3612
3613                    $secondaryverbslot->slotstring[] = $auxtupla;
3614                    $secondaryverbslot->isInfinitive = true;
3615                }
3616            } // Fi permís
3617            // si era un desig, el mainverb va en infinitiu (si el subjecte1 era en primera persona,
3618            // si no va en subjuntiu) i el secondary verb segons el subjecte2
3619            else if ($desig) {
3620               
3621                if ($persona == 1 && $numero == "sing") {
3622                    $verbconjugat = $CI->Lexicon->conjugarES($mainverbslot->paraulafinal->id, 'infinitiu', $persona, $numero, $this->pronominal);
3623                    $mainverbslot->isInfinitive = true;
3624                }
3625                else {
3626                    $verbconjugat = $CI->Lexicon->conjugarES($mainverbslot->paraulafinal->id, 'prsubj', $persona, $numero, $this->pronominal);
3627                   
3628                    // afegim la partícula QUE després del "Quiero"
3629                    $auxtupla[0] = "que";
3630                    $auxtupla[1] = null;
3631                   
3632                    $slotaux = $this->slotarray["Desire"];
3633                    $slotaux->slotstring[] = $auxtupla;
3634                }
3635               
3636                $auxtupla[0] = $verbconjugat."@VERBUM";
3637                $auxtupla[1] = $mainverbslot->paraulafinal;
3638
3639                $mainverbslot->slotstring[] = $auxtupla; // omplim l'slotstring
3640               
3641                if ($secondaryverbslot != null) {
3642                   
3643                    // si els subjectes eren iguals, va en infinitiu
3644                    if ($this->subjsiguals) {
3645                        $verbconjugat = $CI->Lexicon->conjugarES($secondaryverbslot->paraulafinal->id, 'infinitiu', $persona2, $numero2, $this->pronominal2);
3646                       
3647                        $secondaryverbslot->isInfinitive = true;
3648                       
3649                        // posem la preposició que va davant del verb secundari, si n'hi havia
3650                        if ($secondaryverbslot->prep != null) {
3651                            $auxtupla[0] = $secondaryverbslot->prep;
3652                            $auxtupla[1] = null;
3653
3654                            $secondaryverbslot->slotstring[] = $auxtupla;
3655                        }
3656                    }
3657                    // si no, aleshores va en subjuntiu (si fos en passat hauria d'anar en passat
3658                    // de subjuntiu, però el sistema encara no ho té
3659                    else {
3660                        $verbconjugat = $CI->Lexicon->conjugarES($secondaryverbslot->paraulafinal->id, 'prsubj', $persona2, $numero2, $this->pronominal2);
3661                       
3662                        // posem la preposició que darrere del verb principal, si n'hi havia
3663                        if ($secondaryverbslot->prep != null) {
3664                            $auxtupla[0] = $secondaryverbslot->prep;
3665                            $auxtupla[1] = null;
3666
3667                            $mainverbslot->slotstring[] = $auxtupla;
3668                        }
3669                       
3670                        // afegim la partícula QUE després del main verb
3671                        $auxtupla[0] = "que";
3672                        $auxtupla[1] = null;
3673                        $mainverbslot->slotstring[] = $auxtupla;
3674                    }
3675                   
3676                    $auxtupla[0] = $verbconjugat."@VERBUM";
3677                    $auxtupla[1] = $secondaryverbslot->paraulafinal;
3678
3679                    $secondaryverbslot->slotstring[] = $auxtupla;
3680                }
3681            } // Fi desig
3682           
3683            // si no, CONJUGACIÓ NORMAL
3684            else {
3685                $verbconjugat = $CI->Lexicon->conjugarES($mainverbslot->paraulafinal->id, $tense, $persona, $numero, $this->pronominal);
3686
3687                $auxtupla[0] = $verbconjugat."@VERBUM";
3688                $auxtupla[1] = $mainverbslot->paraulafinal;
3689                $auxtupla[8] = true;
3690                $mainverbslot->isInfinitive = ($tense == "infinitiu"); // pel perifràstic no cal posar
3691                                        // els pronoms febles a darrere, ja que a davant hi queden millor
3692               
3693                $mainverbslot->slotstring[] = $auxtupla; // omplim l'slotstring
3694               
3695                if ($secondaryverbslot != null) {
3696                   
3697                    // si els subjectes eren iguals, també va en infinitiu
3698                    if ($this->subjsiguals) {
3699                        $verbconjugat = $CI->Lexicon->conjugarES($secondaryverbslot->paraulafinal->id, 'infinitiu', $persona2, $numero2, $this->pronominal2);
3700                       
3701                        $secondaryverbslot->isInfinitive = true;
3702                       
3703                        // posem la preposició que va davant del verb secundari, si n'hi havia
3704                        if ($secondaryverbslot->prep != null) {
3705                            $auxtupla[0] = $secondaryverbslot->prep;
3706                            $auxtupla[1] = null;
3707
3708                            $secondaryverbslot->slotstring[] = $auxtupla;
3709                        }
3710                    }
3711                    // si no, aleshores va en subjuntiu (si fos en passat hauria d'anar en passat
3712                    // de subjuntiu, però el sistema encara no ho té
3713                    else {
3714                        $verbconjugat = $CI->Lexicon->conjugarES($secondaryverbslot->paraulafinal->id, 'prsubj', $persona2, $numero2, $this->pronominal2);
3715                       
3716                        // posem la preposició que darrere del verb principal, si n'hi havia
3717                        if ($secondaryverbslot->prep != null) {
3718                            $auxtupla[0] = $secondaryverbslot->prep;
3719                            $auxtupla[1] = null;
3720
3721                            $mainverbslot->slotstring[] = $auxtupla;
3722                        }
3723                       
3724                        // afegim la partícula QUE després del main verb
3725                        $auxtupla[0] = "que";
3726                        $auxtupla[1] = null;
3727                        $mainverbslot->slotstring[] = $auxtupla;
3728                    }
3729                                       
3730                    $auxtupla[0] = $verbconjugat."@VERBUM";
3731                    $auxtupla[1] = $secondaryverbslot->paraulafinal;
3732
3733                    $secondaryverbslot->slotstring[] = $auxtupla;
3734                }
3735            } // Fi conjugació normal
3736           
3737           
3738        } // Fi si no era verbless     
3739       
3740        // DEBUG
3741        // echo $this->printFraseFinalSlotString()."<br /><br />";
3742    }
3743   
3744    // Treure els "jo" i "tu" dels subjectes. Canviar receivers a pronoms febles i posar-los
3745    // a darrere el verb si cal. Posar modificadors de frase com el "no" o el "també".
3746    // Fusionar preposicions amb articles (de+el/s = del/s... a+el, per+el...). Posar apòstrofs
3747    // de preps i pronoms febles (i guions?). Netejar espais abans o després dels apòstrofs.
3748    // Escriure la frase final, posant les expressions i altres advs de temps al final.
3749    public function launchCleaner($tipusfrase)
3750    {
3751        $CI = &get_instance();
3752        $CI->load->library('Mymatching');
3753        $CI->load->library('Myslot');
3754       
3755        $matching = new Mymatching();
3756       
3757        // TREURE ELS "JO" I "TU" i agafar info dels verbs per després
3758        $keymainverb = null;
3759        $indexmainverb = -1;
3760        $indexsecondaryverb = -1;
3761       
3762        $indextheme1 = -1;
3763        $indextheme2 = -1;
3764       
3765        $indexdesire = -1;
3766        $indexpermission = -1;
3767       
3768        $mainverbinf = false;
3769        $secondaryverbinf = false;
3770               
3771        $numslots = count($this->ordrefrase);
3772       
3773        for ($i=0; $i<$numslots; $i++) {
3774            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
3775           
3776            if ($slotaux->category == "Main Verb") {
3777                $indexmainverb = $i;
3778                if ($slotaux->isInfinitive) $mainverbinf = true;
3779                $keymainverb = $this->ordrefrase[$i]; // agafem el key del main verb pel pas dels modificadors
3780            }
3781            else if ($slotaux->category == "Secondary Verb") {
3782                $indexsecondaryverb = $i;
3783                if ($slotaux->isInfinitive) $secondaryverbinf = true;
3784            }
3785            else if ($slotaux->category == "Theme") {
3786                if ($slotaux->level == 1 && $slotaux->defvalueused && $slotaux->defvalue == "ho") $indextheme1 = $i;
3787                else if ($slotaux->level == 2 && $slotaux->defvalueused && $slotaux->defvalue == "ho") $indextheme2 = $i;
3788            }
3789            else if ($slotaux->category == "Desire") $indexdesire = $i;
3790            else if ($slotaux->category == "Permission") $indexpermission = $i;
3791            else if ($slotaux->category == "Subject") {
3792                if ($slotaux->defvalueused) {
3793                    // esborrem el tu o jo o 3a persona impersonal o vostè quan hi són per defecte
3794                    if ($slotaux->defvalue == '1' || $slotaux->defvalue == '2' 
3795                            || $slotaux->defvalue == '3' || $slotaux->defvalue == '7') $slotaux->slotstring = array();
3796                }
3797                // si no s'ha fet servir el subjecte per defecte
3798                else {
3799                    // esborrem el tu o el jo (si no tenen cap element coordinat)
3800                    if (($slotaux->paraulafinal->text == "jo" || $slotaux->paraulafinal->text == "tu") 
3801                            && !$slotaux->paraulafinal->coord) {
3802                        $slotaux->slotstring = array();
3803                    }
3804                    // esborrem el subjecte del verb secundari, si és el mateix que el del principal
3805                    if ($slotaux->level == 2 && $this->subjsiguals) {
3806                        $slotaux->slotstring = array();
3807                    }
3808                }
3809            }
3810        }
3811       
3812        $indexreceiver1 = -1;
3813        $indexreceiver2 = -1;
3814       
3815        $receiver1pron = false;
3816        $receiver2pron = false;
3817        $theme1pron = false;
3818        $theme2pron = false;
3819       
3820        // si és una ordre els pronoms aniran darrere el verb i tindran una altra forma
3821        $ordre = ($tipusfrase == "ordre");
3822        $elementaux = array();
3823       
3824       
3825        // TRANSFORMAR ELS PRONOMS A FEBLES DEL RECEIVER O DEL THEME
3826        for ($i=0; $i<$numslots; $i++) {
3827            $slotaux = $this->slotarray[$this->ordrefrase[$i]];
3828           
3829            if ($slotaux->category == "Receiver") {
3830                // si hi ha valors per defecte
3831                if ($slotaux->defvalueused) {
3832                    if ($slotaux->defvalue == "mi") {
3833                        // posar "me", si és infinitiu o ordre positiva, els apòstrofs després
3834                        if (($slotaux->level == 1 && $mainverbinf) || 
3835                                ($slotaux->level == 1 && $ordre && !$this->frasenegativa)) {
3836                            $slotaux->slotstring = array();
3837                            $elementaux[0] = "me";
3838                            $elementaux[1] = null;
3839                            $slotaux->slotstring[] = $elementaux;
3840                            $indexreceiver1 = $i;
3841                            $receiver1pron = true;
3842                        }
3843                        // posar "me"
3844                        else if ($slotaux->level == 2 && $secondaryverbinf) {
3845                            $slotaux->slotstring = array();
3846                            $elementaux[0] = "me";
3847                            $elementaux[1] = null;
3848                            $slotaux->slotstring[] = $elementaux;
3849                            $indexreceiver2 = $i;
3850                            $receiver2pron = true;
3851                        }
3852                        // posar "em"
3853                        else {
3854                            $slotaux->slotstring = array();
3855                            $elementaux[0] = "em";
3856                            $elementaux[1] = null;
3857                            $slotaux->slotstring[] = $elementaux;
3858                            if ($slotaux->level == 1) {
3859                                $indexreceiver1 = $i;
3860                                $receiver1pron = true;
3861                            }
3862                            else if ($slotaux->level == 2) {
3863                                $indexreceiver2 = $i;
3864                                $receiver2pron = true;
3865                            }
3866                        }
3867                    }
3868                    else if ($slotaux->defvalue == "tu") {
3869                        // posar "te"
3870                        if ($slotaux->level == 1 && $mainverbinf || 
3871                                ($slotaux->level == 1 && $ordre && !$this->frasenegativa)) {
3872                            $slotaux->slotstring = array();
3873                            $elementaux[0] = "te";
3874                            $elementaux[1] = null;
3875                            $slotaux->slotstring[] = $elementaux;
3876                            $indexreceiver1 = $i;
3877                            $receiver1pron = true;
3878                        }
3879                        // posar "te"
3880                        else if ($slotaux->level == 2 && $secondaryverbinf) {
3881                            $slotaux->slotstring = array();
3882                            $elementaux[0] = "te";
3883                            $elementaux[1] = null;
3884                            $slotaux->slotstring[] = $elementaux;
3885                            $indexreceiver2 = $i;
3886                            $receiver2pron = true;
3887                        }
3888                        // posar "et"
3889                        else {
3890                            $slotaux->slotstring = array();
3891                            $elementaux[0] = "et";
3892                            $elementaux[1] = null;
3893                            $slotaux->slotstring[] = $elementaux;
3894                            if ($slotaux->level == 1) {
3895                                $indexreceiver1 = $i;
3896                                $receiver1pron = true;
3897                            }
3898                            else if ($slotaux->level == 2) {
3899                                $indexreceiver2 = $i;
3900                                $receiver2pron = true;
3901                            }
3902                        }
3903                    }
3904                }
3905                // si no hi ha valors per defecte -> transformar tots els pronoms personals
3906                else {
3907                    if (($slotaux->level == 1 && $mainverbinf) 
3908                            || ($slotaux->level == 1 && $ordre && !$this->frasenegativa)) {
3909                        // si són pronoms personals, posem la forma correcta pels receivers de darrere el verb
3910                        if ($matching->isPronomPers($slotaux->paraulafinal->text)) {
3911                            $slotaux->slotstring = array();
3912                            $elementaux[0] = $matching->pronomsPersonalsAfterReceiver[$slotaux->paraulafinal->text];                         
3913                            $elementaux[1] = null;
3914                            $slotaux->slotstring[] = $elementaux;
3915                            $indexreceiver1 = $i;
3916                            $receiver1pron = true;
3917                        }                       
3918                    }
3919                    else if ($slotaux->level == 1) {
3920                        // si són pronoms personals, posem la forma correcta pels receivers d'abans del verb
3921                        if ($matching->isPronomPers($slotaux->paraulafinal->text)) {
3922                            $slotaux->slotstring = array();
3923                            $elementaux[0] = $matching->pronomsPersonalsFrontReceiver[$slotaux->paraulafinal->text];                         
3924                            $elementaux[1] = null;
3925                            $slotaux->slotstring[] = $elementaux;
3926                            $indexreceiver1 = $i;
3927                            $receiver1pron = true;
3928                        }
3929                    }
3930                    else if ($slotaux->level == 2 && $secondaryverbinf) {
3931                        // si són pronoms personals, posem la forma correcta pels receivers de darrere el verb
3932                        if ($matching->isPronomPers($slotaux->paraulafinal->text)) {
3933                            $slotaux->slotstring = array();
3934                            $elementaux[0] = $matching->pronomsPersonalsAfterReceiver[$slotaux->paraulafinal->text];                         
3935                            $elementaux[1] = null;
3936                            $slotaux->slotstring[] = $elementaux;
3937                            $indexreceiver2 = $i;
3938                            $receiver2pron = true;
3939                        }                       
3940                    }
3941                    else if ($slotaux->level == 2) {
3942                        // si són pronoms personals, posem la forma correcta pels receivers d'abans del verb
3943                        if ($matching->isPronomPers($slotaux->paraulafinal->text)) {
3944                            $slotaux->slotstring = array();
3945                            $elementaux[0] = $matching->pronomsPersonalsFrontReceiver[$slotaux->paraulafinal->text];                         
3946                            $elementaux[1] = null;
3947                            $slotaux->slotstring[] = $elementaux;
3948                            $indexreceiver2 = $i;
3949                            $receiver2pron = true;
3950                        }
3951                    }                   
3952                }
3953            } // Fi if slotaux = receiver
3954           
3955           
3956            else if ($slotaux->category == "Theme") {
3957                // si hi ha valors per defecte
3958                if ($slotaux->defvalueused) {
3959                    if ($slotaux->defvalue == "jo") {
3960                        // posar "me", si és infinitiu o ordre positiva, els apòstrofs després
3961                        if (($slotaux->level == 1 && $mainverbinf) || 
3962                                ($slotaux->level == 1 && $ordre && !$this->frasenegativa)) {
3963                            $slotaux->slotstring = array();
3964                            $elementaux[0] = "me";
3965                            $elementaux[1] = null;
3966                            $slotaux->slotstring[] = $elementaux;
3967                            $indextheme1 = $i;
3968                            $theme1pron = true;
3969                        }
3970                        // posar "me"
3971                        else if ($slotaux->level == 2 && $secondaryverbinf) {
3972                            $slotaux->slotstring = array();
3973                            $elementaux[0] = "me";
3974                            $elementaux[1] = null;
3975                            $slotaux->slotstring[] = $elementaux;
3976                            $indextheme2 = $i;
3977                            $theme2pron = true;
3978                        }
3979                        // posar "em"
3980                        else {
3981                            $slotaux->slotstring = array();
3982                            $elementaux[0] = "em";
3983                            $elementaux[1] = null;
3984                            $slotaux->slotstring[] = $elementaux;
3985                            if ($slotaux->level == 1) {
3986                                $indextheme1 = $i;
3987                                $theme1pron = true;
3988                            }
3989                            else if ($slotaux->level == 2) {
3990                                $indextheme2 = $i;
3991                                $theme2pron = true;
3992                            }
3993                        }
3994                    }
3995                    else if ($slotaux->defvalue == "tu") {
3996                        // posar "te"
3997                        if ($slotaux->level == 1 && $mainverbinf || 
3998                                ($slotaux->level == 1 && $ordre && !$this->frasenegativa)) {
3999                            $slotaux->slotstring = array();
4000                            $elementaux[0] = "te";
4001                            $elementaux[1] = null;
4002                            $slotaux->slotstring[] = $elementaux;
4003                            $indextheme1 = $i;
4004                            $theme1pron = true;
4005                        }
4006                        // posar "te"
4007                        else if ($slotaux->level == 2 && $secondaryverbinf) {
4008                            $slotaux->slotstring = array();
4009                            $elementaux[0] = "te";
4010                            $elementaux[1] = null;
4011                            $slotaux->slotstring[] = $elementaux;
4012                            $indextheme2 = $i;
4013                            $theme2pron = true;
4014                        }
4015                        // posar "et"
4016                        else {
4017                            $slotaux->slotstring = array();
4018                            $elementaux[0] = "et";
4019                            $elementaux[1] = null;
4020                            $slotaux->slotstring[] = $elementaux;
4021                            if ($slotaux->level == 1) {
4022                                $indextheme1 = $i;
4023                                $theme1pron = true;
4024                            }
4025                            else if ($slotaux->level == 2) {
4026                                $indextheme2 = $i;
4027                                $theme2pron = true;
4028                            }
4029                        }
4030                    }
4031                }
4032                // si no hi ha valors per defecte -> transformar tots els pronoms personals
4033                else {
4034                   
4035                    $parauladerivada = $slotaux->slotstring[0];
4036                    $parauladerivada = $parauladerivada[0]; 
4037                    // si hi ha una preposicio davant del pronom, no hauria de fer el canvi
4038                   
4039                    if (($slotaux->level == 1 && $mainverbinf) 
4040                            || ($slotaux->level == 1 && $ordre && !$this->frasenegativa)) {
4041                        // si són pronoms personals, posem la forma correcta pels themes de darrere el verb
4042                        // menys si és un patró verbless, on la frase només tindrà el pronom
4043                        if ($matching->isPronomPers($parauladerivada) && !$this->verbless) {
4044                            $slotaux->slotstring = array();
4045                            $elementaux[0] = $matching->pronomsPersonalsAfterTheme[$parauladerivada];                         
4046                            $elementaux[1] = null;
4047                            $slotaux->slotstring[] = $elementaux;
4048                            $indextheme1 = $i;
4049                            $theme1pron = true;
4050                        }                       
4051                    }
4052                    else if ($slotaux->level == 1) {
4053                        // si són pronoms personals, posem la forma correcta pels themes d'abans del verb
4054                        // menys si és un patró verbless, on la frase només tindrà el pronom
4055                        if ($matching->isPronomPers($parauladerivada) && !$this->verbless) {
4056                            $slotaux->slotstring = array();
4057                            $elementaux[0] = $matching->pronomsPersonalsFrontTheme[$parauladerivada];                         
4058                            $elementaux[1] = null;
4059                            $slotaux->slotstring[] = $elementaux;
4060                            $indextheme1 = $i;
4061                            $theme1pron = true;
4062                        }
4063                    }
4064                    else if ($slotaux->level == 2 && $secondaryverbinf) {
4065                        // si són pronoms personals, posem la forma correcta pels themes de darrere el verb
4066                        if ($matching->isPronomPers($parauladerivada)) {
4067                            $slotaux->slotstring = array();
4068                            $elementaux[0] = $matching->pronomsPersonalsAfterTheme[$parauladerivada];                         
4069                            $elementaux[1] = null;
4070                            $slotaux->slotstring[] = $elementaux;
4071                            $indextheme2 = $i;
4072                            $theme2pron = true;
4073                        }                       
4074                    }
4075                    else if ($slotaux->level == 2) {
4076                        // si són pronoms personals, posem la forma correcta pels themes d'abans del verb
4077                        if ($matching->isPronomPers($parauladerivada)) {
4078                            $slotaux->slotstring = array();
4079                            $elementaux[0] = $matching->pronomsPersonalsFrontTheme[$parauladerivada];                         
4080                            $elementaux[1] = null;
4081                            $slotaux->slotstring[] = $elementaux;
4082                            $indextheme2 = $i;
4083                            $theme2pron = true;
4084                        }
4085                    }                   
4086                }
4087            } // Fi if slotaux = theme
4088           
4089           
4090        } // Fi for transformar pronoms
4091               
4092        // ORDRE DELS PRONOMS
4093        // amb tota la info recollida, movem els pronoms de lloc si cal
4094        // pel main verb si és infinitiu (els d'ordre ja són a darrere)
4095        if ($mainverbinf) {
4096            // el theme 1
4097            if ($indextheme1 != -1) {
4098                $temp = $this->ordrefrase[$indextheme1];
4099                // esborrem el theme 1 per moure'l de lloc
4100                array_splice($this->ordrefrase, $indextheme1, 1);
4101                // l'insertem just després del main verb
4102                array_splice($this->ordrefrase, $indexmainverb, 0, $temp);
4103                $indextheme1 = $indexmainverb;
4104                $indexmainverb -= 1;
4105            }
4106            // el receiver 1
4107            if ($indexreceiver1 != -1) {
4108                $temp = $this->ordrefrase[$indexreceiver1];
4109                // esborrem el theme 1 per moure'l de lloc
4110                array_splice($this->ordrefrase, $indexreceiver1, 1);
4111                // l'insertem just després del main verb
4112                array_splice($this->ordrefrase, $indexmainverb, 0, $temp);
4113                $indexreceiver1 = $indexmainverb;
4114                $indexmainverb -= 1;
4115            }
4116        }
4117        // pel verb secundari si és infinitiu
4118        if ($secondaryverbinf) {
4119            // el theme 2
4120            if ($indextheme2 != -1) {
4121                $temp = $this->ordrefrase[$indextheme2];
4122                // esborrem el theme 1 per moure'l de lloc
4123                array_splice($this->ordrefrase, $indextheme2, 1);
4124                // l'insertem just després del main verb
4125                array_splice($this->ordrefrase, $indexsecondaryverb, 0, $temp);
4126                $indextheme2 = $indexsecondaryverb;
4127                $indexsecondaryverb -= 1;
4128            }
4129            // el receiver 2
4130            if ($indexreceiver2 != -1) {
4131                $temp = $this->ordrefrase[$indexreceiver2];
4132                // esborrem el theme 1 per moure'l de lloc
4133                array_splice($this->ordrefrase, $indexreceiver2, 1);
4134                // l'insertem just després del main verb
4135                array_splice($this->ordrefrase, $indexsecondaryverb, 0, $temp);
4136                $indexreceiver2 = $indexsecondaryverb;
4137                $indexsecondaryverb -= 1;
4138            }
4139        }
4140       
4141       
4142        // ORDRE MODIFICADORS DE FRASE QUE NO VAN AL PRINCIPI: "NO", "TAMBÉ"
4143        // agafem els modificadors, si n'hi ha
4144        $slotmainverb = $this->slotarray[$keymainverb];
4145        $counter = 0;
4146        $indexsmodifs = array();
4147        $janegatiu = false;
4148       
4149        if ($slotmainverb->CModassigned) {
4150            for ($i=0; $i<count($slotmainverb->cmpMod); $i++) {
4151               
4152                $keymodifaux = $slotmainverb->CModassignedkey[$i];
4153                $slotmodifaux = $slotmainverb->cmpMod[$keymodifaux];
4154
4155                // si és del grup que va darrere el subjecte (ex: no, també)
4156                if ($matching->isModAfterSubj($slotmodifaux->paraulafinal->text)) {
4157                   
4158                    // indiquem, que si la frase era negativa, ja no caldrà afegir el no
4159                    if ($slotmodifaux->paraulafinal->text == "no") $janegatiu = true;
4160                   
4161                    // Creem un slot, el posem a slotarray i de moment al final d'ordrefrase
4162                    $counter += 1;
4163                    $newslotmodif = new Myslot();
4164                    $newslotmodif->category = "Modifier ".$counter;
4165                    $newslotmodif->grade = "opt";
4166                    $newslotmodif->type = "modif";
4167                    $newslotmodif->full = true;
4168                    $newslotmodif->paraulafinal = $slotmodifaux->paraulafinal;
4169                   
4170                    $elementaux = array();
4171                    $elementaux[0] = $slotmodifaux->paraulafinal->text;
4172                    $elementaux[1] = $slotmodifaux->paraulafinal;
4173                    $newslotmodif->slotstring[] = $elementaux;
4174                    $newslotmodif->puntsfinal = 7;
4175                   
4176                    $this->slotarray["Modifier ".$counter] = $newslotmodif;
4177                    $this->ordrefrase[] = "Modifier ".$counter;
4178                    $indexsmodifs[] = $numslots;
4179                }
4180            }
4181        }
4182       
4183        // afegim un slot amb el no si la frase era negativa i no l'hem afegit ja
4184        if ($this->frasenegativa && !$janegatiu) {
4185            // Creem un slot, el posem a slotarray i de moment al final d'ordrefrase
4186            $counter += 1;
4187            $newslotmodif = new Myslot();
4188            $newslotmodif->category = "Modifier ".$counter;
4189            $newslotmodif->grade = "opt";
4190            $newslotmodif->type = "modif";
4191            $newslotmodif->full = true;
4192
4193            $elementaux = array();
4194            $elementaux[0] = "no";
4195            $elementaux[1] = null;
4196            $newslotmodif->slotstring[] = $elementaux;
4197            $newslotmodif->puntsfinal = 7;
4198
4199            $this->slotarray["Modifier ".$counter] = $newslotmodif;
4200            $this->ordrefrase[] = "Modifier ".$counter;
4201            $indexsmodifs[] = $numslots;
4202        }
4203           
4204        // si hem trobat algun d'aquests slots, els col·loquem al lloc on toqui
4205        if ($counter > 0) {
4206            for ($i=0; $i<count($indexsmodifs); $i++) {
4207                $indexmodifaux = $indexsmodifs[$i];
4208               
4209                // si hi ha un verb de desig, posar-los abans, amb els de permís van darrere del permís
4210                if ($indexdesire != -1) {
4211                    $indexaux = $indexdesire;
4212                   
4213                    $temp = $this->ordrefrase[$indexmodifaux];
4214                    // esborrem el modif per moure'l de lloc
4215                    array_splice($this->ordrefrase, $indexmodifaux, 1);
4216                    // l'insertem just abans del receiver
4217                    array_splice($this->ordrefrase, $indexaux, 0, $temp);
4218                }
4219                // si els possibles pronoms que hi hagi, van abans del verb principal
4220                else if (!$mainverbinf && (!$ordre || $this->frasenegativa)) {
4221
4222                    // si hi ha receiver, que sempre va abans del theme en versió pronominal
4223                    // el posem abans del receiver
4224                    if ($receiver1pron) {
4225                        $temp = $this->ordrefrase[$indexmodifaux];
4226                        // esborrem el modif per moure'l de lloc
4227                        array_splice($this->ordrefrase, $indexmodifaux, 1);
4228                        // l'insertem just abans del receiver
4229                        array_splice($this->ordrefrase, $indexreceiver1, 0, $temp);
4230                    }
4231                    // si hi ha theme i no receiver, el posem abans del theme
4232                    else if ($indextheme1 != -1) {
4233                        $temp = $this->ordrefrase[$indexmodifaux];
4234                        // esborrem el modif per moure'l de lloc
4235                        array_splice($this->ordrefrase, $indexmodifaux, 1);
4236                        // l'insertem just abans del receiver
4237                        array_splice($this->ordrefrase, $indextheme1, 0, $temp);
4238                    }
4239                    // si no hi ha ni receiver, ni theme, el posem abans del mainverb
4240                    else {
4241                        $temp = $this->ordrefrase[$indexmodifaux];
4242                        // esborrem el modif per moure'l de lloc
4243                        array_splice($this->ordrefrase, $indexmodifaux, 1);
4244                        // l'insertem just abans del receiver
4245                        array_splice($this->ordrefrase, $indexmainverb, 0, $temp);
4246                    }
4247                }
4248                // si no, va just abans del verb
4249                else {
4250                    $temp = $this->ordrefrase[$indexmodifaux];
4251                    // esborrem el modif per moure'l de lloc
4252                    array_splice($this->ordrefrase, $indexmodifaux, 1);
4253                    // l'insertem just abans del receiver
4254                    array_splice($this->ordrefrase, $indexmainverb, 0, $temp);
4255                }
4256            }
4257        } // Fi si hi ha algun slot de modificador d'aquesta mena
4258       
4259        // AJUNTAR PREPS+ARTS / PRONOMS FEBLES I APÒSTROFS
4260        $frasebruta = $this->frasefinal.$this->printFraseFinalSlotString();
4261       
4262        // perps + arts
4263        $patterns[0] = '/[[:space:]][d][e][[:space:]][e][l][[:space:]]/u'; 
4264        $patterns[1] = '/[[:space:]][d][e][[:space:]][e][l][s][[:space:]]/u';
4265        $patterns[2] = '/[[:space:]][a][[:space:]][e][l][[:space:]]/u';
4266        $patterns[3] = '/[[:space:]][a][[:space:]][e][l][s][[:space:]]/u';
4267        $patterns[4] = '/[[:space:]][p][e][r][[:space:]][e][l][[:space:]]/u';
4268        $patterns[5] = '/[[:space:]][p][e][r][[:space:]][e][l][s][[:space:]]/u';
4269       
4270        // de => d'
4271        $patterns[6] = '/[[:space:][d][e][[:space:]](?=[(aeiouAEIOUhH)])/u'; 
4272       
4273        // em => m'; et => t'
4274        $patterns[7] = '/[[:space:]][e][m][[:space:]](?=[(aeiouAEIOUhH)])/u';
4275        $patterns[8] = '/[[:space:]][e][t][[:space:]](?=[(aeiouAEIOUhH)])/u';
4276       
4277        //verb acabat en vocal + pronoms de receiver/theme a darrere
4278        $patterns[9] = '/(?<=[aeio]@VERBUM)[[:space:]]me[[:space:]]/u';
4279        $patterns[10] = '/(?<=[aeio]@VERBUM)[[:space:]]te[[:space:]]/u';
4280        $patterns[11] = '/(?<=[aeiou]@VERBUM)[[:space:]]li[[:space:]]/u';
4281        $patterns[12] = '/(?<=[aeio]@VERBUM)[[:space:]]nos[[:space:]]/u';
4282        $patterns[13] = '/(?<=[aeiou]@VERBUM)[[:space:]]vos[[:space:]]/u';
4283        $patterns[14] = '/(?<=[aeio]@VERBUM)[[:space:]]los[[:space:]]/u';
4284        $patterns[38] = '/(?<=[aeio]@VERBUM)[[:space:]]lo[[:space:]]/u';
4285        $patterns[39] = '/(?<=[aeiou]@VERBUM)[[:space:]]@PRFEBLEla[[:space:]]/u';
4286        $patterns[42] = '/(?<=[aeiou]@VERBUM)[[:space:]]@PRFEBLEles[[:space:]]/u';
4287        $patterns[48] = '/(?<=[aeiou]@VERBUM)[[:space:]]ho[[:space:]]/u';
4288       
4289        // verb acabat en vocal+r + pronoms de receiver a darrere
4290        $patterns[15] = '/(?<=@VERBUM)[[:space:]]me[[:space:]]/u';
4291        $patterns[16] = '/(?<=@VERBUM)[[:space:]]te[[:space:]]/u';
4292        $patterns[17] = '/(?<=@VERBUM)[[:space:]]li[[:space:]]/u';
4293        $patterns[18] = '/(?<=@VERBUM)[[:space:]]nos[[:space:]]/u';
4294        $patterns[19] = '/(?<=@VERBUM)[[:space:]]vos[[:space:]]/u';
4295        $patterns[20] = '/(?<=@VERBUM)[[:space:]]los[[:space:]]/u';
4296        $patterns[40] = '/(?<=@VERBUM)[[:space:]]lo[[:space:]]/u';
4297        $patterns[41] = '/(?<=@VERBUM)[[:space:]]@PRFEBLEla[[:space:]]/u';
4298        $patterns[43] = '/(?<=@VERBUM)[[:space:]]@PRFEBLEles[[:space:]]/u';
4299        $patterns[49] = '/(?<=@VERBUM)[[:space:]]ho[[:space:]]/u';
4300       
4301        // verb+pronom feble de receiver ja enganxat, seguit de "ho"
4302        $patterns[21] = "/(?<=@VERBUM)'m[[:space:]]ho[[:space:]]/u";
4303        $patterns[22] = "/(?<=@VERBUM)'t[[:space:]]ho[[:space:]]/u";
4304        $patterns[23] = "/(?<=@VERBUM)-li[[:space:]]ho[[:space:]]/u";
4305        $patterns[24] = "/(?<=@VERBUM)'ns[[:space:]]ho[[:space:]]/u";
4306        $patterns[25] = "/(?<=@VERBUM)-vos[[:space:]]ho[[:space:]]/u";
4307        $patterns[26] = "/(?<=@VERBUM)'ls[[:space:]]ho[[:space:]]/u";
4308       
4309        $patterns[27] = "/(?<=@VERBUM)-me[[:space:]]ho[[:space:]]/u";
4310        $patterns[28] = "/(?<=@VERBUM)-te[[:space:]]ho[[:space:]]/u";
4311        $patterns[29] = "/(?<=@VERBUM)-nos[[:space:]]ho[[:space:]]/u";
4312        $patterns[30] = "/(?<=@VERBUM)-vos[[:space:]]ho[[:space:]]/u";
4313        $patterns[31] = "/(?<=@VERBUM)-los[[:space:]]ho[[:space:]]/u";
4314       
4315        // netejar espais abans i després dels apòstrofs, si n'hi ha
4316        $patterns[32] = "/[[:space:]]'/u";
4317        $patterns[33] = "/'[[:space:]]/u";
4318       
4319        // netejar @VERBUM
4320        $patterns[50] = "/@VERBUM/u";
4321       
4322        // canviar els pronoms febles el i la, per l', si cal
4323        $patterns[35] = "/(?<=@PRFEBLE)el[[:space:]](?=[(aeiouAEIOUhH)])/u";
4324        $patterns[36] = "/(?<=@PRFEBLE)la[[:space:]](?=[(aeiouAEIOUhH)])/u";
4325       
4326        // netejar @PRFEBLE
4327        $patterns[51] = "/@PRFEBLE/u";
4328       
4329        //preps + pronoms personals
4330        $patterns[44] = '/[[:space:]][p][e][r][[:space:]][j][o][[:space:]]/u';
4331        $patterns[45] = '/[[:space:]][a][m][b][[:space:]][j][o][[:space:]]/u';
4332        $patterns[46] = '/[[:space:]][a][[:space:]][j][o][[:space:]]/u';
4333        $patterns[47] = '/[[:space:]][d][e][[:space:]][j][o][[:space:]]/u';
4334        $patterns[34] = '/[[:space:]][e][n][[:space:]][j][o][[:space:]]/u';
4335       
4336       
4337        $replacements[0] = ' del ';
4338        $replacements[1] = ' dels ';
4339        $replacements[2] = ' al ';
4340        $replacements[3] = ' als ';
4341        $replacements[4] = ' pel ';
4342        $replacements[5] = ' pels ';
4343       
4344        $replacements[6] = " d'";
4345       
4346        $replacements[7] = " m'";
4347        $replacements[8] = " t'";
4348       
4349        $replacements[9] = "'m ";
4350        $replacements[10] = "'t ";
4351        $replacements[11] = "-li ";
4352        $replacements[12] = "'ns ";
4353        $replacements[13] = "-vos ";
4354        $replacements[14] = "'ls ";
4355        $replacements[38] = "'l ";
4356        $replacements[39] = "-la ";
4357        $replacements[42] = "-les ";
4358        $replacements[48] = "-ho ";
4359       
4360        $replacements[15] = "-me ";
4361        $replacements[16] = "-te ";
4362        $replacements[17] = "-li ";
4363        $replacements[18] = "-nos ";
4364        $replacements[19] = "-vos ";
4365        $replacements[20] = "-los ";
4366        $replacements[40] = "-lo ";
4367        $replacements[41] = "-la ";
4368        $replacements[43] = "-les ";
4369        $replacements[49] = "-ho ";
4370       
4371        $replacements[21] = "-m'ho ";
4372        $replacements[22] = "-t'ho ";
4373        $replacements[23] = "-li-ho ";
4374        $replacements[24] = "'ns-ho ";
4375        $replacements[25] = "-vos-ho ";
4376        $replacements[26] = "'ls-ho ";
4377       
4378        $replacements[27] = "-m'ho ";
4379        $replacements[28] = "-t'ho ";
4380        $replacements[29] = "-nos-ho ";
4381        $replacements[30] = "-vos-ho ";
4382        $replacements[31] = "-los-ho ";
4383       
4384        $replacements[32] = "'";
4385        $replacements[33] = "'";
4386       
4387        $replacements[50] = "";
4388       
4389        $replacements[35] = "l'";
4390        $replacements[36] = "l'";
4391        $replacements[51] = "";
4392       
4393        $replacements[44] = ' per mi ';
4394        $replacements[45] = ' amb mi ';
4395        $replacements[46] = ' a mi ';
4396        $replacements[47] = ' de mi ';
4397        $replacements[34] = ' en mi ';
4398       
4399        $frasebruta = preg_replace($patterns, $replacements, $frasebruta);
4400       
4401        // fem una assignació prèvia
4402        $this->frasefinal = $frasebruta;
4403       
4404        // afegim les expressions de temps que van a darrere, si n'hi havia
4405        for ($i=0; $i<count($this->timeexpr); $i++) {
4406            $wordaux = $this->timeexpr[$i];
4407           
4408            if (!$matching->isFrontAdvTemps($wordaux->text)) {
4409
4410                // el posem darrere de la frase
4411</