source: lliurex-jocomunico/trunk/fuentes/lliurex-jocomunico.install/var/lib/application/libraries/Myslot.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: 157.8 KB
Line 
1<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); 
2
3class Myslot {
4   
5   
6    // PROPIETATS
7    var $category; // Tipus d'slot -> Theme, Subj... No té els 1|2 del final que tenen les keys de l'slotarray del pattern si hi ha subverbs
8    var $grade; // Si és obligatori, opt o no pot ser-hi
9    var $type = null; // Si vol qualsevol nom, joguines, adverbis, verbs... (si és obligatori o optatiu)
10    var $defvalue = null; // Valor per defecte si és de grade obligatori
11    var $prep = null; // Preposició que precedeix a l'slot
12    var $art = null;
13    var $defvalueused = false; // indica si l'slot s'ha omplert amb el def value
14    var $verbless = false; // per quan no han introduït verb i s'afegeix després amb les columnes
15                           // defaultverb o els verbless patterns
16   
17    var $full = false; // Si l'slot ja està ple/bloquejat
18    var $paraulafinal = null; // Paraula que acaba omplint l'slot (classe Myword)
19    var $puntsfinal; // punts segons com de bo és el fit de la paraula a l'slot
20    var $indexclassfinalword = 0; // L'index de la classe per saber quina classe s'ha agafat si una paraula en tenia vàries
21    var $puntsguanyats = -1000;
22   
23    var $paraulestemp = array(); // Array de les paraules/myword [0], els seus punts [1] que poden omplir l'slot i l'index de la classe [2]
24   
25    var $level = 1; // Nivell on es troba l'slot, si és d'un slot de subverb serà 2
26    var $parent; // Si l'slot és de nivell 2, aquí hi ha el nom de l'slot original que substitueixen
27                 // en general el que era subverb
28   
29    var $complements = array(); // ARRAY de slots pels complements de nom (NC) que siguin noms.
30    var $NCassigned = false;
31    var $NCassignedkey = null;
32   
33    var $cmpAdjs = array(); // ARRAY de slots pels complements de nom (NC) que siguin adjectius.
34    var $CAdjassigned = false;
35    var $CAdjassignedkey = null;
36   
37    var $cmpAdvs = array(); // ARRAY de slots pels complements de nom (NC) que siguin adverbis (com ara pels de lloc, "davant" la taula).
38    var $CAdvassigned = false;
39    var $CAdvassignedkey = null;
40   
41    var $cmpMod = array(); // ARRAY de slots pels complements de nom (NC) que siguin modificadors (quantificadors...).
42    var $CModassigned = false;
43    var $CModassignedkey = array();
44   
45    /*
46     * VARIABLES PEL GENERADOR
47     */
48   
49    var $slotstring = array(); // array amb la representació escrita de l'slot on a cada
50                               // posició hi té una tupla amb [0] la forma escrita de la paraula
51                               // i [1] una referència a la paraula (myWord) si no és una
52                               // prep, un article,  conj... [2] si el nucli és un nom [3] si masc [4] si plural
53                               // [5] si no necessita article -> quan hi ha un numero davant del nom o un quantificador
54                               // [6] si el nom és un complement de nom [7] si el nucli té un possessiu, que l'article
55                               // anirà davant del possessiu
56   
57    var $isInfinitive = false; // only for verbs. If after conjugating them, they are in infinitive form.
58   
59         
60    function __construct() {}
61   
62    public function isFull()
63    {
64        return $this->full;
65    }
66       
67    public function nounFitsSlot($word, $keyslot)
68    {
69        $CI = &get_instance();
70        $CI->load->library('Mymatching');
71       
72        $matching = new Mymatching();
73       
74        $langnouncorder = $CI->session->userdata('uinterfacelangncorder');
75       
76        $numclasses = count($word->classes);
77       
78        $matchscore = 1000;
79        $matchindexclass = -1;
80        $output = 0;
81        $isPronoun = false;
82                       
83        for ($i=0; $i<$numclasses; $i++) {
84           
85            if ($word->classes[$i] == "pronoun") $isPronoun = true;
86            // comprovem que la classe de nom existeixi i que el type de l'slot sigui de nom
87            if ($matching->isSetKeyNoun($word->classes[$i]) && $matching->isSetKeyNoun($this->type)) {
88                $tipusx = $matching->nounsFitKeys[$this->type]; // agafem l'index del tipus de nom de l'slot
89                $tipusy = $matching->nounsFitKeys[$word->classes[$i]];
90               
91                if ($matching->nounsFit[$tipusx][$tipusy] < $matchscore) {
92                    $matchscore = $matching->nounsFit[$tipusx][$tipusy];
93                    $matchindexclass = $i;
94                }
95               
96            }
97        }
98                       
99        // mirar si el nom pot fer de complement de nom d'algun dels noms que estiguin de provisionals a l'slot
100        // Si és un slot de tipus nom i la paraula no és un pronom (que no poden fer de NC)
101        if (!$isPronoun && $matching->isSetKeyNoun($this->type)) { // HO MIREM SEMPRE, JA QUE una paraula POT SER AL LLISTAT PROV DE L'SLOT I al llistat DE NC D'UN ALTRE NOM
102           
103            $i=0;
104            $found = false;
105            $numparaulestemp = count($this->paraulestemp); 
106           
107            // si l'slot està ja ple, mirem si pot fer de complement de nom i
108            // si l'idioma posa després o abans del nom els NC i el posem
109            // no es pot fer de complement de nom de pronoms
110            if ($this->full) {
111                if ((($langnouncorder == '1' && $this->paraulafinal->inputorder == $word->inputorder - 1) 
112                        || ($langnouncorder == '0' && $this->paraulafinal->inputorder == $word->inputorder + 1)) && !$this->paraulafinal->isClass("pronoun")) {
113                    $numcomplements = count($this->complements);
114                                       
115                    $newslot = new Myslot();
116                    $word->slotstemps[] = $keyslot." NC ".$numcomplements; // per dir que està de compl. de nom
117                    $newslot->category = $this->category." NC";
118                    $newslot->grade = "opt";
119                    $newslot->prep = "de";
120                    $newslot->full = true;
121                    $newslot->paraulafinal = $word;
122                    $newslot->level = $this->level + 1;
123                    $newslot->parent = $keyslot;
124                    $newslot->puntsfinal = 7; // Són els punts que resten un NC sobre 100
125                    $newslot->indexclassfinalword = 0;
126
127                    $this->complements[$keyslot." NC ".$numcomplements] = $newslot;
128                    $output = 1;
129                }
130            }
131            // si està buit, mirem si pot fer de complement per totes les paraules que poden omplir l'slot
132            else {
133                while (($i<$numparaulestemp) && !$found) {
134
135                    // mirem si pot fer de complement de nom i
136                    // si l'idioma posa després o abans del nom els NC i el posem
137                    // no es pot fer de complement de nom de pronoms
138                    if ((($langnouncorder == '1' && $this->paraulestemp[$i][0]->inputorder == $word->inputorder - 1) 
139                        || ($langnouncorder == '0' && $this->paraulestemp[$i][0]->inputorder == $word->inputorder + 1)) && !$this->paraulestemp[$i][0]->isClass("pronoun")) {
140                        // POT FER EL MATCH I ES POSA A LA LLISTA DE COMPLEMENTS PROVISIONAL EN UN NOU SLOT
141                       
142                        $numcomplements = count($this->complements);
143
144                        $newslot = new Myslot();
145                        $word->slotstemps[] = $keyslot." NC ".$numcomplements; // per dir que està de compl. de nom
146                        $newslot->category = $this->category." NC";
147                        $newslot->grade = "opt";
148                        $newslot->prep = "de";
149                        $newslot->full = true;
150                        $newslot->paraulafinal = $word;
151                        $newslot->level = $this->level + 1;
152                        $newslot->parent = $keyslot;
153                        $newslot->puntsfinal = 7; // Són els punts que resten un NC sobre 100
154                        $newslot->indexclassfinalword = 0;
155
156                        $this->complements[$keyslot." NC ".$numcomplements] = $newslot;
157                        $found = true;
158                        $output = 1;
159                    }
160                    $i++;
161                } // FI WHILE
162            }
163        }
164        // si podia entrar-hi i l'slot no està ple
165        if ($matchscore != 1000 && !$this->full) {
166            // POSEM LA PARAULA AL LLISTAT DE FILL TEMPORAL
167            $this->fillSlotTemp($word, $matchscore, $matchindexclass, $keyslot);
168            $output = 1;
169        }
170        return $output;
171    }
172   
173    public function adverbFitsSlot($word, $keyslot)
174    {
175        $CI = &get_instance();
176        $CI->load->library('Mymatching');
177               
178        $matching = new Mymatching();
179       
180        $numclasses = count($word->classes);
181       
182        $matchscore = 1000;
183        $matchindexclass = -1;
184        $output = 0;
185        $isadvlloc = false;
186       
187        for ($i=0; $i<$numclasses; $i++) {
188                                               
189            // comprovem que la classe d'adverbi existeixi i que el type de l'slot accepti adverbis
190            if ($matching->isSetKeyAdv($word->classes[$i]) && $matching->isSetKeyAdv($this->type)) {
191                               
192                $tipusx = $matching->advQuantFitKeys[$this->type]; // agafem l'index del tipus d'adverbi de l'slot
193                $tipusy = $matching->advQuantFitKeys[$word->classes[$i]];
194               
195                if ($matching->advQuantFit[$tipusx][$tipusy] < $matchscore) {
196                    $matchscore = $matching->advQuantFit[$tipusx][$tipusy];
197                    $matchindexclass = $i;
198                }
199               
200            }
201            if ($word->classes[$i] == "lloc") $isadvlloc = true;
202        }
203               
204        // Fins aquí hem vist si la paraula podia anar a un slot
205        // Si podia anar a un slot, l'slot està buit i l'slot no és de lloc fem un fill temporal normal
206        if (($matchscore != 1000) && (!$this->full) && ($this->type != "lloc")) {
207            $this->fillSlotTemp($word, $matchscore, $matchindexclass, $keyslot);
208            $output = 1;
209        }
210        // Pels tots els slots plens amb noms, mirem com de bé fa de CAdv l'adverbi de lloc
211        if ($this->full && $isadvlloc) {
212            // només poden anar els adverbis com a complement del nom que està omplint l'slot
213            // per tant l'slot ha d'estar ple
214                $numcomplements = count($this->cmpAdvs);
215               
216                $noun = $this->paraulafinal;
217                $matchscore = 1000;
218               
219                // busquem com de bé fa fit l'adverbi de lloc a la classe del nom
220                for ($j=0; $j<count($noun->classes); $j++) {
221                    $nounclassindex = $matching->nounsFitKeys[$noun->classes[$j]];
222                    $matchscore = $matching->advLocNC[0][$nounclassindex];
223                }
224               
225                // si no fa un mal fit, l'afegim al llistat de complements temporals
226                if ($matchscore < 5) {
227                    $newslot = new Myslot();
228                    $word->slotstemps[] = $keyslot." ADV ".$numcomplements; // per dir que està de compl. de nom
229                    $newslot->category = $this->category." ADV";
230                    $newslot->grade = "opt";
231                    $newslot->prep = "de";
232                    $newslot->full = true;
233                    $newslot->paraulafinal = $word;
234                    $newslot->level = $this->level + 1;
235                    $newslot->parent = $keyslot;
236                    $newslot->puntsfinal = $matchscore; // Són els punts del fit amb l'slot de lloc
237                                                // deixarien un slot opt buit
238                    $newslot->indexclassfinalword = 0;
239
240                    $this->cmpAdvs[$keyslot." ADV ".$numcomplements] = $newslot;
241                    $output = 1;
242                }
243        }
244                       
245        return $output;
246    }
247   
248    public function adjFitsSlot($word, $keyslot)
249    {
250        $CI = &get_instance();
251        $CI->load->library('Mymatching');
252       
253        // we get the usual order of adjectives that complement nouns for the given user interface language
254        $langnounadjorder = $CI->session->userdata('uinterfacelangnadjorder');
255       
256        $matching = new Mymatching();
257       
258        $numclasses = count($word->classes);
259       
260        $matchscore = 1000;
261        $matchindexclass = -1;
262        $output = 0;
263       
264        for ($i=0; $i<$numclasses; $i++) {
265                                                           
266            // comprovem que la classe d'adjectiu existeixi i que el type de l'slot accepti adjectius
267            if ($matching->isSetKeyAdj($word->classes[$i]) && $matching->isSetKeyAdjSmall($this->type)) {
268
269                $tipusx = $matching->adjFitKeys[$this->type]; // agafem l'index del tipus de l'slot
270                $tipusy = $matching->adjFitKeys[$word->classes[$i]];
271               
272                if ($matching->adjFit[$tipusx][$tipusy] < $matchscore) {
273                    $matchscore = $matching->adjFit[$tipusx][$tipusy];
274                    $matchindexclass = $i;
275                }
276               
277            }
278        }
279
280        // mirar si l'adjectiu pot fer de complement de nom del nom que estigui fent fill a l'slot
281        if ($this->full && $this->paraulafinal->tipus == "name") { // HO MIREM SEMPRE, JA QUE una paraula POT SER AL LLISTAT PROV DE L'SLOT I al llistat DE NC D'UN ALTRE NOM
282                     
283                // POT FER EL MATCH I ES POSA A LA LLISTA DE COMPLEMENTS ADJ PROVISIONAL EN UN NOU SLOT
284                   
285                $numcomplements = count($this->cmpAdjs);
286
287                $newslot = new Myslot();
288               
289                $newslot->category = $this->category." ADJ";
290                $newslot->grade = "opt";
291                $newslot->full = true;
292                $newslot->paraulafinal = $word;
293                $newslot->level = $this->level + 1;
294                $newslot->parent = $keyslot;
295                $word->slotstemps[] = $keyslot." ADJ ".$numcomplements;
296                $scoreadjcmp = 1000;
297                $indexclassadj = 0;
298               
299                $numclassesnom = count($this->paraulafinal->classes);
300                for ($i=0; $i<$numclasses; $i++) {
301                    $classeadjaux = $word->classes[$i];
302                                       
303                    for ($j=0; $j<$numclassesnom; $j++) {
304                       
305                        $classenomaux = $this->paraulafinal->classes[$j];
306                       
307                        if ($matching->isSetKeyAdjNoun($classeadjaux) && $matching->isSetKeyNoun($classenomaux)) {
308                                                       
309                            $tipusx = $matching->adjNounFitKeys[$classeadjaux];
310                            $tipusy = $matching->nounsFitKeys[$classenomaux];
311                                                       
312                            if ($matching->adjNounFit[$tipusx][$tipusy] < $scoreadjcmp) {
313                                $scoreadjcmp = $matching->adjNounFit[$tipusx][$tipusy];
314                                $indexclassadj = $i;
315                            }
316                        }
317                    }
318                }
319               
320                // nom - adjectiu
321                $distance = $this->paraulafinal->inputorder - $word->inputorder;
322                               
323                // com més lluny i com menys fit facin, pitjor
324                $newslot->puntsfinal = 7 - $scoreadjcmp - abs($distance);
325               
326                if ($langnounadjorder == '0' && $distance == -1) $newslot->puntsfinal += 1; // Si l'adjectiu va just darrere el nom és la millor opció
327                if ($langnounadjorder == '1' && $distance == 1) $newslot->puntsfinal += 1; // Si l'adjectiu va just abans del nom és la millor opció
328               
329                $aux = array();
330                $aux[0] = $keyslot." ADJ ".$numcomplements; // la clau de l'slot on pot fer de complement
331                $aux[1] = $newslot->puntsfinal; // els punts d'aquest slot: és per desambiguar si un adj pot complementar a dues paraules, per escollir la millor
332               
333                $word->slotstempsext[] = $aux; // key de l'slot on e'adj fa de complement [0] i punts [1]
334               
335                $newslot->indexclassfinalword = $indexclassadj;
336
337                $this->cmpAdjs[$keyslot." ADJ ".$numcomplements] = $newslot;
338                $output = 1;               
339        }
340       
341        // si havia fet fit d'un slot (no de complement)
342        if ($matchscore != 1000) {
343            // POSEM LA PARAULA AL LLISTAT DE FILL TEMPORAL
344            $this->fillSlotTemp($word, $matchscore, $matchindexclass, $keyslot);
345            $output = 1;
346        }
347        return $output;
348    }
349   
350   
351    public function modifFitsSlot($word, $keyslot)
352    {
353        $CI = &get_instance();
354        $CI->load->library('Mymatching');
355       
356        $matching = new Mymatching();
357       
358        $numclasses = count($word->classes);
359       
360        $matchscore = 1000;
361        $matchindexclass = -1;
362        $output = 0;
363               
364        // com que els quant poden omplir slots on tb hi pot haver ja un adv, només volem que l'ompli
365        // si no hi ha cap adv, es a dir, si està buit
366        if (!$this->full) {
367           
368            for ($i=0; $i<$numclasses; $i++) {
369
370                $classe = "modif";
371                if ($word->classes[$i] == "quant") $classe = "quant";
372                else if ($word->classes[$i] == "numero") $classe = "numero";
373               
374                // comprovem que la classe del modificador existeixi i que el type de l'slot accepti adjectius
375                if ($matching->isSetKeyModif($classe) && $matching->isSetKeyModif($this->type)) {
376
377                    $tipusx = $matching->modifFitKeys[$this->type]; // agafem l'index del tipus de l'slot
378                    $tipusy = $matching->modifFitKeys[$classe];
379
380                    if ($matching->modifFit[$tipusx][$tipusy] < $matchscore) {
381                        $matchscore = $matching->modifFit[$tipusx][$tipusy];
382                        $matchindexclass = $i;
383                    }
384
385                }
386            }
387        }
388       
389        // els quant i similar poden fer de complement d'advs, noms (si no són pronoms), adjs i modifs
390        // els altres modificadors (possessius o determinants) de paraula i els números només van amb noms
391        $potferdecmp = false;
392       
393        if ($this->full) {
394            $tipusparaulafinal = $this->paraulafinal->tipus;
395            if ($word->classes[0] == "quant" || $word->classes[0] == "similar") {
396                if (($tipusparaulafinal == "name" 
397                    || $tipusparaulafinal == "adv" || $tipusparaulafinal == "adj" 
398                        || $tipusparaulafinal == "modifier") && !$this->paraulafinal->isClass("pronoun"))
399                $potferdecmp = true;
400            }
401            else if ($tipusparaulafinal == "name") $potferdecmp = true;
402           
403        }
404       
405        if ($potferdecmp) {
406                       
407            $numcomplements = count($this->cmpMod);
408
409            $newslot = new Myslot();
410            $aux = array();
411            $aux[0] = $keyslot." MOD ".$numcomplements; // la clau de l'slot on pot fer complement
412           
413            // nom - modificador
414            $distance = $this->paraulafinal->inputorder - $word->inputorder;
415
416            // com més lluny pitjor
417            $newslot->puntsfinal = 7 - abs($distance);
418           
419            // fem que els quantificadors amb els adjectius tinguin més punts que els slots opcionals
420            // de manera que puguin tenir un quantificador com a fit (els opcionals valen 7 punts)
421            if ($tipusparaulafinal == "adj" && $word->isClass("quant")) {
422                if (abs($distance) == 1) {
423                    $newslot->puntsfinal += 1;
424                }
425            }
426            else if ($distance == 1) {
427                $newslot->puntsfinal += 1; // Si el modficador va just abans de la paraula és la millor opció
428                if ($word->isClass("quant") || $word->isClass("det") || 
429                        $word->isClass("similar")) $newslot->puntsfinal += 1; // i si és un quant, det o similar li sumem un punt extra
430            }
431           
432            $aux[1] = $newslot->puntsfinal; // els punts d'aquest slot: és per desambiguar si un modif pot complementar a dues paraules, per escollir la millor
433           
434            $word->slotstemps[] = $keyslot." MOD ".$numcomplements;
435            $word->slotstempsext[] =  $aux; // key de l'slot on el modif fa de complement [0] i punts [1]
436            $newslot->category = $this->category." MOD";
437            $newslot->grade = "opt";
438            $newslot->full = true;
439            $newslot->paraulafinal = $word;
440            $newslot->level = $this->level + 1;
441            $newslot->parent = $keyslot;
442           
443            $newslot->indexclassfinalword = 0;
444
445            $this->cmpMod[$keyslot." MOD ".$numcomplements] = $newslot;
446           
447            $output = 1; 
448        }
449
450        // si havia fet fit d'un slot (no de complement)
451        if ($matchscore != 1000) {
452            // POSEM LA PARAULA AL LLISTAT DE FILL TEMPORAL
453            $this->fillSlotTemp($word, $matchscore, $matchindexclass, $keyslot);
454            $output = 1;
455        }
456        return $output;
457    }
458   
459   
460    public function fillSlotTemp($word, $penalty, $classindexword, $keyslot) 
461    {       
462        $word->slotstemps[] = $keyslot;
463       
464        $punts = $this->slotPuntuation($word, $penalty);
465                       
466        $aux = array();
467        $aux[0] = $word;
468        $aux[1] = $punts;
469        $aux[2] = $classindexword;
470               
471        if (($this->puntsfinal - $punts) > $this->puntsguanyats) {
472            $this->puntsguanyats = $this->puntsfinal - $punts;
473        }
474       
475        $this->paraulestemp[] = $aux;       
476    }
477   
478    public function slotPuntuation ($word, $penalty)
479    {
480       
481        $CI = &get_instance();
482       
483        // agafem el tipus d'idioma, ja que per desambiguar si l'idioma és svo
484        // les paraules que vagin abans del verb tindran punts extra per fer de subjecte
485        // i les que vagin darrere per fer dels altres slots
486        $langtype = $CI->session->userdata('uinterfacelangtype');
487       
488        $svo = true;
489        if ($langtype != 'svo') $svo = false;
490       
491        $punts = 0;
492        if ($this->category == "Subject") {
493            $punts = $penalty;
494           
495            if ($svo) {
496                // si la paraula va abans del verb, el patró no era verbless, ni amb una pregunta
497                // (que el subjecte pot anar davant o darrere) i el fit no és horrible, li donem un bonus per
498                // igualar als altres camps obligatoris en l'ordre de prioritat
499                // pel subjecte principal
500                if ($this->level == 1 && $word->beforeverb && $penalty < 5 && !$this->verbless) $punts = $punts - 18 + $penalty*4;
501                else if ($this->level == 1 && !$word->beforeverb && !$this->verbless && !$CI->session->userdata('preguntapattern')) $punts += 1;
502                // pel secundari si n'hi ha
503                if ($this->level == 2 && $word->beforeverb2 && $penalty < 5 && !$this->verbless) $punts = $punts - 18 + $penalty*4;
504                else if ($this->level == 2 && !$word->beforeverb2 && !$this->verbless && !$CI->session->userdata('preguntapattern')) $punts += 1;
505            }
506            else {
507                // igualem el grade del subjecte a slot obligatori si no era un fit terrible i no era verbless
508                if ($this->level == 1 && $penalty < 5 && !$this->verbless) $punts = $punts - 18 + $penalty*4;
509                // pel secundari si n'hi ha
510                if ($this->level == 2 && $penalty < 5 && !$this->verbless) $punts = $punts - 18 + $penalty*4;
511            }
512        }
513        else if ($this->category == "Main Verb") $punts = 0;
514        else if ($this->grade == '1') {
515            $punts = $penalty*5;
516            // si l'idioma és svo, el que va abans del verb perd punts si estava introduït abans del verb
517            if ($svo) {
518                if ($this->level == 1 && $word->beforeverb) $punts += 1;
519                else if ($this->level == 2 && ($word->beforeverb || $word->beforeverb2)) $punts += 1;
520            }
521            // els adjs que acompanyen a noms quan estan enganxats a ells (darrere en idiomes nadj i davant en idiomes
522            // adjn) tenen un punt extra per fer de complement, per compensar-ho els perfect fits d'adj a slots de
523            // tipus adj han de tenir un punt extra
524            if ($penalty == 0 && $this->type == "adj") $punts -= 1;
525        }
526        else if ($this->grade == 'opt') $punts = $penalty;
527        else $punts = 7; // serà un de NC, tot i que aquests ja es tracten abans i en prinicipi no
528                         // arriben aquí
529        // DEBUG: echo $this->category." ".$this->level." --> ".$word->text." = ".$punts.'/'.$penalty.'<br /><br />';
530               
531        return $punts;
532    }
533   
534    public function slotPuntsInicials()
535    {
536        if ($this->category == "Subject") $this->puntsfinal = 7;
537        else if ($this->category == "Main Verb") $this->puntsfinal = 0;
538        else if ($this->grade == '1') $this->puntsfinal = 25;
539        else if ($this->grade == 'opt') $this->puntsfinal = 7;
540        else $this->puntsfinal = 1;
541    }
542
543    // retorna l'index d'on es troba la paraula dins de les paraulestemp que poden fill l'slot
544    public function searchIndexWordInSlot($word)
545    {
546        $index = -1;
547       
548        $found = false;
549       
550        $i=0;
551       
552        while ($i<count($this->paraulestemp) && !$found) {
553           
554            // l'inputorder és necessari per si hi ha dues paraules iguals que poden fer fill a l'slot
555            // per exemple, dos subjecte "jo" quan hi ha més d'un verb a la frase
556            if (($word->id == $this->paraulestemp[$i][0]->id) && ($word->tipus == $this->paraulestemp[$i][0]->tipus)
557                    && ($word->inputorder == $this->paraulestemp[$i][0]->inputorder)) {
558                $index = $i;
559                $found = true;
560            }
561            $i++;
562        }
563       
564        return $index;
565    }
566   
567    public function slotCalcPuntsGuanyats()
568    {
569        $puntsaux = -1000;
570       
571        $puntsinicialsaux;
572       
573        if ($this->category == "Subject") $puntsinicialsaux = 7;
574        else if ($this->category == "Main Verb") $puntsinicialsaux = 0;
575        else if ($this->grade == '1') $puntsinicialsaux = 25;
576        else if ($this->grade == 'opt') $puntsinicialsaux = 7;
577        else $puntsinicialsaux = 1;
578       
579        for($i=0; $i<count($this->paraulestemp); $i++) {
580           
581            if (!$this->paraulestemp[$i][0]->used) {
582                $penalty = $this->paraulestemp[$i][1];
583
584                if (($puntsinicialsaux - $penalty) > $puntsaux) {
585                    $puntsaux = $puntsinicialsaux - $penalty;
586                }
587            }
588        }
589       
590        // $this->puntsguanyats = $puntsaux;
591       
592        return $puntsaux;
593    }
594   
595   
596    /*
597     * FUNCIONS PEL GENERADOR
598     */
599   
600    // ordena els slots internament i fa concordar els elements
601    public function ordenarSlot($subjmasc, $subjpl, $copulatiu, $impersonal)
602    {
603        $nucli = $this->paraulafinal;
604        $elementaux = array();
605       
606        if ($nucli != null) {
607           
608            switch ($nucli->tipus) {
609                case "name":
610                   
611                    $numeros = array();
612                    $quantifieradj = array(); // stores the quantifiers that complement the adj instead of the nucleus
613                    $hasquantifieradj = false;
614                    $hasnumorquant = false;
615                    $haspossessive = 0; // al nostre sistema només els nuclis poden tenir possessius
616                                            // també l'activarem si té ordinals o altres elements que van
617                                            // entre l'article i el nom
618                   
619                    // calculem els valors per la concordància general
620                    $masc = true;
621                    $plural = false;
622                   
623                    // si el verb és copulatiu (amb un patró no impersonal) el nom del theme concorda amb el subjecte
624                    if ($this->category == "Theme" && $copulatiu && !$impersonal) {
625                       
626                        // si el nom és femení
627                        if ($nucli->propietats->mf == "fem") $masc = false;
628                        // si el nom és plural
629                        if ($nucli->propietats->singpl == "pl") $plural = true;
630                        // si té modificadors de femení i l'accepta
631                        if ($nucli->propietats->femeni != "" && $nucli->fem) $masc = false;
632                        // si té modificador de plural
633                        if ($nucli->plural) $plural = true;
634                       
635                       
636                        // sobreescrivim els valors si cal
637                        if (!$subjmasc && $subjpl) {
638                            if ($nucli->propietats->femeni != "") {
639                                $masc = false;
640                            }
641                            $plural = true;
642                        }
643                        else if (!$subjmasc && !$subjpl && $nucli->propietats->femeni != "") {
644                            $masc = false;
645                        }
646                        else if ($subjmasc && $subjpl) $plural = true;
647                    }
648                    else {
649                        // si el nom és femení
650                        if ($nucli->propietats->mf == "fem") $masc = false;
651                        // si el nom és plural
652                        if ($nucli->propietats->singpl == "pl") $plural = true;
653                        // si té modificadors de femení i l'accepta
654                        if ($nucli->propietats->femeni != "" && $nucli->fem) $masc = false;
655                        // si té modificador de plural
656                        if ($nucli->plural) $plural = true;
657                    }
658                   
659                    // PREPOSICIÓ
660                    // posem la preposició, si n'hi ha
661                    if ($this->prep != null) {
662                            $elementaux[0] = $this->prep;
663                            $elementaux[1] = null;
664                            $this->slotstring[] = $elementaux;                       
665                    }
666                   
667                    // Posem, si cal, la preposició "a", davant dels slots de temps
668                    if ($this->category == "Time") {
669                        $CI = &get_instance();
670                        $CI->load->library('Mymatching');
671                       
672                        $matching = new Mymatching();
673                       
674                        if ($matching->isTimePrep($nucli->text)) {
675                            $elementaux[0] = $matching->tempsPrep[$nucli->text];
676                            $elementaux[1] = null;
677                            $this->slotstring[] = $elementaux;
678                        }
679                    }
680                   
681                    // QUANTIFICADOR O POSSESSIUS
682                    // si el nom té un modificador, que només pot ser un quantificador o possessiu
683                    if ($this->CModassigned) {
684                       
685                        for ($i=0; $i<count($this->CModassignedkey); $i++) {
686                           
687                            $quantifierslot = $this->cmpMod[$this->CModassignedkey[$i]];
688                            // si és un número
689                            if ($quantifierslot->paraulafinal->isClass("numero")) {
690                                $numeros[] = $quantifierslot;
691                                // si és un número diferent d'1, tot passarà a ser plural
692                                if ($quantifierslot->paraulafinal->text != "un") $plural = true;
693                            }
694                            // si és un quantificador o possessiu
695                            else {
696                                // si el nucli també té un adjectiu assignat, mirem si va millor amb l'adjectiu
697                                if ($this->CAdjassigned) {
698                                    // si és quantifier i anava just davant de l'adjectiu, el guardem per després
699                                    if ($quantifierslot->paraulafinal->inputorder - 
700                                            $this->cmpAdjs[$this->CAdjassignedkey]->paraulafinal->inputorder == -1
701                                            && $quantifierslot->paraulafinal->classes[0] == "quant") {
702                                        $quantifieradj[] = $quantifierslot;
703                                        $hasquantifieradj = true;
704                                    }
705                                    // si no, el tractem com un quantificador o possessiu normal
706                                    else {
707                                        if ($masc && !$plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->masc;
708                                        else if ($masc && $plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->mascpl;
709                                        else if (!$masc && !$plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->fem;
710                                        else $elementaux[0] = $quantifierslot->paraulafinal->propietats->fempl;
711                                        $elementaux[1] = $quantifierslot->paraulafinal;
712
713                                        $this->slotstring[] = $elementaux;
714                                        $hasnumorquant = true;
715                                        if (strpos($quantifierslot->paraulafinal->classes[0], "pos") === 0) {
716                                            $haspossessive++; 
717                                            $hasnumorquant = false;
718                                        }
719                                        // el nom precedit per semblant a portarà article
720                                        if (strpos($quantifierslot->paraulafinal->text, "semblant")) $hasnumorquant = false;
721                                    }
722                                }
723                                else {
724                                    if ($masc && !$plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->masc;
725                                    else if ($masc && $plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->mascpl;
726                                    else if (!$masc && !$plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->fem;
727                                    else $elementaux[0] = $quantifierslot->paraulafinal->propietats->fempl;
728                                    $elementaux[1] = $quantifierslot->paraulafinal;
729
730                                    $this->slotstring[] = $elementaux;
731                                    $hasnumorquant = true;
732                                    if (strpos($quantifierslot->paraulafinal->classes[0], "pos") === 0) {
733                                        $haspossessive++; 
734                                        $hasnumorquant = false;
735                                    }
736                                    // el nom precedit per semblant a portarà article
737                                    if (strpos($quantifierslot->paraulafinal->text, "semblant")) $hasnumorquant = false;
738                                }
739                            }
740                        }                       
741                    }
742                   
743                    // ADVERBI DE LLOC
744                    if ($this->CAdvassigned) {
745                       
746                        $adverbistring = $this->cmpAdvs[$this->CAdvassignedkey]->paraulafinal;
747                        // dividir-lo en cada una de les paraules que formen l'adverbi
748                        $auxstring = explode(" ", $adverbistring->text);
749                        // afegir cada paraula en ordre a slotstring
750                        for ($i=0; $i<count($auxstring); $i++) {
751                            $elementaux[0] = $auxstring[$i];
752                            $elementaux[1] = $adverbistring;
753                           
754                            $this->slotstring[] = $elementaux;
755                        }
756                    }
757                   
758                    // NUMEROS
759                    for ($i=0; $i<count($numeros); $i++) {
760                        if ($masc) $elementaux[0] = $numeros[$i]->paraulafinal->propietats->masc;
761                        else $elementaux[0] = $numeros[$i]->paraulafinal->propietats->fem;
762                        $elementaux[1] = $numeros[$i]->paraulafinal;
763                       
764                        $this->slotstring[] = $elementaux;
765                        $hasnumorquant = true;
766                    }
767                   
768                    // ORDINALS
769                    if ($this->CAdjassigned) {
770                        $adjectiu = $this->cmpAdjs[$this->CAdjassignedkey]->paraulafinal;
771                        if ($adjectiu->isClass("ordinal")) {
772                            if ($masc && !$plural) $elementaux[0] = $adjectiu->propietats->masc;
773                            else if ($masc && $plural) $elementaux[0] = $adjectiu->propietats->mascpl;
774                            else if (!$masc && !$plural) $elementaux[0] = $adjectiu->propietats->fem;
775                            else $elementaux[0] = $adjectiu->propietats->fempl;
776                            $elementaux[1] = $adjectiu;
777
778                            $this->slotstring[] = $elementaux;
779                            $haspossessive++;
780                            $this->CAdjassigned = false; // indiquem que ja s'ha vist l'adjectiu
781                        }
782                    }
783                   
784                    // NOM + COORDINACIÓ
785                    if ($plural) {
786                        if ($nucli->propietats->mf != "fem" && !$masc) $elementaux[0] = $nucli->propietats->fempl;
787                        else $elementaux[0] = $nucli->propietats->plural;
788                    }
789                    else if ($masc && !$plural) $elementaux[0] = $nucli->propietats->nomtext;
790                    else {
791                        if ($nucli->propietats->mf == "fem") $elementaux[0] = $nucli->propietats->nomtext;
792                        else $elementaux[0] = $nucli->propietats->femeni;
793                    }
794                    $elementaux[1] = $nucli;
795                    // com que el nucli és un nom, afegim la informació extra
796                    $elementaux[2] = true;
797                    $elementaux[3] = $masc;
798                    $elementaux[4] = $plural;
799                    $elementaux[5] = $hasnumorquant;
800                    $elementaux[6] = false;
801                    $elementaux[7] = $haspossessive;
802                   
803                    $this->slotstring[] = $elementaux;
804                   
805                    // variables auxiliars que ens ajudaran a concordar l'adjectiu amb
806                    // l'últim nom coordinat, si el nucli no té cap element coordinat,
807                    // tenen els valors per concordar amb el nucli
808                    $masccoord = $masc;
809                    $pluralcoord = $plural;
810                   
811                    // si té element coordinat
812                    if (count($nucli->paraulacoord) > 0) {
813                       
814                        for ($k=0; $k<count($nucli->paraulacoord); $k++) {
815                           
816                            $paraulacoord = $nucli->paraulacoord[$k];
817                           
818                            $paraulacoordisadj = false;
819                            if ($paraulacoord->tipus == "adj") $paraulacoordisadj = true;
820
821                            // afegim la "i"
822                            $elementaux[0] = "i";
823                            $elementaux[1] = null;
824                            $this->slotstring[] = $elementaux;
825                           
826                            if ($paraulacoordisadj) {
827                                $elementaux[0] = $paraulacoord->propietats->masc;
828                                $elementaux[1] = $paraulacoord;
829                                $this->slotstring[] = $elementaux;
830                            }
831                            else {
832                                // afegim la paraula coordinada, el plural es passa, però el femení
833                                // s'ha de mirar si la paraula ho era o no el tenia el modificador
834                                $masccoord = true;
835                                $pluralcoord = false;
836
837                                if ($paraulacoord->propietats->mf == "fem" || $paraulacoord->fem) $masccoord = false;
838                                // el plural només pot canviar si plural era false i la paraulacoord sempre és plural
839                                // que aleshores ha de passar a true o si volíem que la paraulacoord fos plural
840                                if ($paraulacoord->propietats->singpl == "pl" || $paraulacoord->plural) $pluralcoord = true;
841
842                                if ($pluralcoord) $elementaux[0] = $paraulacoord->propietats->plural;
843                                else if ($masccoord && !$pluralcoord) $elementaux[0] = $paraulacoord->propietats->nomtext;
844                                else {
845                                    if ($paraulacoord->propietats->mf == "fem") $elementaux[0] = $paraulacoord->propietats->nomtext;
846                                    else $elementaux[0] = $paraulacoord->propietats->femeni;
847                                }
848                                $elementaux[1] = $paraulacoord;
849                                // com que la paraula coordinada ha de ser un nom, afegim la info extra
850                                $elementaux[2] = true;
851                                $elementaux[3] = $masccoord;
852                                $elementaux[4] = $pluralcoord;
853                                $elementaux[5] = $hasnumorquant;
854                                $elementaux[6] = false;
855                                $elementaux[7] = $haspossessive;
856
857                                $this->slotstring[] = $elementaux;
858                            }
859                        }
860                    }
861                   
862                    // ADJECTIUS I COMPLEMENTS DE NOM
863                    // si té un adjectiu i no un complement de nom
864                    if ($this->CAdjassigned && !$this->NCassigned) {
865                       
866                        // si l'adjectiu tenia un quantificador l'afegim
867                        if ($hasquantifieradj) {
868                            for ($i=0; $i<count($quantifieradj); $i++) {
869                                // aquí els quantificadors tenen forma invariable
870                                $elementaux[0] = $quantifieradj[$i]->paraulafinal->propietats->masc;
871                                $elementaux[1] = $quantifieradj[$i]->paraulafinal;
872                               
873                                $this->slotstring[] = $elementaux;
874                            }
875                        }
876                        // tant si tenia quantificador com si no, posem l'adjectiu
877                        $adjectiu = $this->cmpAdjs[$this->CAdjassignedkey]->paraulafinal;
878                        if ($masccoord && !$pluralcoord) $elementaux[0] = $adjectiu->propietats->masc;
879                        else if ($masccoord && $pluralcoord) $elementaux[0] = $adjectiu->propietats->mascpl;
880                        else if (!$masccoord && !$pluralcoord) $elementaux[0] = $adjectiu->propietats->fem;
881                        else $elementaux[0] = $adjectiu->propietats->fempl;
882                        $elementaux[1] = $adjectiu;
883                       
884                        $this->slotstring[] = $elementaux;
885                       
886                        if (count($adjectiu->paraulacoord) > 0) {
887                       
888                            for ($k=0; $k<count($adjectiu->paraulacoord); $k++) {
889
890                                $paraulacoord = $adjectiu->paraulacoord[$k];
891                               
892                                // afegim la "i"
893                                $elementaux[0] = "i";
894                                $elementaux[1] = null;
895                                $this->slotstring[] = $elementaux;
896
897                                // afegim la paraula coordinada amb la mateixa concordància
898                                if ($masccoord && !$pluralcoord) $elementaux[0] = $paraulacoord->propietats->masc;
899                                else if ($masccoord && $pluralcoord) $elementaux[0] = $paraulacoord->propietats->mascpl;
900                                else if (!$masccoord && !$pluralcoord) $elementaux[0] = $paraulacoord->propietats->fem;
901                                else $elementaux[0] = $paraulacoord->propietats->fempl;
902                                $elementaux[1] = $paraulacoord;
903
904                                $this->slotstring[] = $elementaux;
905                           
906                            }     
907                        }
908                    }
909                    // si té complement de nom i no adjectiu
910                    else if ($this->NCassigned && !$this->CAdjassigned) {
911                       
912                        $nouncmpslot = $this->complements[$this->NCassignedkey];
913                        $nouncmp = $nouncmpslot->paraulafinal;
914                       
915                        // afegim la preposició "de"
916                        $elementaux[0] = $nouncmpslot->prep;
917                        $elementaux[1] = null;
918                        $this->slotstring[] = $elementaux;
919                       
920                        // afegim el nom
921                        $masccmp = true;
922                        $pluralcmp = false;
923                        // si el nom és femení
924                        if ($nouncmp->propietats->mf == "fem") $masccmp = false;
925                        // si el nom és plural
926                        if ($nouncmp->propietats->singpl == "pl") $pluralcmp = true;
927                        // si té modificadors de femení i l'accepta
928                        if ($nouncmp->propietats->femeni != "" && $nouncmp->fem) $masccmp = false;
929                        // si té modificador de plural
930                        if ($nouncmp->plural) $pluralcmp = true;
931                       
932                        if ($pluralcmp) $elementaux[0] = $nouncmp->propietats->plural;
933                        else if ($masccmp && !$pluralcmp) $elementaux[0] = $nouncmp->propietats->nomtext;
934                        else {
935                            if ($nouncmp->propietats->mf == "fem") $elementaux[0] = $nouncmp->propietats->nomtext;
936                            else $elementaux[0] = $nouncmp->propietats->femeni;
937                        }
938                        $elementaux[1] = $nouncmp;
939                        // com que el nucli és un nom, afegim la informació extra
940                        $elementaux[2] = true;
941                        $elementaux[3] = $masccmp;
942                        $elementaux[4] = $pluralcmp;
943                        $elementaux[5] = false;
944                        $elementaux[6] = true;
945                        $elementaux[7] = $haspossessive;
946                       
947                        $this->slotstring[] = $elementaux;
948                       
949                        $masccmpcoord = $masccmp;
950                        $pluralcmpcoord = $pluralcmp;
951                       
952                        // si té element coordinat
953                        if (count($nouncmp->paraulacoord) > 0) {
954                       
955                            for ($k=0; $k<count($nouncmp->paraulacoord); $k++) {
956
957                                $paraulacoord = $nouncmp->paraulacoord[$k];
958                               
959                                $paraulacoordisadj = false;
960                                if ($paraulacoord->tipus == "adj") $paraulacoordisadj = true;
961
962                                // afegim la "i"
963                                $elementaux[0] = "i";
964                                $elementaux[1] = null;
965                                $this->slotstring[] = $elementaux;
966
967                                if ($paraulacoordisadj) {
968                                    $elementaux[0] = $paraulacoord->propietats->masc;
969                                    $elementaux[1] = $paraulacoord;
970                                    $this->slotstring[] = $elementaux;
971                                }
972                                else {
973                                    // afegim la paraula coordinada amb la seva concordància
974                                    $masccmpcoord = true;
975                                    $pluralcmpcoord = false;
976                                    // si el nom és femení
977                                    if ($paraulacoord->propietats->mf == "fem") $masccmpcoord = false;
978                                    // si el nom és plural
979                                    if ($paraulacoord->propietats->singpl == "pl") $pluralcmpcoord = true;
980                                    // si té modificadors de femení i l'accepta
981                                    if ($paraulacoord->propietats->femeni != "" && $paraulacoord->fem) $masccmpcoord = false;
982                                    // si té modificador de plural
983                                    if ($paraulacoord->plural) $pluralcmpcoord = true;
984
985                                    if ($pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->plural;
986                                    else if ($masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->nomtext;
987                                    else {
988                                        if ($paraulacoord->propietats->mf == "fem") $elementaux[0] = $paraulacoord->propietats->nomtext;
989                                        else $elementaux[0] = $paraulacoord->propietats->femeni;
990                                    }
991                                    $elementaux[1] = $paraulacoord;
992                                    // com que el nucli és un nom, afegim la informació extra
993                                    $elementaux[2] = true;
994                                    $elementaux[3] = $masccmpcoord;
995                                    $elementaux[4] = $pluralcmpcoord;
996                                    $elementaux[5] = false;
997                                    $elementaux[6] = true;
998                                    $elementaux[7] = $haspossessive;
999
1000                                    $this->slotstring[] = $elementaux;
1001                                }
1002                            }
1003                        }
1004                    }
1005                    // si té complement de nom i adjectiu
1006                    else if ($this->NCassigned && $this->CAdjassigned) {
1007                        $nouncmpslot = $this->complements[$this->NCassignedkey];
1008                        $adjectiuslot = $this->cmpAdjs[$this->CAdjassignedkey];
1009                        $puntsFitAdjWithNucli = $adjectiuslot->puntsfinal;
1010                                               
1011                        // calculem els punts que tindria fent fit al complement
1012                       
1013                        $CI = &get_instance();
1014                        $CI->load->library('Mymatching');
1015                       
1016                        $matching = new Mymatching();
1017                       
1018                        $classeadj = $adjectiuslot->paraulafinal->classes[$adjectiuslot->indexclassfinalword];
1019                       
1020                        $numclassesnomcmp = count($nouncmpslot->paraulafinal->classes);
1021                       
1022                        $puntsFitAdjWithCMP = 1000;
1023
1024                        for ($j=0; $j<$numclassesnomcmp; $j++) {
1025
1026                            $classenomaux = $nouncmpslot->paraulafinal->classes[$j];
1027
1028                            if ($matching->isSetKeyAdjNoun($classeadj) && $matching->isSetKeyNoun($classenomaux)) {
1029                               
1030                                $tipusx = $matching->adjNounFitKeys[$classeadj];
1031                                $tipusy = $matching->nounsFitKeys[$classenomaux];
1032
1033                                if ($matching->adjNounFit[$tipusx][$tipusy] < $puntsFitAdjWithCMP) {
1034                                    $puntsFitAdjWithCMP = $matching->adjNounFit[$tipusx][$tipusy];
1035                                }
1036                            }
1037                        }
1038                        // nom - adjectiu
1039                        $distance = $nouncmpslot->paraulafinal->inputorder - $adjectiuslot->paraulafinal->inputorder;
1040                        // com més lluny i com menys fit facin, pitjor
1041                        $puntsFitAdjWithCMP = 7 - $puntsFitAdjWithCMP - abs($distance);
1042                        if ($distance == -1) $puntsFitAdjWithCMP += 1;
1043                                               
1044                        // si fa millor fit al NUCLI
1045                        if ($puntsFitAdjWithNucli >= $puntsFitAdjWithCMP) {
1046                           
1047                            // insertem primer l'adjectiu
1048                            // si l'adjectiu tenia un quantificador l'afegim
1049                            if ($hasquantifieradj) {
1050                                for ($i=0; $i<count($quantifieradj); $i++) {
1051                                    // aquí els quantificadors tenen forma invariable
1052                                    $elementaux[0] = $quantifieradj[$i]->paraulafinal->propietats->masc;
1053                                    $elementaux[1] = $quantifieradj[$i]->paraulafinal;
1054
1055                                    $this->slotstring[] = $elementaux;
1056                                }
1057                            }
1058                            // tant si tenia quantificador com si no, posem l'adjectiu
1059                            $adjectiu = $adjectiuslot->paraulafinal;
1060                            if ($masccoord && !$pluralcoord) $elementaux[0] = $adjectiu->propietats->masc;
1061                            else if ($masccoord && $pluralcoord) $elementaux[0] = $adjectiu->propietats->mascpl;
1062                            else if (!$masccoord && !$pluralcoord) $elementaux[0] = $adjectiu->propietats->fem;
1063                            else $elementaux[0] = $adjectiu->propietats->fempl;
1064                            $elementaux[1] = $adjectiu;
1065
1066                            $this->slotstring[] = $elementaux;
1067                           
1068                            // si té element adjectiu coordinat l'afegim
1069                            if (count($adjectiu->paraulacoord) > 0) {
1070
1071                                for ($k=0; $k<count($adjectiu->paraulacoord); $k++) {
1072
1073                                    $paraulacoord = $adjectiu->paraulacoord[$k];
1074                                   
1075                                    // afegim la "i"
1076                                    $elementaux[0] = "i";
1077                                    $elementaux[1] = null;
1078                                    $this->slotstring[] = $elementaux;
1079
1080                                    // afegim la paraula coordinada amb la mateixa concordància
1081                                    if ($masccoord && !$pluralcoord) $elementaux[0] = $paraulacoord->propietats->masc;
1082                                    else if ($masccoord && $pluralcoord) $elementaux[0] = $paraulacoord->propietats->mascpl;
1083                                    else if (!$masccoord && !$pluralcoord) $elementaux[0] = $paraulacoord->propietats->fem;
1084                                    else $elementaux[0] = $paraulacoord->propietats->fempl;
1085                                    $elementaux[1] = $paraulacoord;
1086
1087                                    $this->slotstring[] = $elementaux;
1088                                   
1089                                }   
1090                            }
1091
1092                            // després insertem el nom que fa de complement
1093                            $nouncmp = $nouncmpslot->paraulafinal;
1094
1095                            // afegim la preposició "de"
1096                            $elementaux[0] = $nouncmpslot->prep;
1097                            $elementaux[1] = null;
1098                            $this->slotstring[] = $elementaux;
1099
1100                            // afegim el nom
1101                            $masccmp = true;
1102                            $pluralcmp = false;
1103                            // si el nom és femení
1104                            if ($nouncmp->propietats->mf == "fem") $masccmp = false;
1105                            // si el nom és plural
1106                            if ($nouncmp->propietats->singpl == "pl") $pluralcmp = true;
1107                            // si té modificadors de femení i l'accepta
1108                            if ($nouncmp->propietats->femeni != "" && $nucli->fem) $masccmp = false;
1109                            // si té modificador de plural
1110                            if ($nouncmp->plural) $pluralcmp = true;
1111
1112                            if ($pluralcmp) $elementaux[0] = $nouncmp->propietats->plural;
1113                            else if ($masccmp && !$pluralcmp) $elementaux[0] = $nouncmp->propietats->nomtext;
1114                            else {
1115                                if ($nouncmp->propietats->mf == "fem") $elementaux[0] = $nouncmp->propietats->nomtext;
1116                                else $elementaux[0] = $nouncmp->propietats->femeni;
1117                            }
1118                            $elementaux[1] = $nouncmp;
1119                            // com que el nucli és un nom, afegim la informació extra
1120                            $elementaux[2] = true;
1121                            $elementaux[3] = $masccmp;
1122                            $elementaux[4] = $pluralcmp;
1123                            $elementaux[5] = false;
1124                            $elementaux[6] = true;
1125                            $elementaux[7] = $haspossessive;
1126                           
1127                            $this->slotstring[] = $elementaux;
1128                           
1129                            // si té element coordinat
1130                            if (count($nouncmp->paraulacoord) > 0) {
1131
1132                                for ($k=0; $k<count($nouncmp->paraulacoord); $k++) {
1133
1134                                    $paraulacoord = $nouncmp->paraulacoord[$k];
1135                                   
1136                                    $paraulacoordisadj = false;
1137                                    if ($paraulacoord->tipus == "adj") $paraulacoordisadj = true;
1138
1139                                    // afegim la "i"
1140                                    $elementaux[0] = "i";
1141                                    $elementaux[1] = null;
1142                                    $this->slotstring[] = $elementaux;
1143
1144                                    if ($paraulacoordisadj) {
1145                                        $elementaux[0] = $paraulacoord->propietats->masc;
1146                                        $elementaux[1] = $paraulacoord;
1147                                        $this->slotstring[] = $elementaux;
1148                                    }
1149                                    else {
1150                                        // afegim la paraula coordinada amb la seva concordància
1151                                        $masccmp = true;
1152                                        $pluralcmp = false;
1153                                        // si el nom és femení
1154                                        if ($paraulacoord->propietats->mf == "fem") $masccmp = false;
1155                                        // si el nom és plural
1156                                        if ($paraulacoord->propietats->singpl == "pl") $pluralcmp = true;
1157                                        // si té modificadors de femení i l'accepta
1158                                        if ($paraulacoord->propietats->femeni != "" && $paraulacoord->fem) $masccmp = false;
1159                                        // si té modificador de plural
1160                                        if ($paraulacoord->plural) $pluralcmp = true;
1161
1162                                        if ($pluralcmp) $elementaux[0] = $paraulacoord->propietats->plural;
1163                                        else if ($masccmp && !$pluralcmp) $elementaux[0] = $paraulacoord->propietats->nomtext;
1164                                        else {
1165                                            if ($paraulacoord->propietats->mf == "fem") $elementaux[0] = $paraulacoord->propietats->nomtext;
1166                                            else $elementaux[0] = $paraulacoord->propietats->femeni;
1167                                        }
1168                                        $elementaux[1] = $paraulacoord;
1169                                        // com que el nucli és un nom, afegim la informació extra
1170                                        $elementaux[2] = true;
1171                                        $elementaux[3] = $masccmp;
1172                                        $elementaux[4] = $pluralcmp;
1173                                        $elementaux[5] = false;
1174                                        $elementaux[6] = true;
1175                                        $elementaux[7] = $haspossessive;
1176
1177                                        $this->slotstring[] = $elementaux;
1178                                    }
1179                                }
1180                            }
1181                           
1182                        }
1183                        // si fa millor fit al COMPLEMENT
1184                        else {
1185                           
1186                            // primer insertem el nom que fa de complement
1187                            $nouncmp = $nouncmpslot->paraulafinal;
1188
1189                            // afegim la preposició "de"
1190                            $elementaux[0] = $nouncmpslot->prep;
1191                            $elementaux[1] = null;
1192                            $this->slotstring[] = $elementaux;
1193
1194                            // afegim el nom
1195                            $masccmp = true;
1196                            $pluralcmp = false;
1197                            // si el nom és femení
1198                            if ($nouncmp->propietats->mf == "fem") $masccmp = false;
1199                            // si el nom és plural
1200                            if ($nouncmp->propietats->singpl == "pl") $pluralcmp = true;
1201                            // si té modificadors de femení i l'accepta
1202                            if ($nouncmp->propietats->femeni != "" && $nucli->fem) $masccmp = false;
1203                            // si té modificador de plural
1204                            if ($nouncmp->plural) $pluralcmp = true;
1205
1206                            if ($pluralcmp) $elementaux[0] = $nouncmp->propietats->plural;
1207                            else if ($masccmp && !$pluralcmp) $elementaux[0] = $nouncmp->propietats->nomtext;
1208                            else {
1209                                if ($nouncmp->propietats->mf == "fem") $elementaux[0] = $nouncmp->propietats->nomtext;
1210                                else $elementaux[0] = $nouncmp->propietats->femeni;
1211                            }
1212                            $elementaux[1] = $nouncmp;
1213                            // com que el nucli és un nom, afegim la informació extra
1214                            $elementaux[2] = true;
1215                            $elementaux[3] = $masccmp;
1216                            $elementaux[4] = $pluralcmp;
1217                            $elementaux[5] = false;
1218                            $elementaux[6] = true;
1219                            $elementaux[7] = $haspossessive;
1220                           
1221                            $this->slotstring[] = $elementaux;
1222                           
1223                            $masccmpcoord = $masccmp;
1224                            $pluralcmpcoord = $pluralcmp;
1225                           
1226                            // si té element coordinat
1227                            if (count($nouncmp->paraulacoord) > 0) {
1228
1229                                for ($k=0; $k<count($nouncmp->paraulacoord); $k++) {
1230
1231                                    $paraulacoord = $nouncmp->paraulacoord[$k];
1232                                   
1233                                    $paraulacoordisadj = false;
1234                                    if ($paraulacoord->tipus == "adj") $paraulacoordisadj = true;
1235
1236                                    // afegim la "i"
1237                                    $elementaux[0] = "i";
1238                                    $elementaux[1] = null;
1239                                    $this->slotstring[] = $elementaux;
1240
1241                                    if ($paraulacoordisadj) {
1242                                        $elementaux[0] = $paraulacoord->propietats->masc;
1243                                        $elementaux[1] = $paraulacoord;
1244                                        $this->slotstring[] = $elementaux;
1245                                    }
1246                                    else {
1247                                        // afegim la paraula coordinada amb la seva concordància
1248                                        $masccmpcoord = true;
1249                                        $pluralcmpcoord = false;
1250                                        // si el nom és femení
1251                                        if ($paraulacoord->propietats->mf == "fem") $masccmpcoord = false;
1252                                        // si el nom és plural
1253                                        if ($paraulacoord->propietats->singpl == "pl") $pluralcmpcoord = true;
1254                                        // si té modificadors de femení i l'accepta
1255                                        if ($paraulacoord->propietats->femeni != "" && $paraulacoord->fem) $masccmpcoord = false;
1256                                        // si té modificador de plural
1257                                        if ($paraulacoord->plural) $pluralcmpcoord = true;
1258
1259                                        if ($pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->plural;
1260                                        else if ($masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->nomtext;
1261                                        else {
1262                                            if ($paraulacoord->propietats->mf == "fem") $elementaux[0] = $paraulacoord->propietats->nomtext;
1263                                            else $elementaux[0] = $paraulacoord->propietats->femeni;
1264                                        }
1265                                        $elementaux[1] = $paraulacoord;
1266                                        // com que el nucli és un nom, afegim la informació extra
1267                                        $elementaux[2] = true;
1268                                        $elementaux[3] = $masccmpcoord;
1269                                        $elementaux[4] = $pluralcmpcoord;
1270                                        $elementaux[5] = false;
1271                                        $elementaux[6] = true;
1272                                        $elementaux[7] = $haspossessive;
1273
1274                                        $this->slotstring[] = $elementaux;
1275                                    }                                   
1276                                }
1277                            }
1278                           
1279                            // després afegim l'adjectiu
1280                            // si l'adjectiu tenia un quantificador l'afegim
1281                            if ($hasquantifieradj) {
1282                                for ($i=0; $i<count($quantifieradj); $i++) {
1283                                    // aquí els quantificadors tenen forma invariable
1284                                    $elementaux[0] = $quantifieradj[$i]->paraulafinal->propietats->masc;
1285                                    $elementaux[1] = $quantifieradj[$i]->paraulafinal;
1286
1287                                    $this->slotstring[] = $elementaux;
1288                                }
1289                            }
1290                            // tant si tenia quantificador com si no, posem l'adjectiu que concorda amb el complement
1291                            $adjectiu = $adjectiuslot->paraulafinal;
1292                            if ($masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $adjectiu->propietats->masc;
1293                            else if ($masccmpcoord && $pluralcmpcoord) $elementaux[0] = $adjectiu->propietats->mascpl;
1294                            else if (!$masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $adjectiu->propietats->fem;
1295                            else $elementaux[0] = $adjectiu->propietats->fempl;
1296                            $elementaux[1] = $adjectiu;
1297
1298                            $this->slotstring[] = $elementaux;
1299                           
1300                            // si té element adjectiu coordinat l'afegim
1301                            if (count($adjectiu->paraulacoord) > 0) {
1302
1303                                for ($k=0; $k<count($adjectiu->paraulacoord); $k++) {
1304
1305                                    $paraulacoord = $adjectiu->paraulacoord[$k];
1306                                   
1307                                    // afegim la "i"
1308                                    $elementaux[0] = "i";
1309                                    $elementaux[1] = null;
1310                                    $this->slotstring[] = $elementaux;
1311
1312                                    // afegim la paraula coordinada amb la mateixa concordància
1313                                    if ($masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->masc;
1314                                    else if ($masccmpcoord && $pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->mascpl;
1315                                    else if (!$masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->fem;
1316                                    else $elementaux[0] = $paraulacoord->propietats->fempl;
1317                                    $elementaux[1] = $paraulacoord;
1318
1319                                    $this->slotstring[] = $elementaux;
1320                                }
1321                            }
1322                        }
1323                    } // Fi si té complement de nom i adjectiu
1324
1325                    break;
1326               
1327                case "adj":
1328                   
1329                    // PREPOSICIÓ
1330                    // posem la preposició, si n'hi ha
1331                    if ($this->prep != null) {
1332                            $elementaux[0] = $this->prep;
1333                            $elementaux[1] = null;
1334                            $this->slotstring[] = $elementaux;                       
1335                    }
1336                   
1337                    // QUANTIFICADOR
1338                    // si l'adjectiu té un modificador, que només pot ser un quantificador
1339                    if ($this->CModassigned) {
1340                       
1341                        for ($i=0; $i<count($this->CModassignedkey); $i++) {
1342                           
1343                            $quantifierslot = $this->cmpMod[$this->CModassignedkey[$i]];
1344                           
1345                            // el quantificador és invariable
1346                            $elementaux[0] = $quantifierslot->paraulafinal->propietats->masc;
1347                            $elementaux[1] = $quantifierslot->paraulafinal;
1348
1349                            $this->slotstring[] = $elementaux;
1350                        }                       
1351                    }
1352                   
1353                   
1354                    // POSEM L'ADJECTIU, HA DE CONCORDAR AMB EL SUBJECTE, ja que l'adjectiu
1355                    // només té slots per fer de nucli en verbs copulatius o verbless patterns
1356                    // tenint en compte els modificadors de subjecte
1357                    // si estan definits, tenen preferència els modificadors de l'adjectiu
1358                    // Si és d'un slot de MANNER no ha de concordar
1359                                       
1360                    // si és de manera posem l'adjectiu en masculí
1361                    if ($this->category == "Manner") {
1362                        $elementaux[0] = $nucli->text;
1363                        $elementaux[1] = $nucli;
1364                        $elementaux[2] = false;
1365                       
1366                        $this->slotstring[] = $elementaux;
1367                       
1368                        // si té element adjectiu coordinat
1369                        if (count($nucli->paraulacoord) > 0) {
1370
1371                            for ($k=0; $k<count($nucli->paraulacoord); $k++) {
1372
1373                                $paraulacoord = $nucli->paraulacoord[$k];
1374                               
1375                                // afegim la "i"
1376                                $elementaux[0] = "i";
1377                                $elementaux[1] = null;
1378                                $this->slotstring[] = $elementaux;
1379
1380                                // afegim la paraula coordinada amb la mateixa concordància
1381                                $elementaux[0] = $paraulacoord->text;
1382                                $elementaux[1] = $paraulacoord;
1383
1384                                $this->slotstring[] = $elementaux;
1385                            }
1386                        }
1387                    }
1388                    // si no era de manera (en principi és de verb copulatiu o verbless
1389                    else {
1390                        // posem l'adjectiu que concordi
1391                        if (!$subjmasc && $subjpl) $elementaux[0] = $nucli->propietats->fempl;
1392                        else if (!$subjmasc && !$subjpl) $elementaux[0] = $nucli->propietats->fem;
1393                        else if ($subjmasc && $subjpl) $elementaux[0] = $nucli->propietats->mascpl;
1394                        else $elementaux[0] = $nucli->propietats->masc;
1395                       
1396                        // sobreescrivim si l'adjectiu tenia modificadors activats
1397                        // ho fem perquè si és verbless no té subjecte
1398                        if ($nucli->fem && $nucli->plural) $elementaux[0] = $nucli->propietats->fempl;
1399                        else if ($nucli->fem) $elementaux[0] = $nucli->propietats->fem;
1400                        else if ($nucli->plural) $elementaux[0] = $nucli->propietats->mascpl;
1401                       
1402                        $elementaux[1] = $nucli;
1403                        $elementaux[2] = false;
1404                       
1405                        $this->slotstring[] = $elementaux;
1406                       
1407                        // si té element adjectiu coordinat
1408                        if (count($nucli->paraulacoord) > 0) {
1409
1410                            for ($k=0; $k<count($nucli->paraulacoord); $k++) {
1411
1412                                $paraulacoord = $nucli->paraulacoord[$k];
1413                               
1414                                // afegim la "i"
1415                                $elementaux[0] = "i";
1416                                $elementaux[1] = null;
1417                                $this->slotstring[] = $elementaux;
1418
1419                                // afegim la paraula coordinada amb la mateixa concordància
1420                                if (!$subjmasc && $subjpl) $elementaux[0] = $paraulacoord->propietats->fempl;
1421                                else if (!$subjmasc && !$subjpl) $elementaux[0] = $paraulacoord->propietats->fem;
1422                                else if ($subjmasc && $subjpl) $elementaux[0] = $paraulacoord->propietats->mascpl;
1423                                else $elementaux[0] = $paraulacoord->propietats->masc;
1424
1425                                // sobreescrivim si l'adjectiu tenia modificadors activats
1426                                // ho fem perquè si és verbless no té subjecte
1427                                if ($nucli->fem && $nucli->plural) $elementaux[0] = $paraulacoord->propietats->fempl;
1428                                else if ($nucli->fem) $elementaux[0] = $paraulacoord->propietats->fem;
1429                                else if ($nucli->plural) $elementaux[0] = $paraulacoord->propietats->mascpl;
1430
1431                                $elementaux[1] = $paraulacoord;
1432
1433                                $this->slotstring[] = $elementaux;
1434                            }
1435                        }
1436                    }
1437                   
1438                    break;
1439               
1440                case "verb":
1441                   
1442                    // MODIFICADOR, NOMÉS ELS QUE NO VAN A L'INICI DE LA FRASE
1443                    // més endavant, si hi ha pronoms febles amb el verb, l'ordre potser es canviarà
1444                   
1445                    // NO FEM RES: HO FARAN EL CONJUGADOR I EL CLEANER POSARÀ ELS MODIFICADORS QUE FALTIN
1446                    // A ON CALGUI DE LA FRASE
1447                   
1448                    /* if ($this->CModassigned) {
1449                       
1450                        $CI = &get_instance();
1451                        $CI->load->library('Mymatching');
1452                       
1453                        $matching = new Mymatching();
1454                       
1455                        for ($i=0; $i<count($this->CModassignedkey); $i++) {
1456                           
1457                            $quantifier = $this->cmpMod[$this->CModassignedkey[$i]]->paraulafinal;
1458                           
1459                            // si és dels que va entre subjecte i verb
1460                            if ($matching->isModAfterSubj($quantifier->text)) {
1461                                $elementaux[0] = $quantifier->text;
1462                                $elementaux[1] = $quantifier;
1463
1464                                $this->slotstring[] = $elementaux;
1465                            }
1466                        }                       
1467                    }
1468                   
1469                    // POSEM EL VERB, de moment en infinitiu
1470                    $elementaux[0] = $nucli->text;
1471                    $elementaux[1] = $nucli;
1472                    $elementaux[2] = false;
1473                   
1474                    $this->slotstring[] = $elementaux; */
1475
1476                    break;
1477               
1478                case "modifier":
1479
1480                    // PREPOSICIÓ
1481                    // posem la preposició, si n'hi ha
1482                    if ($this->prep != null) {
1483                        $elementaux[0] = $this->prep;
1484                        $elementaux[1] = null;
1485                        $this->slotstring[] = $elementaux;                       
1486                    }
1487                   
1488                    // NUCLI -> que és un modificador
1489                    $elementaux[0] = $nucli->text;
1490                    $elementaux[1] = $nucli;
1491                    $elementaux[2] = false;
1492                   
1493                    $this->slotstring[] = $elementaux;
1494                   
1495                    // QUANTIFICADORS, si n'hi ha
1496                    if ($this->CModassigned) {
1497                       for ($i=0; $i<count($this->CModassignedkey); $i++) {
1498                           
1499                            $quantifier = $this->cmpMod[$this->CModassignedkey[$i]]->paraulafinal;
1500                            $elementaux[0] = $quantifier->text;
1501                            $elementaux[1] = $quantifier;
1502
1503                            $this->slotstring[] = $elementaux;
1504                        } 
1505                    }
1506                   
1507                    break;
1508                   
1509                case "adv":
1510
1511                    // PREPOSICIÓ
1512                    // posem la preposició, si n'hi ha
1513                    if ($this->prep != null) {
1514                        $elementaux[0] = $this->prep;
1515                        $elementaux[1] = null;
1516                        $this->slotstring[] = $elementaux;                       
1517                    }
1518                   
1519                    // QUANTIFICADORS, si n'hi ha
1520                    if ($this->CModassigned) {
1521                       for ($i=0; $i<count($this->CModassignedkey); $i++) {
1522                           
1523                            $quantifier = $this->cmpMod[$this->CModassignedkey[$i]]->paraulafinal;
1524                            $elementaux[0] = $quantifier->text;
1525                            $elementaux[1] = $quantifier;
1526
1527                            $this->slotstring[] = $elementaux;
1528                        } 
1529                    }
1530                   
1531                    // NUCLI -> que és un adverbi
1532                    $elementaux[0] = $nucli->text;
1533                    $elementaux[1] = $nucli;
1534                    $elementaux[2] = false;
1535                   
1536                    $this->slotstring[] = $elementaux;
1537                                       
1538                    break;
1539                   
1540                case "questpart":
1541
1542                    // Va sense preposició
1543                   
1544                    // NUCLI -> que és una partícula de pregunta
1545                    $elementaux[0] = $nucli->text;
1546                    $elementaux[1] = $nucli;
1547                    $elementaux[2] = false;
1548                   
1549                    $this->slotstring[] = $elementaux;
1550                   
1551                    break;
1552               
1553                // Per qualsevol altra mena de nucli
1554                // posar primer la preposició, si n'hi ha, i després el valor per defecte
1555                default:
1556                   
1557                    // PREPOSICIÓ
1558                    // posem la preposició, si n'hi ha
1559                    if ($this->prep != null) {
1560                        $elementaux[0] = $this->prep;
1561                        $elementaux[1] = null;
1562                        $this->slotstring[] = $elementaux;                       
1563                    }
1564                   
1565                    // NUCLI
1566                    $elementaux[0] = $nucli->text;
1567                    $elementaux[1] = $nucli;
1568                    $elementaux[2] = false;
1569                   
1570                    $this->slotstring[] = $elementaux; 
1571                   
1572                    // si té element element coordinat
1573                    if (count($nucli->paraulacoord) > 0) {
1574
1575                        for ($k=0; $k<count($nucli->paraulacoord); $k++) {
1576
1577                            $paraulacoord = $nucli->paraulacoord[$k];
1578
1579                            // afegim la "i"
1580                            $elementaux[0] = "i";
1581                            $elementaux[1] = null;
1582                            $this->slotstring[] = $elementaux;
1583
1584                            // afegim la paraula coordinada
1585                            $elementaux[0] = $paraulacoord->text;
1586                            $elementaux[1] = $paraulacoord;
1587
1588                            $this->slotstring[] = $elementaux;
1589                        }
1590                    }
1591                   
1592                    break;
1593            }
1594           
1595        }
1596        // si l'slot tenia posat el valor per defecte
1597        // posar primer la preposició, si n'hi ha, i després el valor per defecte
1598        else {
1599            // PREPOSICIÓ
1600            // posem la preposició, si n'hi ha, excepte si l'slot obligatori s'ha quedat buit ->
1601            // ha utilitzat el defvalue i aquest era null           
1602            if ($this->prep != null 
1603                    && !($this->defvalueused && ($this->defvalue == null || $this->defvalue == ""))) {
1604                $elementaux[0] = $this->prep;
1605                $elementaux[1] = null;
1606               
1607                $this->slotstring[] = $elementaux;                       
1608            }
1609           
1610            $elementaux[0] = $this->defvalue;
1611            $elementaux[1] = null;
1612            $elementaux[2] = false;
1613           
1614            $this->slotstring[] = $elementaux; 
1615        }
1616       
1617        // print_r($this->slotstring); echo "<br /><br />";
1618    }
1619   
1620    // ordena els slots internament i fa concordar els elements
1621    public function ordenarSlotES($subjmasc, $subjpl, $copulatiu, $impersonal)
1622    {
1623        $nucli = $this->paraulafinal;
1624        $elementaux = array();
1625       
1626        if ($nucli != null) {
1627           
1628            switch ($nucli->tipus) {
1629                case "name":
1630                   
1631                    $numeros = array();
1632                    $quantifieradj = array(); // stores the quantifiers that complement the adj instead of the nucleus
1633                    $hasquantifieradj = false;
1634                    $hasnumorquant = false;
1635                    $haspossessive = 0; // al nostre sistema només els nuclis poden tenir possessius
1636                                            // també l'activarem si té ordinals o altres elements que van
1637                                            // entre l'article i el nom
1638                   
1639                    // calculem els valors per la concordància general
1640                    $masc = true;
1641                    $plural = false;
1642                   
1643                    // si el verb és copulatiu el nom del theme concorda amb el subjecte
1644                    if ($this->category == "Theme" && $copulatiu && !$impersonal) {
1645                       
1646                        // si el nom és femení
1647                        if ($nucli->propietats->mf == "fem") $masc = false;
1648                        // si el nom és plural
1649                        if ($nucli->propietats->singpl == "pl") $plural = true;
1650                        // si té modificadors de femení i l'accepta
1651                        if ($nucli->propietats->femeni != "" && $nucli->fem) $masc = false;
1652                        // si té modificador de plural
1653                        if ($nucli->plural) $plural = true;
1654                       
1655                        // sobreescrivim els valors si cal
1656                        if (!$subjmasc && $subjpl) {
1657                            if ($nucli->propietats->femeni != "") {
1658                                $masc = false;
1659                            }
1660                            $plural = true;
1661                        }
1662                        else if (!$subjmasc && !$subjpl && $nucli->propietats->femeni != "") {
1663                            $masc = false;
1664                        }
1665                        else if ($subjmasc && $subjpl) $plural = true;
1666                    }
1667                    else {
1668                        // si el nom és femení
1669                        if ($nucli->propietats->mf == "fem") $masc = false;
1670                        // si el nom és plural
1671                        if ($nucli->propietats->singpl == "pl") $plural = true;
1672                        // si té modificadors de femení i l'accepta
1673                        if ($nucli->propietats->femeni != "" && $nucli->fem) $masc = false;
1674                        // si té modificador de plural
1675                        if ($nucli->plural) $plural = true;
1676                    }
1677                   
1678                    // PREPOSICIÓ
1679                    // posem la preposició, si n'hi ha, excepte: Si el nom és el nucli d'un slot de LocAt i
1680                    // el complementa un adverbi de lloc. Per evitar ex: "Está en debajo la mesa." SI és un
1681                    // Theme amb un pronom i la preposició "a" davant, que no la posarem -> Per evitar: A te quiero.
1682                    if ($this->prep != null) {
1683                        if (!(($this->category == "LocAt" && $this->CAdvassigned && 
1684                                $this->cmpAdvs[$this->CAdvassignedkey]->paraulafinal->isClass("lloc"))
1685                                || ($this->category == "Theme" && $this->paraulafinal->isClass("pronoun") &&
1686                                    $this->prep == "a"))) {
1687                            $elementaux[0] = $this->prep;
1688                            $elementaux[1] = null;
1689                            $this->slotstring[] = $elementaux; 
1690                        }
1691                    }
1692                   
1693                    // Posem, si cal, la preposició "en" o "por", davant dels slots de temps
1694                    if ($this->category == "Time") {
1695                        $CI = &get_instance();
1696                        $CI->load->library('Mymatching');
1697                       
1698                        $matching = new Mymatching();
1699                       
1700                        if ($matching->isTimePrepES($nucli->text)) {
1701                            $elementaux[0] = $matching->tempsPrepES[$nucli->text];
1702                            $elementaux[1] = null;
1703                            $this->slotstring[] = $elementaux;
1704                        }
1705                    }
1706                   
1707                    // QUANTIFICADOR O POSSESSIUS
1708                    // si el nom té un modificador, que només pot ser un quantificador o possessiu
1709                    if ($this->CModassigned) {
1710                                               
1711                        for ($i=0; $i<count($this->CModassignedkey); $i++) {
1712                           
1713                            $quantifierslot = $this->cmpMod[$this->CModassignedkey[$i]];
1714                            // si és un número
1715                            if ($quantifierslot->paraulafinal->isClass("numero")) {
1716                                $numeros[] = $quantifierslot;
1717                                // si és un número diferent d'1, tot passarà a ser plural
1718                                if ($quantifierslot->paraulafinal->text != "un") $plural = true;
1719                            }
1720                            // si és un quantificador o possessiu
1721                            else {
1722                                // si el nucli també té un adjectiu assignat, mirem si va millor amb l'adjectiu
1723                                if ($this->CAdjassigned) {
1724                                    // si és quantifier i anava just davant de l'adjectiu, el guardem per després
1725                                    if ($quantifierslot->paraulafinal->inputorder - 
1726                                            $this->cmpAdjs[$this->CAdjassignedkey]->paraulafinal->inputorder == -1
1727                                            && $quantifierslot->paraulafinal->isClass("quant")) {
1728                                        $quantifieradj[] = $quantifierslot;
1729                                        $hasquantifieradj = true;
1730                                    }
1731                                    // si no, el tractem com un quantificador o possessiu normal
1732                                    else {
1733                                        if ($masc && !$plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->masc;
1734                                        else if ($masc && $plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->mascpl;
1735                                        else if (!$masc && !$plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->fem;
1736                                        else $elementaux[0] = $quantifierslot->paraulafinal->propietats->fempl;
1737                                        $elementaux[1] = $quantifierslot->paraulafinal;
1738
1739                                        $this->slotstring[] = $elementaux;
1740                                        $hasnumorquant = true;
1741                                        if (strpos($quantifierslot->paraulafinal->classes[0], "pos") === 0) {
1742                                            $haspossessive++; 
1743                                            $hasnumorquant = false;
1744                                        }
1745                                        // el nom precedit per parecido a portarà article
1746                                        if (strpos($quantifierslot->paraulafinal->text, "parecido")) $hasnumorquant = false;
1747                                    }
1748                                }
1749                                else {
1750                                    if ($masc && !$plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->masc;
1751                                    else if ($masc && $plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->mascpl;
1752                                    else if (!$masc && !$plural) $elementaux[0] = $quantifierslot->paraulafinal->propietats->fem;
1753                                    else $elementaux[0] = $quantifierslot->paraulafinal->propietats->fempl;
1754                                    $elementaux[1] = $quantifierslot->paraulafinal;
1755
1756                                    $this->slotstring[] = $elementaux;
1757                                    $hasnumorquant = true;
1758                                    if (strpos($quantifierslot->paraulafinal->classes[0], "pos") === 0) {
1759                                        $haspossessive++; 
1760                                        $hasnumorquant = false;
1761                                    }
1762                                    // el nom precedit per parecido a portarà article
1763                                    if (strpos($quantifierslot->paraulafinal->text, "parecido")) $hasnumorquant = false;
1764                                }
1765                            }
1766                        }                       
1767                    }
1768                   
1769                    // ADVERBI DE LLOC
1770                    if ($this->CAdvassigned) {
1771                       
1772                        $adverbistring = $this->cmpAdvs[$this->CAdvassignedkey]->paraulafinal;
1773                        // dividir-lo en cada una de les paraules que formen l'adverbi
1774                        $auxstring = explode(" ", $adverbistring->text);
1775                        // afegir cada paraula en ordre a slotstring
1776                        for ($i=0; $i<count($auxstring); $i++) {
1777                            $elementaux[0] = $auxstring[$i];
1778                            $elementaux[1] = $adverbistring;
1779                           
1780                            $this->slotstring[] = $elementaux;
1781                        }
1782                    }
1783                   
1784                    // NUMEROS
1785                    for ($i=0; $i<count($numeros); $i++) {
1786                        if ($masc) $elementaux[0] = $numeros[$i]->paraulafinal->propietats->masc;
1787                        else $elementaux[0] = $numeros[$i]->paraulafinal->propietats->fem;
1788                        $elementaux[1] = $numeros[$i]->paraulafinal;
1789                       
1790                        $this->slotstring[] = $elementaux;
1791                        $hasnumorquant = true;
1792                    }
1793                   
1794                    // ORDINALS
1795                    if ($this->CAdjassigned) {
1796                        $adjectiu = $this->cmpAdjs[$this->CAdjassignedkey]->paraulafinal;
1797                        if ($adjectiu->isClass("ordinal")) {
1798                            if ($masc && !$plural) {
1799                                // excepció per ex: El primer coche llega tarde.
1800                                if ($adjectiu->propietats->masc == "primero") $elementaux[0] = "primer";
1801                                else $elementaux[0] = $adjectiu->propietats->masc;
1802                            }
1803                            else if ($masc && $plural) $elementaux[0] = $adjectiu->propietats->mascpl;
1804                            else if (!$masc && !$plural) $elementaux[0] = $adjectiu->propietats->fem;
1805                            else $elementaux[0] = $adjectiu->propietats->fempl;
1806                            $elementaux[1] = $adjectiu;
1807
1808                            $this->slotstring[] = $elementaux;
1809                            $haspossessive++;
1810                            $this->CAdjassigned = false; // indiquem que ja s'ha vist l'adjectiu
1811                        }
1812                    }
1813                   
1814                    // NOM + COORDINACIÓ
1815                    if ($plural) {
1816                        if ($nucli->propietats->mf != "fem" && !$masc) $elementaux[0] = $nucli->propietats->fempl;
1817                        else $elementaux[0] = $nucli->propietats->plural;
1818                    }
1819                    else if ($masc && !$plural) $elementaux[0] = $nucli->propietats->nomtext;
1820                    else {
1821                        if ($nucli->propietats->mf == "fem") $elementaux[0] = $nucli->propietats->nomtext;
1822                        else $elementaux[0] = $nucli->propietats->femeni;
1823                    }
1824                    $elementaux[1] = $nucli;
1825                    // com que el nucli és un nom, afegim la informació extra
1826                    $elementaux[2] = true;
1827                    $elementaux[3] = $masc;
1828                    $elementaux[4] = $plural;
1829                    $elementaux[5] = $hasnumorquant;
1830                    $elementaux[6] = false;
1831                    $elementaux[7] = $haspossessive;
1832                   
1833                    $this->slotstring[] = $elementaux;
1834                   
1835                    // variables auxiliars que ens ajudaran a concordar l'adjectiu amb
1836                    // l'últim nom coordinat, si el nucli no té cap element coordinat,
1837                    // tenen els valors per concordar amb el nucli
1838                    $masccoord = $masc;
1839                    $pluralcoord = $plural;
1840                   
1841                    // si té element coordinat
1842                    if (count($nucli->paraulacoord) > 0) {
1843                       
1844                        for ($k=0; $k<count($nucli->paraulacoord); $k++) {
1845                           
1846                            $paraulacoord = $nucli->paraulacoord[$k];
1847
1848                            $paraulacoordisadj = false;
1849                            if ($paraulacoord->tipus == "adj") $paraulacoordisadj = true;
1850
1851                            // afegim la "y"
1852                            $elementaux[0] = "y";
1853                            $elementaux[1] = null;
1854                            $this->slotstring[] = $elementaux;
1855                           
1856                            if ($paraulacoordisadj) {
1857                                $elementaux[0] = $paraulacoord->propietats->masc;
1858                                $elementaux[1] = $paraulacoord;
1859                                $this->slotstring[] = $elementaux;
1860                            }
1861                            else {
1862                                // afegim la paraula coordinada, el plural es passa, però el femení
1863                                // s'ha de mirar si la paraula ho era o no el tenia el modificador
1864                                $masccoord = true;
1865                                $pluralcoord = false;
1866
1867                                if ($paraulacoord->propietats->mf == "fem" || $paraulacoord->fem) $masccoord = false;
1868                                // el plural només pot canviar si plural era false i la paraulacoord sempre és plural
1869                                // que aleshores ha de passar a true o si volíem que la paraulacoord fos plural
1870                                if ($paraulacoord->propietats->singpl == "pl" || $paraulacoord->plural) $pluralcoord = true;
1871
1872                                if ($pluralcoord) $elementaux[0] = $paraulacoord->propietats->plural;
1873                                else if ($masccoord && !$pluralcoord) $elementaux[0] = $paraulacoord->propietats->nomtext;
1874                                else {
1875                                    if ($paraulacoord->propietats->mf == "fem") $elementaux[0] = $paraulacoord->propietats->nomtext;
1876                                    else $elementaux[0] = $paraulacoord->propietats->femeni;
1877                                }
1878                                $elementaux[1] = $paraulacoord;
1879                                // com que la paraula coordinada ha de ser un nom, afegim la info extra
1880                                $elementaux[2] = true;
1881                                $elementaux[3] = $masccoord;
1882                                $elementaux[4] = $pluralcoord;
1883                                $elementaux[5] = $hasnumorquant;
1884                                $elementaux[6] = false;
1885                                $elementaux[7] = $haspossessive;
1886
1887                                $this->slotstring[] = $elementaux;
1888                            }
1889                        }
1890                    }
1891                   
1892                    // ADJECTIUS I COMPLEMENTS DE NOM
1893                    // si té un adjectiu i no un complement de nom
1894                    if ($this->CAdjassigned && !$this->NCassigned) {
1895                       
1896                        // si l'adjectiu tenia un quantificador l'afegim
1897                        if ($hasquantifieradj) {
1898                            for ($i=0; $i<count($quantifieradj); $i++) {
1899                                // aquí els quantificadors tenen forma invariable
1900                                // excepte "mucho" que pasa a ser "muy"
1901                                if ($quantifieradj[$i]->paraulafinal->propietats->masc == "mucho") {
1902                                    $elementaux[0] = "muy";
1903                                }
1904                                else {
1905                                    $elementaux[0] = $quantifieradj[$i]->paraulafinal->propietats->masc;
1906                                }
1907                                $elementaux[1] = $quantifieradj[$i]->paraulafinal;
1908                               
1909                                $this->slotstring[] = $elementaux;
1910                            }
1911                        }
1912                        // tant si tenia quantificador com si no, posem l'adjectiu
1913                        $adjectiu = $this->cmpAdjs[$this->CAdjassignedkey]->paraulafinal;
1914                        if ($masccoord && !$pluralcoord) $elementaux[0] = $adjectiu->propietats->masc;
1915                        else if ($masccoord && $pluralcoord) $elementaux[0] = $adjectiu->propietats->mascpl;
1916                        else if (!$masccoord && !$pluralcoord) $elementaux[0] = $adjectiu->propietats->fem;
1917                        else $elementaux[0] = $adjectiu->propietats->fempl;
1918                        $elementaux[1] = $adjectiu;
1919                       
1920                        $this->slotstring[] = $elementaux;
1921                       
1922                        // si té element adjectiu coordinat
1923                        if (count($adjectiu->paraulacoord) > 0) {
1924                       
1925                            for ($k=0; $k<count($adjectiu->paraulacoord); $k++) {
1926
1927                                $paraulacoord = $adjectiu->paraulacoord[$k];
1928                               
1929                                // afegim la "y"
1930                                $elementaux[0] = "y";
1931                                $elementaux[1] = null;
1932                                $this->slotstring[] = $elementaux;
1933
1934                                // afegim la paraula coordinada amb la mateixa concordància
1935                                if ($masccoord && !$pluralcoord) $elementaux[0] = $paraulacoord->propietats->masc;
1936                                else if ($masccoord && $pluralcoord) $elementaux[0] = $paraulacoord->propietats->mascpl;
1937                                else if (!$masccoord && !$pluralcoord) $elementaux[0] = $paraulacoord->propietats->fem;
1938                                else $elementaux[0] = $paraulacoord->propietats->fempl;
1939                                $elementaux[1] = $paraulacoord;
1940
1941                                $this->slotstring[] = $elementaux;
1942                           
1943                            }     
1944                        }
1945                    }
1946                    // si té complement de nom i no adjectiu
1947                    else if ($this->NCassigned && !$this->CAdjassigned) {
1948                       
1949                        $nouncmpslot = $this->complements[$this->NCassignedkey];
1950                        $nouncmp = $nouncmpslot->paraulafinal;
1951                       
1952                        // afegim la preposició "de"
1953                        $elementaux[0] = $nouncmpslot->prep;
1954                        $elementaux[1] = null;
1955                        $this->slotstring[] = $elementaux;
1956                       
1957                        // afegim el nom
1958                        $masccmp = true;
1959                        $pluralcmp = false;
1960                        // si el nom és femení
1961                        if ($nouncmp->propietats->mf == "fem") $masccmp = false;
1962                        // si el nom és plural
1963                        if ($nouncmp->propietats->singpl == "pl") $pluralcmp = true;
1964                        // si té modificadors de femení i l'accepta
1965                        if ($nouncmp->propietats->femeni != "" && $nouncmp->fem) $masccmp = false;
1966                        // si té modificador de plural
1967                        if ($nouncmp->plural) $pluralcmp = true;
1968                       
1969                        if ($pluralcmp) $elementaux[0] = $nouncmp->propietats->plural;
1970                        else if ($masccmp && !$pluralcmp) $elementaux[0] = $nouncmp->propietats->nomtext;
1971                        else {
1972                            if ($nouncmp->propietats->mf == "fem") $elementaux[0] = $nouncmp->propietats->nomtext;
1973                            else $elementaux[0] = $nouncmp->propietats->femeni;
1974                        }
1975                        $elementaux[1] = $nouncmp;
1976                        // com que el nucli és un nom, afegim la informació extra
1977                        $elementaux[2] = true;
1978                        $elementaux[3] = $masccmp;
1979                        $elementaux[4] = $pluralcmp;
1980                        $elementaux[5] = false;
1981                        $elementaux[6] = true;
1982                        $elementaux[7] = $haspossessive;
1983                       
1984                        $this->slotstring[] = $elementaux;
1985                       
1986                        $masccmpcoord = $masccmp;
1987                        $pluralcmpcoord = $pluralcmp;
1988                       
1989                        // si té element coordinat
1990                        if (count($nouncmp->paraulacoord) > 0) {
1991                       
1992                            for ($k=0; $k<count($nouncmp->paraulacoord); $k++) {
1993
1994                                $paraulacoord = $nouncmp->paraulacoord[$k];
1995                               
1996                                $paraulacoordisadj = false;
1997                                if ($paraulacoord->tipus == "adj") $paraulacoordisadj = true;
1998
1999                                // afegim la "y"
2000                                $elementaux[0] = "y";
2001                                $elementaux[1] = null;
2002                                $this->slotstring[] = $elementaux;
2003
2004                                if ($paraulacoordisadj) {
2005                                    $elementaux[0] = $paraulacoord->propietats->masc;
2006                                    $elementaux[1] = $paraulacoord;
2007                                    $this->slotstring[] = $elementaux;
2008                                }
2009                                else {
2010                                   // afegim la paraula coordinada amb la seva concordància
2011                                    $masccmpcoord = true;
2012                                    $pluralcmpcoord = false;
2013                                    // si el nom és femení
2014                                    if ($paraulacoord->propietats->mf == "fem") $masccmpcoord = false;
2015                                    // si el nom és plural
2016                                    if ($paraulacoord->propietats->singpl == "pl") $pluralcmpcoord = true;
2017                                    // si té modificadors de femení i l'accepta
2018                                    if ($paraulacoord->propietats->femeni != "" && $paraulacoord->fem) $masccmpcoord = false;
2019                                    // si té modificador de plural
2020                                    if ($paraulacoord->plural) $pluralcmpcoord = true;
2021
2022                                    if ($pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->plural;
2023                                    else if ($masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->nomtext;
2024                                    else {
2025                                        if ($paraulacoord->propietats->mf == "fem") $elementaux[0] = $paraulacoord->propietats->nomtext;
2026                                        else $elementaux[0] = $paraulacoord->propietats->femeni;
2027                                    }
2028                                    $elementaux[1] = $paraulacoord;
2029                                    // com que el nucli és un nom, afegim la informació extra
2030                                    $elementaux[2] = true;
2031                                    $elementaux[3] = $masccmpcoord;
2032                                    $elementaux[4] = $pluralcmpcoord;
2033                                    $elementaux[5] = false;
2034                                    $elementaux[6] = true;
2035                                    $elementaux[7] = $haspossessive;
2036
2037                                    $this->slotstring[] = $elementaux; 
2038                                }                               
2039                            }
2040                        }
2041                    }
2042                    // si té complement de nom i adjectiu
2043                    else if ($this->NCassigned && $this->CAdjassigned) {
2044                        $nouncmpslot = $this->complements[$this->NCassignedkey];
2045                        $adjectiuslot = $this->cmpAdjs[$this->CAdjassignedkey];
2046                        $puntsFitAdjWithNucli = $adjectiuslot->puntsfinal;
2047                                               
2048                        // calculem els punts que tindria fent fit al complement
2049                       
2050                        $CI = &get_instance();
2051                        $CI->load->library('Mymatching');
2052                       
2053                        $matching = new Mymatching();
2054                       
2055                        $classeadj = $adjectiuslot->paraulafinal->classes[$adjectiuslot->indexclassfinalword];
2056                       
2057                        $numclassesnomcmp = count($nouncmpslot->paraulafinal->classes);
2058                       
2059                        $puntsFitAdjWithCMP = 1000;
2060
2061                        for ($j=0; $j<$numclassesnomcmp; $j++) {
2062
2063                            $classenomaux = $nouncmpslot->paraulafinal->classes[$j];
2064
2065                            if ($matching->isSetKeyAdjNoun($classeadj) && $matching->isSetKeyNoun($classenomaux)) {
2066                               
2067                                $tipusx = $matching->adjNounFitKeys[$classeadj];
2068                                $tipusy = $matching->nounsFitKeys[$classenomaux];
2069
2070                                if ($matching->adjNounFit[$tipusx][$tipusy] < $puntsFitAdjWithCMP) {
2071                                    $puntsFitAdjWithCMP = $matching->adjNounFit[$tipusx][$tipusy];
2072                                }
2073                            }
2074                        }
2075                        // nom - adjectiu
2076                        $distance = $nouncmpslot->paraulafinal->inputorder - $adjectiuslot->paraulafinal->inputorder;
2077                        // com més lluny i com menys fit facin, pitjor
2078                        $puntsFitAdjWithCMP = 7 - $puntsFitAdjWithCMP - abs($distance);
2079                        if ($distance == -1) $puntsFitAdjWithCMP += 1;
2080                                               
2081                        // si fa millor fit al NUCLI
2082                        if ($puntsFitAdjWithNucli >= $puntsFitAdjWithCMP) {
2083                           
2084                            // insertem primer l'adjectiu
2085                            // si l'adjectiu tenia un quantificador l'afegim
2086                            if ($hasquantifieradj) {
2087                                for ($i=0; $i<count($quantifieradj); $i++) {
2088                                    // aquí els quantificadors tenen forma invariable
2089                                    // excepte "mucho" que pasa a ser "muy"
2090                                    if ($quantifieradj[$i]->paraulafinal->propietats->masc == "mucho") {
2091                                        $elementaux[0] = "muy";
2092                                    }
2093                                    else {
2094                                        $elementaux[0] = $quantifieradj[$i]->paraulafinal->propietats->masc;
2095                                    }
2096                                    $elementaux[1] = $quantifieradj[$i]->paraulafinal;
2097
2098                                    $this->slotstring[] = $elementaux;
2099                                }
2100                            }
2101                            // tant si tenia quantificador com si no, posem l'adjectiu
2102                            $adjectiu = $adjectiuslot->paraulafinal;
2103                            if ($masccoord && !$pluralcoord) $elementaux[0] = $adjectiu->propietats->masc;
2104                            else if ($masccoord && $pluralcoord) $elementaux[0] = $adjectiu->propietats->mascpl;
2105                            else if (!$masccoord && !$pluralcoord) $elementaux[0] = $adjectiu->propietats->fem;
2106                            else $elementaux[0] = $adjectiu->propietats->fempl;
2107                            $elementaux[1] = $adjectiu;
2108
2109                            $this->slotstring[] = $elementaux;
2110                           
2111                            // si té element adjectiu coordinat l'afegim
2112                            if (count($adjectiu->paraulacoord) > 0) {
2113
2114                                for ($k=0; $k<count($adjectiu->paraulacoord); $k++) {
2115
2116                                    $paraulacoord = $adjectiu->paraulacoord[$k];
2117                                   
2118                                    // afegim la "y"
2119                                    $elementaux[0] = "y";
2120                                    $elementaux[1] = null;
2121                                    $this->slotstring[] = $elementaux;
2122
2123                                    // afegim la paraula coordinada amb la mateixa concordància
2124                                    if ($masccoord && !$pluralcoord) $elementaux[0] = $paraulacoord->propietats->masc;
2125                                    else if ($masccoord && $pluralcoord) $elementaux[0] = $paraulacoord->propietats->mascpl;
2126                                    else if (!$masccoord && !$pluralcoord) $elementaux[0] = $paraulacoord->propietats->fem;
2127                                    else $elementaux[0] = $paraulacoord->propietats->fempl;
2128                                    $elementaux[1] = $paraulacoord;
2129
2130                                    $this->slotstring[] = $elementaux;
2131                                   
2132                                }   
2133                            }
2134
2135                            // després insertem el nom que fa de complement
2136                            $nouncmp = $nouncmpslot->paraulafinal;
2137
2138                            // afegim la preposició "de"
2139                            $elementaux[0] = $nouncmpslot->prep;
2140                            $elementaux[1] = null;
2141                            $this->slotstring[] = $elementaux;
2142
2143                            // afegim el nom
2144                            $masccmp = true;
2145                            $pluralcmp = false;
2146                            // si el nom és femení
2147                            if ($nouncmp->propietats->mf == "fem") $masccmp = false;
2148                            // si el nom és plural
2149                            if ($nouncmp->propietats->singpl == "pl") $pluralcmp = true;
2150                            // si té modificadors de femení i l'accepta
2151                            if ($nouncmp->propietats->femeni != "" && $nucli->fem) $masccmp = false;
2152                            // si té modificador de plural
2153                            if ($nouncmp->plural) $pluralcmp = true;
2154
2155                            if ($pluralcmp) $elementaux[0] = $nouncmp->propietats->plural;
2156                            else if ($masccmp && !$pluralcmp) $elementaux[0] = $nouncmp->propietats->nomtext;
2157                            else {
2158                                if ($nouncmp->propietats->mf == "fem") $elementaux[0] = $nouncmp->propietats->nomtext;
2159                                else $elementaux[0] = $nouncmp->propietats->femeni;
2160                            }
2161                            $elementaux[1] = $nouncmp;
2162                            // com que el nucli és un nom, afegim la informació extra
2163                            $elementaux[2] = true;
2164                            $elementaux[3] = $masccmp;
2165                            $elementaux[4] = $pluralcmp;
2166                            $elementaux[5] = false;
2167                            $elementaux[6] = true;
2168                            $elementaux[7] = $haspossessive;
2169                           
2170                            $this->slotstring[] = $elementaux;
2171                           
2172                            // si té element coordinat
2173                            if (count($nouncmp->paraulacoord) > 0) {
2174
2175                                for ($k=0; $k<count($nouncmp->paraulacoord); $k++) {
2176
2177                                    $paraulacoord = $nouncmp->paraulacoord[$k];
2178                                   
2179                                    $paraulacoordisadj = false;
2180                                    if ($paraulacoord->tipus == "adj") $paraulacoordisadj = true;
2181
2182                                    // afegim la "y"
2183                                    $elementaux[0] = "y";
2184                                    $elementaux[1] = null;
2185                                    $this->slotstring[] = $elementaux;
2186
2187                                    if ($paraulacoordisadj) {
2188                                        $elementaux[0] = $paraulacoord->propietats->masc;
2189                                        $elementaux[1] = $paraulacoord;
2190                                        $this->slotstring[] = $elementaux;
2191                                    }
2192                                    else {
2193                                        // afegim la paraula coordinada amb la seva concordància
2194                                        $masccmp = true;
2195                                        $pluralcmp = false;
2196                                        // si el nom és femení
2197                                        if ($paraulacoord->propietats->mf == "fem") $masccmp = false;
2198                                        // si el nom és plural
2199                                        if ($paraulacoord->propietats->singpl == "pl") $pluralcmp = true;
2200                                        // si té modificadors de femení i l'accepta
2201                                        if ($paraulacoord->propietats->femeni != "" && $paraulacoord->fem) $masccmp = false;
2202                                        // si té modificador de plural
2203                                        if ($paraulacoord->plural) $pluralcmp = true;
2204
2205                                        if ($pluralcmp) $elementaux[0] = $paraulacoord->propietats->plural;
2206                                        else if ($masccmp && !$pluralcmp) $elementaux[0] = $paraulacoord->propietats->nomtext;
2207                                        else {
2208                                            if ($paraulacoord->propietats->mf == "fem") $elementaux[0] = $paraulacoord->propietats->nomtext;
2209                                            else $elementaux[0] = $paraulacoord->propietats->femeni;
2210                                        }
2211                                        $elementaux[1] = $paraulacoord;
2212                                        // com que el nucli és un nom, afegim la informació extra
2213                                        $elementaux[2] = true;
2214                                        $elementaux[3] = $masccmp;
2215                                        $elementaux[4] = $pluralcmp;
2216                                        $elementaux[5] = false;
2217                                        $elementaux[6] = true;
2218                                        $elementaux[7] = $haspossessive;
2219
2220                                        $this->slotstring[] = $elementaux;
2221                                    }
2222                                }
2223                            }
2224                        }
2225                        // si fa millor fit al COMPLEMENT
2226                        else {
2227                           
2228                            // primer insertem el nom que fa de complement
2229                            $nouncmp = $nouncmpslot->paraulafinal;
2230
2231                            // afegim la preposició "de"
2232                            $elementaux[0] = $nouncmpslot->prep;
2233                            $elementaux[1] = null;
2234                            $this->slotstring[] = $elementaux;
2235
2236                            // afegim el nom
2237                            $masccmp = true;
2238                            $pluralcmp = false;
2239                            // si el nom és femení
2240                            if ($nouncmp->propietats->mf == "fem") $masccmp = false;
2241                            // si el nom és plural
2242                            if ($nouncmp->propietats->singpl == "pl") $pluralcmp = true;
2243                            // si té modificadors de femení i l'accepta
2244                            if ($nouncmp->propietats->femeni != "" && $nucli->fem) $masccmp = false;
2245                            // si té modificador de plural
2246                            if ($nouncmp->plural) $pluralcmp = true;
2247
2248                            if ($pluralcmp) $elementaux[0] = $nouncmp->propietats->plural;
2249                            else if ($masccmp && !$pluralcmp) $elementaux[0] = $nouncmp->propietats->nomtext;
2250                            else {
2251                                if ($nouncmp->propietats->mf == "fem") $elementaux[0] = $nouncmp->propietats->nomtext;
2252                                else $elementaux[0] = $nouncmp->propietats->femeni;
2253                            }
2254                            $elementaux[1] = $nouncmp;
2255                            // com que el nucli és un nom, afegim la informació extra
2256                            $elementaux[2] = true;
2257                            $elementaux[3] = $masccmp;
2258                            $elementaux[4] = $pluralcmp;
2259                            $elementaux[5] = false;
2260                            $elementaux[6] = true;
2261                            $elementaux[7] = $haspossessive;
2262                           
2263                            $this->slotstring[] = $elementaux;
2264                           
2265                            $masccmpcoord = $masccmp;
2266                            $pluralcmpcoord = $pluralcmp;
2267                           
2268                            // si té element coordinat
2269                            if (count($nouncmp->paraulacoord) > 0) {
2270
2271                                for ($k=0; $k<count($nouncmp->paraulacoord); $k++) {
2272
2273                                    $paraulacoord = $nouncmp->paraulacoord[$k];
2274                                   
2275                                    $paraulacoordisadj = false;
2276                                    if ($paraulacoord->tipus == "adj") $paraulacoordisadj = true;
2277
2278                                    // afegim la "y"
2279                                    $elementaux[0] = "y";
2280                                    $elementaux[1] = null;
2281                                    $this->slotstring[] = $elementaux;
2282
2283                                    if ($paraulacoordisadj) {
2284                                        $elementaux[0] = $paraulacoord->propietats->masc;
2285                                        $elementaux[1] = $paraulacoord;
2286                                        $this->slotstring[] = $elementaux;
2287                                    }
2288                                    else {
2289                                        // afegim la paraula coordinada amb la seva concordància
2290                                        $masccmpcoord = true;
2291                                        $pluralcmpcoord = false;
2292                                        // si el nom és femení
2293                                        if ($paraulacoord->propietats->mf == "fem") $masccmpcoord = false;
2294                                        // si el nom és plural
2295                                        if ($paraulacoord->propietats->singpl == "pl") $pluralcmpcoord = true;
2296                                        // si té modificadors de femení i l'accepta
2297                                        if ($paraulacoord->propietats->femeni != "" && $paraulacoord->fem) $masccmpcoord = false;
2298                                        // si té modificador de plural
2299                                        if ($paraulacoord->plural) $pluralcmpcoord = true;
2300
2301                                        if ($pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->plural;
2302                                        else if ($masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->nomtext;
2303                                        else {
2304                                            if ($paraulacoord->propietats->mf == "fem") $elementaux[0] = $paraulacoord->propietats->nomtext;
2305                                            else $elementaux[0] = $paraulacoord->propietats->femeni;
2306                                        }
2307                                        $elementaux[1] = $paraulacoord;
2308                                        // com que el nucli és un nom, afegim la informació extra
2309                                        $elementaux[2] = true;
2310                                        $elementaux[3] = $masccmpcoord;
2311                                        $elementaux[4] = $pluralcmpcoord;
2312                                        $elementaux[5] = false;
2313                                        $elementaux[6] = true;
2314                                        $elementaux[7] = $haspossessive;
2315
2316                                        $this->slotstring[] = $elementaux;
2317                                    }
2318                                }
2319                            }
2320                           
2321                            // després afegim l'adjectiu
2322                            // si l'adjectiu tenia un quantificador l'afegim
2323                            if ($hasquantifieradj) {
2324                                for ($i=0; $i<count($quantifieradj); $i++) {
2325                                    // aquí els quantificadors tenen forma invariable
2326                                    // excepte "mucho" que pasa a ser "muy"
2327                                    if ($quantifieradj[$i]->paraulafinal->propietats->masc == "mucho") {
2328                                        $elementaux[0] = "muy";
2329                                    }
2330                                    else {
2331                                        $elementaux[0] = $quantifieradj[$i]->paraulafinal->propietats->masc;
2332                                    }
2333                                    $elementaux[1] = $quantifieradj[$i]->paraulafinal;
2334
2335                                    $this->slotstring[] = $elementaux;
2336                                }
2337                            }
2338                            // tant si tenia quantificador com si no, posem l'adjectiu que concorda amb el complement
2339                            $adjectiu = $adjectiuslot->paraulafinal;
2340                            if ($masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $adjectiu->propietats->masc;
2341                            else if ($masccmpcoord && $pluralcmpcoord) $elementaux[0] = $adjectiu->propietats->mascpl;
2342                            else if (!$masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $adjectiu->propietats->fem;
2343                            else $elementaux[0] = $adjectiu->propietats->fempl;
2344                            $elementaux[1] = $adjectiu;
2345
2346                            $this->slotstring[] = $elementaux;
2347                           
2348                            // si té element adjectiu coordinat l'afegim
2349                            if (count($adjectiu->paraulacoord) > 0) {
2350
2351                                for ($k=0; $k<count($adjectiu->paraulacoord); $k++) {
2352
2353                                    $paraulacoord = $adjectiu->paraulacoord[$k];
2354                                   
2355                                    // afegim la "y"
2356                                    $elementaux[0] = "y";
2357                                    $elementaux[1] = null;
2358                                    $this->slotstring[] = $elementaux;
2359
2360                                    // afegim la paraula coordinada amb la mateixa concordància
2361                                    if ($masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->masc;
2362                                    else if ($masccmpcoord && $pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->mascpl;
2363                                    else if (!$masccmpcoord && !$pluralcmpcoord) $elementaux[0] = $paraulacoord->propietats->fem;
2364                                    else $elementaux[0] = $paraulacoord->propietats->fempl;
2365                                    $elementaux[1] = $paraulacoord;
2366
2367                                    $this->slotstring[] = $elementaux;
2368                                }
2369                            }
2370                        }
2371                    } // Fi si té complement de nom i adjectiu
2372
2373                    break;
2374               
2375                case "adj":
2376                   
2377                    // PREPOSICIÓ
2378                    // posem la preposició, si n'hi ha
2379                    if ($this->prep != null) {
2380                            $elementaux[0] = $this->prep;
2381                            $elementaux[1] = null;
2382                            $this->slotstring[] = $elementaux;                       
2383                    }
2384                   
2385                    // QUANTIFICADOR
2386                    // si l'adjectiu té un modificador, que només pot ser un quantificador
2387                    if ($this->CModassigned) {
2388                       
2389                        for ($i=0; $i<count($this->CModassignedkey); $i++) {
2390                           
2391                            $quantifierslot = $this->cmpMod[$this->CModassignedkey[$i]];
2392                           
2393                            // el quantificador és invariable
2394                            // excepte "mucho" que pasa a ser "muy"
2395                            if ($quantifierslot->paraulafinal->propietats->masc == "mucho") {
2396                                // si té més d'un quantificador ja no. Ex: mucho más alto
2397                                if (count($this->CModassignedkey) == 1) $elementaux[0] = "muy";
2398                                else $elementaux[0] = "mucho";
2399                            }
2400                            else {
2401                                $elementaux[0] = $quantifierslot->paraulafinal->propietats->masc;
2402                            }
2403                            $elementaux[1] = $quantifierslot->paraulafinal;
2404
2405                            $this->slotstring[] = $elementaux;
2406                        }                       
2407                    }
2408                   
2409                   
2410                    // POSEM L'ADJECTIU, HA DE CONCORDAR AMB EL SUBJECTE, ja que l'adjectiu
2411                    // només té slots per fer de nucli en verbs copulatius o verbless patterns
2412                    // tenint en compte els modificadors de subjecte
2413                    // si estan definits, tenen preferència els modificadors de l'adjectiu
2414                    // Si és d'un slot de MANNER no ha de concordar
2415                                       
2416                    // si és de manera posem l'adjectiu en masculí
2417                    if ($this->category == "Manner") {
2418                        $elementaux[0] = $nucli->text;
2419                        $elementaux[1] = $nucli;
2420                        $elementaux[2] = false;
2421                       
2422                        $this->slotstring[] = $elementaux;
2423                       
2424                        // si té element adjectiu coordinat
2425                        if (count($nucli->paraulacoord) > 0) {
2426
2427                            for ($k=0; $k<count($nucli->paraulacoord); $k++) {
2428
2429                                $paraulacoord = $nucli->paraulacoord[$k];
2430                               
2431                                // afegim la "y"
2432                                $elementaux[0] = "y";
2433                                $elementaux[1] = null;
2434                                $this->slotstring[] = $elementaux;
2435
2436                                // afegim la paraula coordinada amb la mateixa concordància
2437                                $elementaux[0] = $paraulacoord->text;
2438                                $elementaux[1] = $paraulacoord;
2439
2440                                $this->slotstring[] = $elementaux;
2441                            }
2442                        }
2443                    }
2444                    // si no era de manera (en principi és de verb copulatiu o verbless
2445                    else {
2446                        // posem l'adjectiu que concordi
2447                        if (!$subjmasc && $subjpl) $elementaux[0] = $nucli->propietats->fempl;
2448                        else if (!$subjmasc && !$subjpl) $elementaux[0] = $nucli->propietats->fem;
2449                        else if ($subjmasc && $subjpl) $elementaux[0] = $nucli->propietats->mascpl;
2450                        else $elementaux[0] = $nucli->propietats->masc;
2451                       
2452                        // sobreescrivim si l'adjectiu tenia modificadors activats
2453                        // ho fem perquè si és verbless no té subjecte
2454                        if ($nucli->fem && $nucli->plural) $elementaux[0] = $nucli->propietats->fempl;
2455                        else if ($nucli->fem) $elementaux[0] = $nucli->propietats->fem;
2456                        else if ($nucli->plural) $elementaux[0] = $nucli->propietats->mascpl;
2457                       
2458                        $elementaux[1] = $nucli;
2459                        $elementaux[2] = false;
2460                       
2461                        $this->slotstring[] = $elementaux;
2462                       
2463                        // si té element adjectiu coordinat
2464                        if (count($nucli->paraulacoord) > 0) {
2465
2466                            for ($k=0; $k<count($nucli->paraulacoord); $k++) {
2467
2468                                $paraulacoord = $nucli->paraulacoord[$k];
2469                               
2470                                // afegim la "y"
2471                                $elementaux[0] = "y";
2472                                $elementaux[1] = null;
2473                                $this->slotstring[] = $elementaux;
2474
2475                                // afegim la paraula coordinada amb la mateixa concordància
2476                                if (!$subjmasc && $subjpl) $elementaux[0] = $paraulacoord->propietats->fempl;
2477                                else if (!$subjmasc && !$subjpl) $elementaux[0] = $paraulacoord->propietats->fem;
2478                                else if ($subjmasc && $subjpl) $elementaux[0] = $paraulacoord->propietats->mascpl;
2479                                else $elementaux[0] = $paraulacoord->propietats->masc;
2480
2481                                // sobreescrivim si l'adjectiu tenia modificadors activats
2482                                // ho fem perquè si és verbless no té subjecte
2483                                if ($nucli->fem && $nucli->plural) $elementaux[0] = $paraulacoord->propietats->fempl;
2484                                else if ($nucli->fem) $elementaux[0] = $paraulacoord->propietats->fem;
2485                                else if ($nucli->plural) $elementaux[0] = $paraulacoord->propietats->mascpl;
2486
2487                                $elementaux[1] = $paraulacoord;
2488
2489                                $this->slotstring[] = $elementaux;
2490                            }
2491                        }
2492                    }
2493                   
2494                    break;
2495               
2496                case "verb":
2497                   
2498                    // MODIFICADOR, NOMÉS ELS QUE NO VAN A L'INICI DE LA FRASE
2499                    // més endavant, si hi ha pronoms febles amb el verb, l'ordre potser es canviarà
2500                   
2501                    // NO FEM RES: HO FARAN EL CONJUGADOR I EL CLEANER POSARÀ ELS MODIFICADORS QUE FALTIN
2502                    // A ON CALGUI DE LA FRASE
2503                   
2504                    /* if ($this->CModassigned) {
2505                       
2506                        $CI = &get_instance();
2507                        $CI->load->library('Mymatching');
2508                       
2509                        $matching = new Mymatching();
2510                       
2511                        for ($i=0; $i<count($this->CModassignedkey); $i++) {
2512                           
2513                            $quantifier = $this->cmpMod[$this->CModassignedkey[$i]]->paraulafinal;
2514                           
2515                            // si és dels que va entre subjecte i verb
2516                            if ($matching->isModAfterSubj($quantifier->text)) {
2517                                $elementaux[0] = $quantifier->text;
2518                                $elementaux[1] = $quantifier;
2519
2520                                $this->slotstring[] = $elementaux;
2521                            }
2522                        }                       
2523                    }
2524                   
2525                    // POSEM EL VERB, de moment en infinitiu
2526                    $elementaux[0] = $nucli->text;
2527                    $elementaux[1] = $nucli;
2528                    $elementaux[2] = false;
2529                   
2530                    $this->slotstring[] = $elementaux; */
2531
2532                    break;
2533               
2534                case "modifier":
2535
2536                    // PREPOSICIÓ
2537                    // posem la preposició, si n'hi ha
2538                    if ($this->prep != null) {
2539                        $elementaux[0] = $this->prep;
2540                        $elementaux[1] = null;
2541                        $this->slotstring[] = $elementaux;                       
2542                    }
2543                   
2544                    // NUCLI -> que és un modificador
2545                    $elementaux[0] = $nucli->text;
2546                    $elementaux[1] = $nucli;
2547                    $elementaux[2] = false;
2548                   
2549                    $this->slotstring[] = $elementaux;
2550                   
2551                    // QUANTIFICADORS, si n'hi ha
2552                    if ($this->CModassigned) {
2553                       for ($i=0; $i<count($this->CModassignedkey); $i++) {
2554                           
2555                            $quantifier = $this->cmpMod[$this->CModassignedkey[$i]]->paraulafinal;
2556                            $elementaux[0] = $quantifier->text;
2557                            $elementaux[1] = $quantifier;
2558
2559                            $this->slotstring[] = $elementaux;
2560                        } 
2561                    }
2562                   
2563                    break;
2564                   
2565                case "adv":
2566
2567                    // PREPOSICIÓ
2568                    // posem la preposició, si n'hi ha
2569                    if ($this->prep != null) {
2570                        $elementaux[0] = $this->prep;
2571                        $elementaux[1] = null;
2572                        $this->slotstring[] = $elementaux;                       
2573                    }
2574                   
2575                    // QUANTIFICADORS, si n'hi ha
2576                    if ($this->CModassigned) {
2577                       for ($i=0; $i<count($this->CModassignedkey); $i++) {
2578                           
2579                            $quantifier = $this->cmpMod[$this->CModassignedkey[$i]]->paraulafinal;
2580                            // Excepció: Ex: "Muy arriba".
2581                            if ($quantifier->text == "mucho") {
2582                                // si té més d'un quantificador ja no. Ex: mucho más arriba
2583                                if (count($this->CModassignedkey) == 1) $elementaux[0] = "muy";
2584                                else $elementaux[0] = "mucho";
2585                            }
2586                            else $elementaux[0] = $quantifier->text;
2587                            $elementaux[1] = $quantifier;
2588
2589                            $this->slotstring[] = $elementaux;
2590                        } 
2591                    }
2592                   
2593                    // NUCLI -> que és un adverbi
2594                    $elementaux[0] = $nucli->text;
2595                    $elementaux[1] = $nucli;
2596                    $elementaux[2] = false;
2597                   
2598                    $this->slotstring[] = $elementaux;
2599                                       
2600                    break;
2601                   
2602                case "questpart":
2603
2604                    // Va sense preposició
2605                   
2606                    // NUCLI -> que és una partícula de pregunta
2607                    $elementaux[0] = $nucli->text;
2608                    $elementaux[1] = $nucli;
2609                    $elementaux[2] = false;
2610                   
2611                    $this->slotstring[] = $elementaux;
2612                   
2613                    break;
2614               
2615                // Per qualsevol altra mena de nucli
2616                // posar primer la preposició, si n'hi ha, i després el valor per defecte
2617                default:
2618                   
2619                    // PREPOSICIÓ
2620                    // posem la preposició, si n'hi ha
2621                    if ($this->prep != null) {
2622                        $elementaux[0] = $this->prep;
2623                        $elementaux[1] = null;
2624                        $this->slotstring[] = $elementaux;                       
2625                    }
2626                   
2627                    // NUCLI
2628                    $elementaux[0] = $nucli->text;
2629                    $elementaux[1] = $nucli;
2630                    $elementaux[2] = false;
2631                   
2632                    $this->slotstring[] = $elementaux; 
2633                   
2634                    // si té element element coordinat
2635                    if (count($nucli->paraulacoord) > 0) {
2636
2637                        for ($k=0; $k<count($nucli->paraulacoord); $k++) {
2638
2639                            $paraulacoord = $nucli->paraulacoord[$k];
2640
2641                            // afegim la "y"
2642                            $elementaux[0] = "y";
2643                            $elementaux[1] = null;
2644                            $this->slotstring[] = $elementaux;
2645
2646                            // afegim la paraula coordinada
2647                            $elementaux[0] = $paraulacoord->text;
2648                            $elementaux[1] = $paraulacoord;
2649
2650                            $this->slotstring[] = $elementaux;
2651                        }
2652                    }
2653                   
2654                    break;
2655            }
2656           
2657        }
2658        // si l'slot tenia posat el valor per defecte
2659        // posar primer la preposició, si n'hi ha, i després el valor per defecte
2660        else {
2661            // PREPOSICIÓ
2662            // posem la preposició, si n'hi ha, excepte si l'slot obligatori s'ha quedat buit ->
2663            // ha utilitzat el defvalue i aquest era null           
2664            if ($this->prep != null 
2665                    && !($this->defvalueused && ($this->defvalue == null || $this->defvalue == ""))) {
2666                $elementaux[0] = $this->prep;
2667                $elementaux[1] = null;
2668               
2669                $this->slotstring[] = $elementaux;                       
2670            }
2671           
2672            $elementaux[0] = $this->defvalue;
2673            $elementaux[1] = null;
2674            $elementaux[2] = false;
2675           
2676            $this->slotstring[] = $elementaux; 
2677        }
2678       
2679        // print_r($this->slotstring); echo "<br /><br />";
2680    }
2681   
2682    // Posa els articles necessaris a tots els noms de l'slot
2683    public function putArticles($tipusfrase, $partQuant)
2684    {
2685        $i=0;
2686        $numelements = count($this->slotstring);
2687       
2688        // recorrem slotstring per tractar tots els noms que hi ha a l'slot
2689        while ($i<count($this->slotstring)) { 
2690           
2691            $definite = false;
2692            $indefinite = false;
2693            $noarticle = false;
2694            $auxstring = $this->slotstring[$i];
2695                       
2696            $article = "";
2697           
2698            // agafem la paraula
2699            $wordaux = $auxstring[1];
2700           
2701            // si és un nom
2702            if ($wordaux != null && $wordaux->isType("name")) {
2703                // si no necessita article (perquè té quantificadors a davant) o perquè
2704                // és un pronom personal
2705               
2706                if ($auxstring[5] || $wordaux->isClass("pronoun")) $noarticle = true;
2707                // si és un nom propi va amb article determinat
2708                else if ($wordaux->propietats->ispropernoun == '1') $definite = true;
2709                // si no té quantificador davant, procedim amb l'algoritme normal
2710                else {
2711                    // si són complements (al nostre sistema no poden tenir possessius)
2712                    // si no porten article, sense article, i si són del grup dels animats amb determinat
2713                    // i si no sense, JA QUE ÉS EL CAS MÉS COMÚ
2714                    if ($auxstring[6]) {
2715                        if ($wordaux->propietats->determinat == 'sense') $noarticle = true;
2716                        else if ($wordaux->isClass("material")) $noarticle = true;
2717                        else if ($wordaux->isClass("animate") ||
2718                                $wordaux->isClass("animal") ||
2719                                $wordaux->isClass("vehicle") ||
2720                                $wordaux->isClass("human") ||
2721                                $wordaux->isClass("event") ||
2722                                $wordaux->isClass("objecte") ||
2723                                $wordaux->isClass("lloc") ||
2724                                $wordaux->isClass("time") ||
2725                                $wordaux->isClass("planta")) $definite = true;
2726                        else $noarticle = true;
2727                    }
2728                    // si no són complements, dependrà de quina categoria sigui l'slot
2729                    else {
2730                        // si tenen un possessiu l'article és sempre determinat
2731                        if ($auxstring[7] > 0) $definite = true;
2732                        // si no hi ha possessiu
2733                        else {
2734                            // si és subjecte és determinat, excepte si és un lloc
2735                            if ($this->category == "Subject") {
2736                                // si és una ordre, el subjecte no porta article
2737                                if ($tipusfrase == "ordre") $noarticle = true;
2738                                else {
2739                                    if ($wordaux->isClass("lloc")) {
2740                                        // mirar propietats
2741                                        if ($wordaux->propietats->determinat == 'sense') $noarticle = true;
2742                                        else $definite = true;
2743                                    }
2744                                    else $definite = true;
2745                                }
2746                            }
2747                            // si és un locatiu
2748                            else if ($this->category == "LocAt" || $this->category == "LocTo" 
2749                                    || $this->category == "LocFrom") {
2750                                if ($wordaux->isClass("lloc") || $wordaux->isClass("joc")) {
2751                                    // si no porten article, sense article, i si no determinat
2752                                    if ($wordaux->propietats->determinat == 'sense') $noarticle = true;
2753                                    else $definite = true;
2754                                }
2755                                else $definite = true;
2756                            }
2757                            // si és un theme
2758                            else if ($this->category == "Theme") {
2759                                // si hi ha la pregunta "quant", el theme va sense article
2760                                if ($partQuant) $noarticle = true;
2761                                // si és una resposta, si el nom és humà, article determinat
2762                                else if ($tipusfrase == "resposta" && $wordaux->isClass("human")) {
2763                                    $definite = true;
2764                                }
2765                                // si hi ha definit un article determinat pel theme i la paraula no
2766                                // preferia no portar article, l'agafem
2767                                else if ($this->art != null && $wordaux->propietats->determinat != 'sense') {
2768                                    if ($this->art == '1') $definite = true;
2769                                    else if ($this->art == '0') $indefinite = true;
2770                                    else $noarticle = true;
2771                                }
2772                                // si no, mirem les propietats
2773                                else {
2774                                    if ($wordaux->propietats->determinat == '1') $definite = true;
2775                                    else if ($wordaux->propietats->determinat == '0') $indefinite = true;
2776                                    else $noarticle = true;
2777                                }
2778                            }
2779                            // si és un receiver
2780                            else if ($this->category == "Receiver") {
2781                                $definite = true;
2782                            }
2783                            // en tots els altres slots i casos, mirem les propietats del nom
2784                            else {
2785                                if ($wordaux->propietats->determinat == '1') $definite = true;
2786                                else if ($wordaux->propietats->determinat == '0') $indefinite = true;
2787                                else $noarticle = true;
2788                            }
2789                        } // Fi si no hi ha possessiu
2790                    } // Fi si no és complement
2791                } // Fi si no té quantificador
2792            }
2793            // si no és un nom
2794            else $noarticle = true;
2795           
2796            // POSEM ELS ARTICLES
2797            //si ha de portar article
2798            if (!$noarticle) {
2799                if ($definite) {
2800                    // si té possessius i/o ordinals davant, no volem que posi apòstrofs si el nom és singular,
2801                    // ja que concorda amb el nom, però va davant dels possessius o ordinals que mai
2802                    // comencen en vocal
2803                    if ($auxstring[7] > 0 && !$auxstring[4]) {
2804                        if ($auxstring[3]) $article = "el";
2805                        else $article = "la";
2806                    }
2807                    else $article = $wordaux->giveDefiniteArticleContext($auxstring[3], $auxstring[4]);
2808
2809                }
2810
2811                else if ($indefinite) {
2812                    $article = $wordaux->giveIndefiniteArticleContext($auxstring[3], $auxstring[4]);
2813                }
2814               
2815                // fer l'insert, tenir en compte si és POSSESSIU
2816                $elementaux = array();
2817                $elementaux[0] = $article;
2818                $elementaux[1] = null;
2819               
2820                $indexinsert = $i;
2821                // si té un possessiu i/o un ordinal, l'hem de posar abans del possessiu i/o l'ordinal
2822                if ($auxstring[7] > 0) $indexinsert -= $auxstring[7];
2823               
2824                // fem l'insert... aquí array_splice donava problemes
2825                $slotstringaux = array();
2826                for ($j=0; $j<count($this->slotstring); $j++) {
2827                    if ($j == $indexinsert) $slotstringaux[] = $elementaux;
2828                    $slotstringaux[] = $this->slotstring[$j];
2829                }
2830                $this->slotstring = $slotstringaux;
2831                                               
2832                // si insertem un element, com que no volem tornar a tractar el nom que ara està una posició
2833                // més endavant de slotstring, incrementem la "i"
2834                $i++; 
2835            }
2836           
2837            $i++;
2838        } // Fi while per cada element de slotstring
2839    }
2840   
2841    // Posa els articles necessaris a tots els noms de l'slot
2842    public function putArticlesES($tipusfrase, $partQuant)
2843    {
2844        $i=0;
2845       
2846        // recorrem slotstring per tractar tots els noms que hi ha a l'slot
2847        while ($i<count($this->slotstring)) { 
2848           
2849            $definite = false;
2850            $indefinite = false;
2851            $noarticle = false;
2852            $auxstring = $this->slotstring[$i];
2853                       
2854            $article = "";
2855           
2856            // agafem la paraula
2857            $wordaux = $auxstring[1];
2858           
2859            // si és un nom
2860            if ($wordaux != null && $wordaux->isType("name")) {
2861                // si no necessita article (perquè té quantificadors a davant) o perquè
2862                // és un pronom personal o un nom propi
2863                if ($auxstring[5] || $wordaux->isClass("pronoun") || $wordaux->propietats->ispropernoun == '1') $noarticle = true;
2864                // si no té quantificador davant, procedim amb l'algoritme normal
2865                else {
2866                    // si són complements (al nostre sistema no poden tenir possessius)
2867                    // si no porten article, sense article, i si són del grup dels animats amb determinat
2868                    // i si no sense, JA QUE ÉS EL CAS MÉS COMÚ
2869                    if ($auxstring[6]) {
2870                        if ($wordaux->propietats->determinat == 'sense') $noarticle = true;
2871                        else if ($wordaux->isClass("material")) $noarticle = true;
2872                        else if ($wordaux->isClass("animate") ||
2873                                $wordaux->isClass("animal") ||
2874                                $wordaux->isClass("vehicle") ||
2875                                $wordaux->isClass("human") ||
2876                                $wordaux->isClass("event") ||
2877                                $wordaux->isClass("objecte") ||
2878                                $wordaux->isClass("lloc") ||
2879                                $wordaux->isClass("time") ||
2880                                $wordaux->isClass("planta")) $definite = true;
2881                        else $noarticle = true;
2882                    }
2883                    // si no són complements, dependrà de quina categoria sigui l'slot
2884                    else {
2885                        // si tenen un possessiu no porten article en castellà
2886                        if ($auxstring[7] > 0) $noarticle = true;
2887                        // si no hi ha possessiu
2888                        else {
2889                            // si és subjecte és determinat, excepte si és un lloc
2890                            if ($this->category == "Subject") {
2891                                // si és una ordre, el subjecte no porta article
2892                                if ($tipusfrase == "ordre") $noarticle = true;
2893                                else {
2894                                    if ($wordaux->isClass("lloc")) {
2895                                        // mirar propietats
2896                                        if ($wordaux->propietats->determinat == 'sense') $noarticle = true;
2897                                        else $definite = true;
2898                                    } 
2899                                    else $definite = true;
2900                                }
2901                            }
2902                            // si és un locatiu
2903                            else if ($this->category == "LocAt" || $this->category == "LocTo" 
2904                                    || $this->category == "LocFrom") {
2905                                if ($wordaux->isClass("lloc") || $wordaux->isClass("joc")) {
2906                                    // si no porten article, sense article, i si no determinat
2907                                    if ($wordaux->propietats->determinat == 'sense') $noarticle = true;
2908                                    else $definite = true;
2909                                }
2910                                else $definite = true;
2911                            }
2912                            // si és un theme
2913                            else if ($this->category == "Theme") {
2914                                // si hi ha la pregunta "quant", el theme va sense article
2915                                if ($partQuant) $noarticle = true;
2916                                // si és una resposta, si el nom és humà, article determinat
2917                                else if ($tipusfrase == "resposta" && $wordaux->isClass("human")) {
2918                                    $definite = true;
2919                                }
2920                                // si hi ha definit un article determinat pel theme l'agafem
2921                                else if ($this->art != null) {
2922                                    if ($this->art == '1') $definite = true;
2923                                    else if ($this->art == '0') $indefinite = true;
2924                                    else $noarticle = true;
2925                                }
2926                                // si no, mirem les propietats
2927                                else {
2928                                    if ($wordaux->propietats->determinat == '1') $definite = true;
2929                                    else if ($wordaux->propietats->determinat == '0') $indefinite = true;
2930                                    else $noarticle = true;
2931                                }
2932                            }
2933                            // si és un receiver
2934                            else if ($this->category == "Receiver") {
2935                                $definite = true;
2936                            }
2937                            // en tots els altres slots i casos, mirem les propietats del nom
2938                            else {
2939                                if ($wordaux->propietats->determinat == '1') $definite = true;
2940                                else if ($wordaux->propietats->determinat == '0') $indefinite = true;
2941                                else $noarticle = true;
2942                            }
2943                        } // Fi si no hi ha possessiu
2944                    } // Fi si no és complement
2945                } // Fi si no té quantificador
2946            }
2947            // SI NO ÉS UN NOM
2948            else $noarticle = true;
2949           
2950            // POSEM ELS ARTICLES
2951            //si ha de portar article
2952            if (!$noarticle) {
2953                if ($definite) {
2954                    if ($auxstring[3] && !$auxstring[4]) $article = "el";
2955                    else if (!$auxstring[3] && !$auxstring[4]) $article = "la";
2956                    else if ($auxstring[3] && $auxstring[4]) $article = "los";
2957                    else if (!$auxstring[3] && $auxstring[4]) $article = "las";
2958                }
2959
2960                else if ($indefinite) {
2961                    if ($auxstring[3] && !$auxstring[4]) $article = "un";
2962                    else if (!$auxstring[3] && !$auxstring[4]) $article = "una";
2963                    else if ($auxstring[3] && $auxstring[4]) $article = "unos";
2964                    else if (!$auxstring[3] && $auxstring[4]) $article = "unas";
2965                }
2966               
2967                // fer l'insert, tenir en compte si té un ORDINAL, ex: "el segundo jugador"
2968                $elementaux = array();
2969                $elementaux[0] = $article;
2970                $elementaux[1] = null;
2971               
2972                $indexinsert = $i;
2973                // si té un ordinal, l'hem de posar abans de l'ordinal
2974                if ($auxstring[7] > 0) $indexinsert -= $auxstring[7];
2975               
2976                // fem l'insert... aquí array_splice donava problemes
2977                $slotstringaux = array();
2978                for ($j=0; $j<count($this->slotstring); $j++) {
2979                    if ($j == $indexinsert) $slotstringaux[] = $elementaux;
2980                    $slotstringaux[] = $this->slotstring[$j];
2981                }
2982                $this->slotstring = $slotstringaux;
2983                                               
2984                // si insertem un element, com que no volem tornar a tractar el nom que ara està una posició
2985                // més endavant de slotstring, incrementem la "i"
2986                $i++; 
2987            }
2988           
2989            $i++;
2990        } // Fi while per cada element de slotstring
2991    }
2992   
2993}
2994
2995/* End of file Myslot.php */
Note: See TracBrowser for help on using the repository browser.