diff --git a/index_4.6.html b/index_4.6.html index 5af989f..e20c953 100644 --- a/index_4.6.html +++ b/index_4.6.html @@ -38,9 +38,10 @@ - + + diff --git a/js/browseMgr.js b/js/browseMgr.js index 1ac8cbb..b641a6b 100644 --- a/js/browseMgr.js +++ b/js/browseMgr.js @@ -14,7 +14,7 @@ var vistaRiferimenti = true var listaPeriodiRisultato; var listaClausoleRisultato; var numeroContesti; -var hdnNamespace='http://dantenetwork.it/data/commedia/' +const hdnNamespace='http://dantenetwork.it/data/commedia/' const syntitNamespace='https://dantenetwork.it/ontology/syntit/current/' $(document).ready(function() { @@ -1901,12 +1901,17 @@ $(document).ready(function() { //regione della clausola var clfrom = binding.get('clfr').value; var clto = binding.get('clto').value; - //var cltype=binding.get('clatype').value.replace(syntitNamespace,'') - var clfunction = binding.get('clafunction').value.replace(syntitNamespace, '') - var clocc = binding.get('clocc').value.replace(hdnNamespace, '') + var clfunction='' + if (binding.has('clafunction')) + clfunction = binding.get('clafunction').value.replaceAll(syntitNamespace, '') + var clocc = '' + if (binding.has('clocc')) + clocc = binding.get('clocc').value.replaceAll(hdnNamespace, '') //var clfunction=binding.get('clf').value.replace(syntitNamespace,'') //id del periodo - var sentenceid = binding.get('sentence').value.replace(hdnNamespace, '') + var sentenceid = '' + if (binding.has('sentence')) + sentenceid=binding.get('sentence').value.replace(hdnNamespace, '') if (pos > 0 && !result.has(pos)) { @@ -1917,7 +1922,15 @@ $(document).ready(function() { if (unitaRicerca != 'frase' && pos == -1) { unitaRicerca = 'frase' } - resultClauses.add(sentenceid + "-" + clfrom + '-' + clto + "-" + clfunction.trim().replace('ordinateClause', '').replace('MainClause', 'Ma') + '-' + cantica + '-' + canto + '-' + clocc) + if(clfunction.includes(';')){ + var funcs=clfunction.slice(0,-1).split(';') + var occs=clocc.slice(0,-1).split(';') + for (var mi=0; mi +PREFIX ecrm: +PREFIX hdn: +PREFIX lemon: +PREFIX orl: +PREFIX xsd: +PREFIX ontolex: +PREFIX olires: +PREFIX comm: +PREFIX syntit: + +SELECT (?t_canto as ?Canto) (?t_cantica as ?Cantica) ?clatype ?clafunction ?clfr ?clto ?cl ?sentence ?cltext ?pos ?clocc +WHERE { + FILTER(REGEX(?Rappresentazione, "^buon$", "i")) . + FILTER(LANGMATCHES(LANG(?Rappresentazione), "it")) + ###condizioni grammaticali + { + + ?form ontolex:writtenRep ?Rappresentazione. + ?lent ontolex:lexicalForm ?form; + ontolex:canonicalForm ?cf. + ?cf ontolex:writtenRep ?lm. + ?fa olires:occurrenceOf ?form; + olires:OccursInRegion ?reg . + ?reg olires:fragmentRegionFrom ?pos . + } + ###end + ###condizioni sintattiche + { + ?clocc olires:occurrenceOf ?cl ; + ecrm:P148_has_component ?fa ; #condizione join grammaticale sintattica + olires:occursInRegion ?frag . + + ?sentence a syntit:Sentence ; + ecrm:P148i_is_component_of ?canto; + syntit:hasSyntacticalComponent ?cl. + + ?cl syntit:hasClauseType ?clatype ; + ecrm:P190_has_symbolic_content ?cltext ; + syntit:hasClauseFunction ?clafunction. + + ?frag olires:fragmentRegionFrom ?clfr ; + olires:fragmentRegionTo ?clto . + } + ### end + ### condizioni comuni + + ?canto ecrm:P102_has_title ?t_canto; + olires:hasNumber ?num . + ?cantica ecrm:P102_has_title ?t_cantica; + olires:hasStructuralComponent ?canto. + # FILTER (?t_cantica in ("Inferno", "Purgatorio")) + # FILTER (?num IN ("12"^^xsd:short, "4"^^xsd:short ) ) + ### end + }` + +var ontoSparqlQueryMultCond = `PREFIX rdfs: +PREFIX ecrm: +PREFIX hdn: +PREFIX lemon: +PREFIX orl: +PREFIX xsd: +PREFIX ontolex: +PREFIX olires: +PREFIX comm: +PREFIX syntit: +PREFIX rdf: + +SELECT (?t_canto as ?Canto) (?t_cantica as ?Cantica) ?clatype ?clafunction ?clfr ?clto ?cl ?sentence ?pos ?clocc +WHERE { + FILTER(REGEX(?Rappresentazione, "^buon$", "i")) . + FILTER(LANGMATCHES(LANG(?Rappresentazione), "it")) + + ### condizioni + ?canto ecrm:P102_has_title ?t_canto; + olires:hasNumber ?num . + ?cantica ecrm:P102_has_title ?t_cantica; + olires:hasStructuralComponent ?canto. + ###condizioni end + ###condizioni sintattiche + { + ?clocc olires:occurrenceOf ?cl ; + ecrm:P148_has_component ?fa ; # join grammaticale sintattica + olires:occursInRegion ?frag . + + ?sentence a syntit:Sentence ; + ecrm:P148i_is_component_of ?canto; + syntit:hasSyntacticalComponent ?cl. + + ?cl syntit:hasClauseType ?clatype ; + ecrm:P190_has_symbolic_content ?cltext ; + syntit:hasClauseFunction ?clafunction. + + ?frag olires:fragmentRegionFrom ?clfr ; + olires:fragmentRegionTo ?clto . + #?frag olires:fragmentRegionFrom ?pos. + } + ###condizioni sintattiche end + BIND(COALESCE(?pos1,-1) AS ?pos) + }` + + +var ontoSparqlQuerySynt = ` +PREFIX ecrm: +PREFIX orl: +PREFIX ontolex: +PREFIX olires: +PREFIX syntit: +SELECT DISTINCT ?sentence ?clocc ?clfr ?clto ?clafunction ?clatype (?t_canto as ?Canto) (?t_cantica as ?Cantica) +WHERE { + FILTER regex(?Rappresentazione,"^persona$","i") . #remove if query_text=='' + FILTER langMatches(lang(?Rappresentazione),"it") #remove if query_text=='' + ?cat ontolex:writtenRep ?Rappresentazione . #remove if query_text=='' + ?lent ontolex:lexicalForm ?cat; #remove if query_text=='' + ontolex:canonicalForm ?cf. #remove if query_text=='' + ?cf ontolex:writtenRep ?lm. #remove if query_text=='' + ?fa olires:occurrenceOf ?cat . #remove if query_text=='' + ?clocc ecrm:P148_has_component ?fa . #remove if query_text=='' + ?cl syntit:hasClauseType ?clatype; + ecrm:P190_has_symbolic_content ?cltext; + syntit:hasClauseFunction ?clafunction. + ?clocc olires:occurrenceOf ?cl; + olires:occursInRegion ?frag. + ?frag olires:fragmentRegionFrom ?clfr; + olires:fragmentRegionTo ?clto. + ?sentence syntit:Sentence; + ecrm:P148i_is_component_of ?canto; + syntit:hasSyntacticalComponent ?cl. + ?cantica ecrm:P102_has_title ?t_cantica ; + olires:hasStructuralComponent ?canto . + ?canto ecrm:P102_has_title ?t_canto ; + olires:hasNumber ?num . + +} LIMIT 10000 + +` + +//colori per frasi sintattiche + + + +var colorssp = d3.scaleQuantize() + .domain([0, 17]) + .range(["#1f78b4", "#a6cee3", "#b2df8a", "#33a02c", "#fb9a99", "#e31a1c", "#fdbf6f", "#ff7f00", + "#cab2d6", "#6a3d9a", "#ffff99", "#b15928", "#F46D43", + "#D53E4F", "#9E0142", "#e377c2", "#7f7f7f", "#bcbd22"]); +/*.range(["#3288bd", "#66c2a5", "#e41a1c", "#4daf4a", "#984ea3", "#d53e4f", "#f46d43", "#ABDDA4", + "#E6F598", "#FFFFBF", "#FEE08B", "#FDAE61", "#F46D43", + "#D53E4F", "#9E0142", "#e377c2", "#7f7f7f", "#bcbd22"]);*/ + +const mapsynttypestopalette = { + "Ma": 0, "SubI": 1, "SubII": 3, "SubIII": 4, "Co": 5, "Co0": 2, + "CoI": 9, "CoII": 10, "SubIV": 5, "SubV": 6, "ParentethicalClause": 17, + "CoIII": 11, "ParentheticalCo": 14, "PseudoCo": 16, "SubVI": 7, "CoIV": 12, + "CoV": 13, "ParentheticalCoI": 15, "SubVII": 8 +} + +const maptypes = { + "Ma": "Principale", "SubI": "Subordinata I grado", "SubII": "Subordinata II grado", "SubIII": "Subordinata III grado", "Co": "Coordinata", + "CoI": "Coordinata I grado", "CoII": "Coordinata II grado", "SubIV": "Subordinata IV grado", "SubV": "Subordinata V grado", + "ParentethicalClause": "Parentetica", "CoIII": "Coordinata III grado", "ParentheticalCo": "Coordinata alla parentetica", + "PseudoCo": "Pseudo-coordinata", "SubVI": "Subordinata VI grado", "CoIV": "Coordinata IV grado", "CoV": "Coordinata V grado", + "ParentheticalCoI": "Coordinata alla parentetica I grado", "SubVII": "Subordinata VII grado" +} + + + +var orlprefix = 'https://dantenetwork.it/ontology/orl/current/' + +var syntitprefix = 'https://dantenetwork.it/ontology/syntit/current/' + +//var stringInSparql= false; + + + +function getFormaContext(formaid, numversi = 3) { + var context = [] + var cantica = 0; + var listaforme = formeprima; + var minpos = 0; + var limitv = Math.max((numversi), 3) + var maxpos = 0; + var offset = 0; + + + if (parseInt(formaid) < 33373) { + offset = parseInt(formaid) + } + + if (parseInt(formaid) > 33373 && parseInt(formaid) < 66588) { + listaforme = formeseconda; + cantica = 1; + offset = parseInt(formaid) - 33374 + + } + if (parseInt(formaid) > 66587 && parseInt(formaid) < 99314) { + listaforme = formeterza; + cantica = 2; + offset = parseInt(formaid) - 66588 + + } + if (parseInt(formaid) > 99314 || parseInt(formaid) < 0) { + return []; + } + + + + maxpos = listaforme.length - 1 + var pos = 0 + var startindex = Math.max(0, (offset - 25)) + + //console.log('Forma id: '+formaid+' startindex '+ startindex+' offset '+offset+' ('+cantica+')') + for (i = startindex; i < listaforme.length; i++) { + var tmpos = listaforme[i].split('_')[2] + if (tmpos == formaid) { + pos = i; + //console.log(' in pos: '+pos) + break; + } + } + + /*for (const [index, element] of listaforme.entries()) { + if(element.split('_')[2]==formaid){ + pos=index; + break; + } + + } + */ + var item = listaforme[pos].split('_'); + var numverso = item[3] + var spannum = (11 * limitv) + + var contextinf = Math.max(minpos, parseInt(pos) - spannum) + var contextsup = Math.min(maxpos, parseInt(pos) + spannum) + for (j = contextinf; j < contextsup + 1; j++) { + var tmpform = listaforme[j].split('_'); + if ((tmpform[3] > parseInt(numverso) - limitv) && (tmpform[3] < parseInt(numverso) + limitv)) { + var contextitem = {} + contextitem['testo'] = tmpform[0]; + contextitem['verso'] = tmpform[3]; + contextitem['canto'] = tmpform[1]; + contextitem['cantica'] = cantica; + contextitem['posizione'] = tmpform[2]; + contextitem['catg'] = tmpform[4]; + contextitem['periodo'] = cantica + '_' + tmpform[1] + '_s_' + tmpform[5]; + contextitem['funzperiodo'] = tmpform[6]; + context.push(contextitem); + } + } + return context; + +} + +// the basic initial query is parsed + +function gimmespq() { + var SparqlParser = sparqljs.Parser; + var parser = new SparqlParser(); + return parser.parse(ontoSparqlQuery); + + +} + +// the query is transformed according the form values + +function gimmespqfromjson(form) { + const sparqlgen = sparqljs.Generator; + const generator = new sparqlgen({ orl: "http://www.w3.org/2000/01/rdf-schema#" }) + const parsedquery = gimmespq() + if (form.categoria.value != 'all') + parsedquery.where[0].triples.push(JSON.parse(data21)[form.categoria.value]); + if (form.query.value != "") + switch (form.tipo.value) { + case 'parola': + parsedquery.where[1].expression.args[1].value = "^" + form.query.value + "$"; + break; + case 'sottostringa': + parsedquery.where[1].expression.args[1].value = form.query.value; + break; + case 'prefisso': + parsedquery.where[1].expression.args[1].value = form.query.value; + break; + case 'suffisso': + parsedquery.where[1].expression.args[1].value = form.query.value + "$"; + break; + default: + parsedquery.where[1].expression.args[1].value = "^" + form.query.value + "$"; + }; + return generator.stringify(parsedquery); + +} + +function getStatements() { + + return data21 + +} + + +var theguiQ = '' +var multipleCondSpQuery = '' +var bindConcatStatement='' +var occBindConcatStatement='' +var conditions = [] +var filters = [] +var unionop = `{"union": {"type": "union", "patterns":[]}, "bgp": {"type": "bgp", "triples":[]}, "group": {"type": "group", "patterns":[]}}` + + + +function parseJsonClause(op, tokens, nowhere) { + //alert(op) + var idp = -1 + if (nowhere[0].type == 'filter' && nowhere[0].expression.args[0].value == 'Rappresentazione') { + //nowhere.splice(0, 1) + nowhere.splice(0, 2) + } + if (op.trim() == 'OR') { + + //nowhere.splice(1, 0, JSON.parse(unionop)['union']) + nowhere.splice(0, 0, JSON.parse(unionop)['union']) + //idp = 1 + idp = 0 + } + if (op.trim() == 'AND') { + + //nowhere.splice(1, 0, JSON.parse(unionop)['group']) + nowhere.splice(0, 0, JSON.parse(unionop)['group']) + //idp = 1 + idp = 0 + + } + for (var mtoken in tokens) { + te_op = tokens[mtoken] + if ('TERM' in te_op) { + cond = theguiQ[te_op['TERM']] + //mywhere=nowhere[idp].patterns; + multipleCondSpQuery = buildStatementClause(cond, multipleCondSpQuery, -1, nowhere[idp].patterns, mtoken) + + } + else + parseJsonClause(Object.keys(te_op)[0], te_op[Object.keys(te_op)[0]], nowhere.at(-1).patterns) + + } + +} + + +//MULTIPLE CONDITIONS +function buildSPQuery(guiquery) { + theguiQ = ''; + theguiQ = guiquery; + var SparqlParser = sparqljs.Parser; + var spqparser = new SparqlParser(); + if (theguiQ['unitaRicerca']=='periodo') {//Multiple Conditions UR=Periodo + multipleCondSpQuery = spqparser.parse(sentencetargetquery); + bindConcatStatement=JSON.parse(sentencetarget_functionbind); + occBindConcatStatement=JSON.parse(sentencetarget_occbind); + + } + else + multipleCondSpQuery = spqparser.parse(ontoSparqlQueryMultCond); + var parser = peg.generate(hdnquerygrammar); + test = guiquery['EsprLogica'].join(" "); + test = test.replaceAll("( ", "(") + test = test.replaceAll(" )", ")") + clauses = parser.parse(test); + jsonclauses = JSON.parse(clauses) + + for (const ck of Object.keys(jsonclauses)) { + parseJsonClause(ck, jsonclauses[ck], multipleCondSpQuery.where) + + } + if (theguiQ['unitaRicerca']=='periodo') { + multipleCondSpQuery.where.push(bindConcatStatement) + multipleCondSpQuery.where.push(occBindConcatStatement) + } + +} + +//BUILD THE QUERY! + +function buildSQ(stquery) { + + var filtroContesto; + stringInSparql = false; + var SparqlParser = sparqljs.Parser; + var parser = new SparqlParser(); + //Prendo la query SPARQL template + var parsedquery = parser.parse(ontoSparqlQuery); + console.log(stquery) + + if (stquery['QueryAvanzata'] == 1 && stquery['EsprLogica'] != null && stquery['EsprLogica'].length > 1) { + //parsedquery = parser.parse(ontoSparqlQueryMultCond) + buildSPQuery(stquery) + return multipleCondSpQuery; + } + + if (stquery['QueryAvanzata'] == 1 && stquery['EsprLogica'] != null && stquery['EsprLogica'] != '' && stquery['EsprLogica'].length == 1) { + clause = stquery['EsprLogica'] + + filtroContesto=getFiltroContestoJson(JSON.parse(stquery[clause[0]]['contesto'])) + if (stquery[clause]['TipoClausola'] == 'Sintattico') { + parsedquery = parser.parse(ontoSparqlQuerySynt); + var tempsyntquery=buildSintacticClause(stquery[clause], parsedquery, 2) + if (filtroContesto.length>0){ + for (tmpc of filtroContesto){ + + tempsyntquery.where.splice(0, 0, tmpc) + } + } + return tempsyntquery + } + + myquery = buildClause(stquery[clause], parsedquery, 2) + if (filtroContesto.length>0){ + for (tmpc of filtroContesto){ + console.log(filtroContesto[0]) + myquery.where.splice(1, 0, tmpc) + } + //myArray[0] = myArray.splice(1, 1, myArray[0])[0]; + //let tw=myquery.where[4] + //myquery.where[4]=myquery.where[3] + //myquery.where[3]=tw + if (stquery[clause]['queryText'].trim() == "") { + if (myquery.where[0].type == 'filter') + myquery.where.splice(0, 1) + } + + } + return (myquery) + } + //Simple query + + filtroContestoJson=getFiltroContestoJson(JSON.parse(stquery['Clausola0']['contesto'])) + if (filtroContestoJson.length>0){ + for (tmpc of filtroContestoJson){ + //console.log(filtroContesto[0]) + parsedquery.where.splice(1, 0, tmpc) + } + + + } + + if (stquery['Clausola0']['queryText'] != "" && stquery['Clausola0']['Attiva'] == 1) { + searchtext = stquery['Clausola0']['queryText'] + let strval = searchtext + + if (stquery['Clausola0']['opzioni_testo'] == 'parola') { + strval = "^" + searchtext.trim() + "$"; + } + if (stquery['Clausola0']['opzioni_testo'] == 'sottostringa') { + strval = searchtext.trim(); + } + if (stquery['Clausola0']['opzioni_testo'] == 'suffisso') { + strval = searchtext.trim() + "$"; + } + if (stquery['Clausola0']['opzioni_testo'] == 'prefisso') { + strval = "^" + searchtext.trim(); + } + + + + + parsedquery.where[0].expression.args[1].value = strval; + if (stquery['Clausola0']['lemma_forma'] == 'lemma'){ + parsedquery.where[0].expression.args[0].value = "lm"; + parsedquery.where.splice(1, 1) + parsedquery.where[1].patterns[0].triples.splice(0,1) + } + + } + else { + console.log('Simple query, no param') + parsedquery.where.splice(0, 1) + } + + return (parsedquery) + +} + + + +//Filtro Contesto + + +function getFiltroContestoJson(datiContesto) { + var cantica = 0; + var canticheids= new Set () + for (contestoCantica of datiContesto) { + var contextids=[] + cantica++; + for (const [index, element] of contestoCantica.entries()) { + if (element == 1){ + //console.log('Cantica ' + cantica + ', Canto ' + (parseInt(index) + 1)); + contextids.push (parseInt(index) + 1) + } + } + if (contextids.length>0){ + canticheids[cantica]=contextids + } + } + + if (Object.keys(canticheids).length > 0){ + + //console.log(JSON.stringify(canticheids)) + var test=buildFilterContextJson (canticheids) + + return (test) + } + else + return [] +} + +function buildStatementClause(clause, parsedquery, whereind, theplace, token) { + // + if (clause['TipoClausola'] == "Sintattico") { + if (theguiQ['unitaRicerca']=='periodo') + tmpgroup=JSON.parse(sentencetarget_syntgroup) + else + tmpgroup = JSON.parse(syntgroup) + } + else tmpgroup = JSON.parse(morphgroup); + + if (clause['queryText'] != null && clause['queryText'].trim() != "") { + //theplace.push(JSON.parse(unionop)['group']); + + var stmt = buildFilterStatement(clause['lemma_forma'], clause['queryText'].trim(), clause['opzioni_testo']) + tmpgroup.patterns.push(stmt) + tmpgroup.patterns.push(JSON.parse(unionop)['bgp']); + tmpgroup.patterns.at(-1).triples.push(JSON.parse(writtenrepresentation)) + } + if (clause['typeGramm0'] != null && clause['typeGramm0'] != "all") + if (whereind > -1) + parsedquery.where[whereind].triples.push(JSON.parse(data21)[clause['typeGramm0']]); + else { + tmpgroup.patterns.push(JSON.parse(unionop)['bgp']); + tmpgroup.patterns.at(-1).triples.push(JSON.parse(data21)[clause['typeGramm0']]); + + } + + if (clause['typeGramm0'] != null && Object.keys(sottoCategorie).includes(clause['typeGramm0'].trim())) { + + sctmp = sottoCategorie[clause['typeGramm0'].trim()] + sctk = Object.keys(sctmp) + for (ke in sctk) { + + keval = clause[sctk[ke]] + if (keval != null && keval != '') { + sttmts = sctmp[sctk[ke]] + if (sttmts[keval] != null && (sttmts[keval].split(':')[1]) != null) { + subcatstat = buildsubcategoryClause(sttmts[keval]) + if (whereind > -1) + parsedquery.where[whereind].triples.push(subcatstat); + else + //theplace.at(-1).triples.push(subcatstat); + tmpgroup.patterns.at(-1).triples.push(subcatstat); + } + } + } + } + if (clause['TipoClausola'] == "Sintattico") { + tmpgroup.patterns.push(JSON.parse(unionop)['bgp']); + var functS = clause['functionSyntax']; + var typeS = clause['typeSyntax0'] + console.log(functS + ' ' + typeS) + var myf ='' + if (functS != null && functS != ".+") { + myf = buildsyntClause(funzione_clausola[functS]) + if (myf != '') + tmpgroup.patterns.at(-1).triples.push(myf) + } + if (typeS != null && typeS != ".+") { + var alltipi = Object.assign(macrotipi_sint, tipi_sint); + let mymt=alltipi[typeS] + //let mymt=macrotipi_sint[typeS] + if(listaMacroTipiConSubTipo.includes(mymt.split(':')[1])){ + let myfa=buildMacroSyntType(mymt) + for (fa in myfa){ + //tmpgroup.patterns.at(-1).triples.push(myfa[fa]) + tmpgroup.patterns.push(myfa[fa]) + } + } + else{ + var tmptr=alltipi[typeS].split(';') + for (indttr in tmptr){ + myf = buildsyntClause(tmptr[indttr]) + if (myf != '') + tmpgroup.patterns.at(-1).triples.push(myf) + } + + } + + } + if (theguiQ['unitaRicerca']=='periodo'){ + mytest=JSON.stringify(tmpgroup) + mytest=mytest.replaceAll(':"cl"', ':"cl'+token+'"') + mytest=mytest.replaceAll(':"clatype"', ':"clatype'+token+'"') + mytest=mytest.replaceAll(':"clafunction"', ':"clafunction'+token+'"') + var mystrb=`{ + "type": "operation", + "operator": "str", + "args": [ + { + "termType": "Variable", + "value": "clafunction`+token+`" + } + ] + } + ` + bindConcatStatement['expression']['args'].push(JSON.parse(mystrb)) + mystrb=`{ + "type": "operation", + "operator": "str", + "args": [ + { + "termType": "Variable", + "value": "cl`+token+`" + } + ] + } + ` + occBindConcatStatement['expression']['args'].push(JSON.parse(mystrb)) + mystrb=`{ + "termType": "Literal", + "value": ";", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#string" + } + }` + bindConcatStatement['expression']['args'].push(JSON.parse(mystrb)) + occBindConcatStatement['expression']['args'].push(JSON.parse(mystrb)) + tmpgroup=JSON.parse(mytest) + + + } + } + + theplace.push(tmpgroup) + + return parsedquery + +} + + + +function buildSintacticClause(clause, parsedquery, whereind) { + + if (clause['queryText'].trim() != "") { + + var strval = getStringFilter(clause['queryText'].trim(), clause['opzioni_testo']) + parsedquery.where[0].expression.args[1].value = strval; + if (clause['lemma_forma'] == 'lemma') + parsedquery.where[0].expression.args[0].value = "lm"; + } + else { + if (parsedquery.where[0].type == 'filter' && parsedquery.where[0].expression.args[0].value == 'Rappresentazione') + //remove the filter for text CHANGE! + parsedquery.where.splice(0, 1) + parsedquery.where.splice(0, 1) + parsedquery.where[0].triples.splice(5, 1) + parsedquery.where[0].triples.splice(4, 1) + parsedquery.where[0].triples.splice(3, 1) + parsedquery.where[0].triples.splice(2, 1) + parsedquery.where[0].triples.splice(1, 1) + parsedquery.where[0].triples.splice(0, 1) + whereind = whereind - 1 + } + + + var functS = clause['functionSyntax']; + var typeS = clause['typeSyntax0'] + console.log(functS + ' ' + typeS) + if (functS != null && functS != ".+") { + //console.log('functS '+funzione_clausola['princ']) + var myf = buildsyntClause(funzione_clausola[functS]) + + if (myf == '') + return parsedquery + parsedquery.where.at(-1).triples.push(myf); + } + if (typeS != null && typeS != ".+") { + var alltipi = Object.assign(macrotipi_sint, tipi_sint); + let mymt=alltipi[typeS] + if(listaMacroTipiConSubTipo.includes(mymt.split(':')[1])){ + let myfa=buildMacroSyntType(mymt) + for (fa in myfa){ + //parsedquery.where.at(-1).triples.push(myfa[fa]) + parsedquery.where.push(myfa[fa]) + } + } + else{ + + var tmptr=macrotipi_sint[typeS].split(';') + for (indttr in tmptr){ + myf = buildsyntClause(tmptr[indttr]) + if (myf != '') + parsedquery.where.at(-1).triples.push(myf) + } + } + + + } + return parsedquery +} + +function buildClause(clause, parsedquery, whereind) { + + if (clause['TipoClausola'] == 'Sintattico') + return buildSintacticClause(clause, parsedquery, whereind) + + + + if (clause['typeGramm0'] != null && clause['typeGramm0'] != "all") + if (whereind > -1) + //parsedquery.where[whereind].triples.push(JSON.parse(data21)[clause['typeGramm0']]); + parsedquery.where[2].patterns[0].triples.splice(0, 0, JSON.parse(data21)[clause['typeGramm0']]); + else { + parsedquery.where.at(-1).patterns.push(JSON.parse(unionop)['bgp']); + parsedquery.where.at(-1).patterns.at(-1).triples.push(JSON.parse(data21)[clause['typeGramm0']]); + } + + + if (clause['typeGramm0'] != null && Object.keys(sottoCategorie).includes(clause['typeGramm0'].trim())) { + //sctmp=JSON.parse(sottoCategorieSostantivi) + sctmp = sottoCategorie[clause['typeGramm0'].trim()] + sctk = Object.keys(sctmp) + for (ke in sctk) { + + keval = clause[sctk[ke]] + if (keval != null && keval != '') { + sttmts = sctmp[sctk[ke]] + if (sttmts[keval] != null && (sttmts[keval].split(':')[1]) != null) { + subcatstat = buildsubcategoryClause(sttmts[keval]) + if (whereind > -1) + parsedquery.where[2].patterns[0].triples.push(subcatstat); + else + parsedquery.where.at(-1).patterns.at(-1).triples.push(subcatstat); + } + } + } + } + + if (clause['queryText'].trim() != "") { + + var strval = getStringFilter(clause['queryText'].trim(), clause['opzioni_testo']) + parsedquery.where[0].expression.args[1].value = strval; + if (clause['lemma_forma'] == 'lemma') + parsedquery.where[0].expression.args[0].value = "lm"; + } + else { + if (parsedquery.where[0].type == 'filter' && parsedquery.where[0].expression.args[0].value == 'Rappresentazione') + parsedquery.where.splice(0, 1) + whereind = whereind - 1 + } + + return parsedquery + +} + +function getStringFilter(filter, opzione) { + var strval = "^" + filter.trim() + "$"; + if (opzione != "") + switch (opzione) { + case 'parola': + strval = "^" + filter.trim() + "$"; + break; + case 'sottostringa': + strval = filter.trim(); + break; + case 'prefisso': + strval = "^" + filter.trim(); + break; + case 'suffisso': + strval = filter.trim() + "$"; + break; + default: + strval = "^" + filter.trim() + "$"; + + }; + return (strval) +} +//costruzione filtri per query + +//filtri contesto +function buildFilterContextJson( contextcantiche) { + var resfilters=[] + + var contextgroup = ` { + "type": "group", + "patterns": [ + { + "type": "bgp", + "triples": [ + {"subject": {"termType": "Variable","value": "cantica"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P102_has_title"}, + "object": {"termType": "Variable","value": "t_cantica"}}, + {"subject": {"termType": "Variable","value": "cantica"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/hasStructuralComponent"}, + "object": {"termType": "Variable","value": "canto"}}, + {"subject": {"termType": "Variable","value": "canto"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/hasNumber"}, + "object": {"termType": "Variable","value": "num"}} + + ] + } + ] + } + +` + + var filtercontexttemplate = `{ + "type": "filter", + "expression": { + "type": "operation", + "operator": "in", + "args": [ + { + "termType": "Variable", + "value": "num" + } + ] + } + }` + + var filtercontextcantichetemplate = `{ + "type": "filter", + "expression": { + "type": "operation", + "operator": "in", + "args": [ + { + "termType": "Variable", + "value": "t_cantica" + } + ] + } + }` + + var itemcontexttemplate = ` + { + "termType": "Literal", + "value": "na", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#short" + } + }` + var canticacontexttemplate= ` + { + "termType": "Literal", + "value": "na", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#string" + } + }` + + + var canticheliteral=['Inferno', 'Purgatorio', 'Paradiso'] + + for (var ky in contextcantiche){ + var contextfilter=[] + var cantichecontextfilter=[] + var cgroup=JSON.parse(contextgroup) + if(contextcantiche.hasOwnProperty(ky)){ + ///console.log(`test ${ky} : ${contextcantiche[ky]}`) + + var cfilter=JSON.parse(canticacontexttemplate); + + cfilter['value']=canticheliteral[ky-1] + cantichecontextfilter.push(cfilter) + for (var kval in contextcantiche[ky]){ + //console.log(contextcantiche[ky][kval]) + var myfilter= JSON.parse(itemcontexttemplate); + myfilter['value']=contextcantiche[ky][kval].toString() + contextfilter.push(myfilter) + } + } + if (contextfilter.length>0){ + var filters=JSON.parse(filtercontexttemplate) + var cantichefilters=JSON.parse(filtercontextcantichetemplate) + filters['expression']['args'].push(contextfilter) + + //resfilters.push(filters) + cgroup.patterns.splice(0,0,filters) + cantichefilters['expression']['args'].push(cantichecontextfilter) + + cgroup.patterns.splice(0,0, cantichefilters) + resfilters.push(cgroup) + } + + } + var uniontmp=`{"type": "union", "patterns":[]}` + var tmpres=[] + jsunion=JSON.parse(uniontmp) + if (resfilters.length>1){ + + for (filter in resfilters){ + jsunion.patterns.push(resfilters[filter]) + } + tmpres.push(jsunion) + return (tmpres) + } + if (resfilters.length>0){ + + tmpres.push(resfilters[0].patterns[1]) + tmpres.push(resfilters[0].patterns[0]) + } + return (tmpres) + +} + + +function buildFilterStatement(target, filter, opzione) { + + var filtertemplate = `{ + "type": "filter", + "expression": { + "type": "operation", + "operator": "regex", + "args": [ + { + "termType": "Variable", + "value": "Rappresentazione" + }, + { + "termType": "Literal", + "value": "^andare$", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#string" + } + }, + { + "termType": "Literal", + "value": "i", + "language": "", + "datatype": { + "termType": "NamedNode", + "value": "http://www.w3.org/2001/XMLSchema#string" + } + } + ] + } +}` + + + var statement = JSON.parse(filtertemplate) + /* + if (filter.trim().slice(-1) !== '*') + strval = "^" + filter.trim() + "$"; + else + strval = filter.trim().slice(0, -1) + */ + var strval = getStringFilter(filter, opzione); + + statement.expression.args[1].value = strval; + if (target == 'lemma') + statement.expression.args[0].value = "lm"; + + return (statement) +} + + + //"hasClauseType:Comparativa" + // + //?cl syntit:hasClauseType ?tipoSint . + //?tipoSint rdf:type syntit:ClauseSubType ; + // ecrm:P127_has_broader_term syntit:Comparativa . + +function buildMacroSyntType(sttmnt){ + var uniontmpms=`{"type": "union", "patterns":[]}` + var trm1=`{ + "type": "bgp", + "triples": + [ + {"subject": {"termType": "Variable","value": "cl"}, + "predicate": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/hasClauseType"}, + "object": {"termType": "Variable","value": "tipoSint"}}, + {"subject": {"termType": "Variable","value": "tipoSint"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, + "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/ClauseSubType"}}, + {"subject": {"termType": "Variable","value": "tipoSint"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P127_has_broader_term"}, + "object": {"termType": "NamedNode"}} + + ] + }` + var tmplate = `{"subject": {"termType": "Variable", "value":"cl"}, + "predicate": {"termType":"NamedNode"}, + "object": {"termType": "NamedNode"}}` + + var t1m= `{"subject": {"termType": "Variable","value": "cl"}, + "predicate": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/hasClauseType"}, + "object": {"termType": "Variable","value": "tipoSint"}}` + var t2m= `{"subject": {"termType": "Variable","value": "tipoSint"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, + "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/ClauseSubType"}}` + var t3m= `{"subject": {"termType": "Variable","value": "tipoSint"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P127_has_broader_term"}, + "object": {"termType": "NamedNode"}}` + var res=[] + + + + var obj = syntitprefix + (sttmnt.split(':')[1]) + + var predicate = syntitprefix + (sttmnt.split(':')[0]) + + var statement = JSON.parse(tmplate) + + statement['predicate']['value'] = predicate + statement['object']['value'] = obj + + var grstmt=JSON.parse(trm1) + grstmt['triples'][2]['object']['value']=obj + + var unionst=JSON.parse(uniontmpms) + unionst['patterns'].push(grstmt) + unionst['patterns'].push(statement) + res.push(unionst) + //var statement = JSON.parse(t3m) + //statement['object']['value'] = obj + //res.push(JSON.parse(t1m)) + //res.push(JSON.parse(t2m)) + //res.push(statement) + return res +} + +function buildsyntClause(sttmnt) { + + + var tmplate = `{"subject": {"termType": "Variable", "value":"cl"}, + "predicate": {"termType":"NamedNode"}, + "object": {"termType": "NamedNode"}} + ` + + + console.log(sttmnt) + + var predicate = syntitprefix + (sttmnt.split(':')[0]) + var obj = syntitprefix + (sttmnt.split(':')[1]) + var statement = JSON.parse(tmplate) + + statement['predicate']['value'] = predicate + statement['object']['value'] = obj + + return (statement) + +} + +function buildsubcategoryClause(sttmnt) { + + subcattmplate = `{"subject": {"termType": "Variable", "value":"form"}, + "predicate": {"termType":"NamedNode"}, + "object": {"termType": "NamedNode"}} + ` + + predicate = orlprefix + (sttmnt.split(':')[0]) + obj = orlprefix + (sttmnt.split(':')[1]) + subcatstatement = JSON.parse(subcattmplate) + + subcatstatement['predicate']['value'] = predicate + subcatstatement['object']['value'] = obj + + return (subcatstatement) + +} +//GESTIONE CITAZIONI/COMMENTI +//return JSON object +function getVersiConCitazioniJson(canticapar='', cantopar=''){ + let citcantiche=['Inferno','Purgatorio','Paradiso'] + if (canticapar==''){ + citazioni.map(function(item) { + console.log(item['Cantica']+', '+item['Canto']+', '+item['Verso'].split('-')[0]); + }) + return + } + var citazionitemp={} + citazioni.map(function(item) { + if (item['Cantica']==canticapar && item['Canto']==cantopar){ + + let tca=item['Canto'] + if (tca.startsWith('0')) + tca=tca.replace('0','') + let citid=(citcantiche.indexOf(item['Cantica'])+1).toString()+'_'+tca+'_'+item['Verso']//.split('-')[0] + //console.log(citid) + var commentsItem = {} + commentsItem['verso'] = citid; + commentsItem['annotazione'] = item['Annotazione']; + commentsItem['commentario'] = item['Commentario']; + commentsItem['frammentoNota'] = item['FrammentoNota']; + //commentsItem['AutoreCitazione'] = item['InfoCitazione.Autore']; + commentsItem['AutoreCitazione'] = item['AC']; + //commentsItem['FonteCitazione'] = item['InfoCitazione.Fonte']; + commentsItem['FonteCitazione'] = item['F']; + //commentsItem['LuogoFonteCitazione'] = item['InfoCitazione.LuogoFonte']; + commentsItem['LuogoFonteCitazione'] = item['LF']; + //commentsItem['NotaFonteCitazione'] = item['InfoCitazione.NotaFonte']; + commentsItem['NotaFonteCitazione'] = item['NF']; + //commentsItem['TestoFonteCitazione'] = item['InfoCitazione.TestoFonte']; + commentsItem['TestoFonteCitazione'] = item['TF']; + //commentsItem['URLFonteCitazione'] = item['InfoCitazione.UrlFonte']; + commentsItem['URLFonteCitazione'] = item['UF']; + commentsItem['NaturaRiferimento'] = item['NaturaRiferimento']; + commentsItem['RapportoCommentoCommentatoreText'] = item['RCC']; + //commentsItem['RapportoSoggettoOggetto'] = item['RapportoSoggettoOggetto']; + commentsItem['RapportoSoggettoOggetto'] = item['RSO']; + commentsItem['NomeAutoreCitazione'] = item['NomeAutore']; + commentsItem['TitoloFonteCitazione'] = item['TitoloFonte']; + commentsItem['VersoCitazione'] = item['Verso']; + + if (item['AutoreCitazione']==''){ + commentsItem['AutoreCitazione'] ='autore' + } + + if (item['TipoDiCitazione']=='no'){ + commentsItem['TipoCitazione'] ='' + } + else{ + commentsItem['TipoCitazione'] =item['TipoDiCitazione'] + } + //'CEP', 'CIM', 'CTE', 'CMO', 'CST', 'CTO' + + if (item['CEP']=='no'){ + commentsItem['CitEpisodi'] ='' + } + else{ + commentsItem['CitEpisodi'] =item['CEP'] + } + + if (item['CIM']=='no'){ + commentsItem['CitImmagini'] ='' + } + else{ + commentsItem['CitImmagini'] =item['CIM'] + } + + if (item['CTE']=='no'){ + commentsItem['CitTeorie'] ='' + } + else{ + commentsItem['CitTeorie'] =item['CTE'] + } + + if (item['CMO']=='no'){ + commentsItem['CitMotivi'] ='' + } + else{ + commentsItem['CitMotivi'] =item['CMO'] + } + + if (item['CST']=='no'){ + commentsItem['CitStilemi'] ='' + } + else{ + commentsItem['CitStilemi'] =item['CST'] + } + + if (item['CTO']=='no'){ + commentsItem['CitTopografie'] ='' + } + else{ + commentsItem['CitTopografie'] =item['CTO'] + } + + if (citazionitemp.hasOwnProperty(citid)){ + citazionitemp[citid].push(commentsItem) + } + else{ + var tmpar=[] + tmpar.push(commentsItem) + citazionitemp[citid]=tmpar + } + } + + }) + console.log(citazionitemp) + return citazionitemp; +} + +function getVersiConCitazioni(canticapar='', cantopar=''){ + let citcantiche=['Inferno','Purgatorio','Paradiso'] + if (canticapar==''){ + citazioni.map(function(item) { + console.log(item['Cantica']+', '+item['Canto']+', '+item['Verso'].split('-')[0]); + }) + return + } + var citazionitemp=[] + citazioni.map(function(item) { + if (item['Cantica']==canticapar && item['Canto']==cantopar){ + //versi.push(item['Verso']) + //console.log(item['Cantica']+', '+item['Canto']+', '+item['Verso']); + + //console.log(citcantiche.indexOf(item['Cantica'])+1); + //console.log(item['Canto']); + tca=item['Canto'] + if (tca.startsWith('0')) + tca=tca.replace('0','') + citid=(citcantiche.indexOf(item['Cantica'])+1).toString()+'_'+tca+'_'+item['Verso'].split('-')[0] + //console.log(citid) + var commentsItem = {} + commentsItem['verso'] = citid; + commentsItem['annotazione'] = item['Annotazione']; + commentsItem['commentario'] = item['Commentario']; + commentsItem['frammentoNota'] = item['FrammentoNota']; + //commentsItem['AutoreCitazione'] = item['InfoCitazione.Autore']; + commentsItem['AutoreCitazione'] = item['AC']; + //commentsItem['FonteCitazione'] = item['InfoCitazione.Fonte']; + commentsItem['FonteCitazione'] = item['F']; + //commentsItem['LuogoFonteCitazione'] = item['InfoCitazione.LuogoFonte']; + commentsItem['LuogoFonteCitazione'] = item['LF']; + //commentsItem['NotaFonteCitazione'] = item['InfoCitazione.NotaFonte']; + commentsItem['NotaFonteCitazione'] = item['NF']; + //commentsItem['TestoFonteCitazione'] = item['InfoCitazione.TestoFonte']; + commentsItem['TestoFonteCitazione'] = item['TF']; + //commentsItem['URLFonteCitazione'] = item['InfoCitazione.UrlFonte']; + commentsItem['URLFonteCitazione'] = item['UF']; + commentsItem['NaturaRiferimento'] = item['NaturaRiferimento']; + //commentsItem['RapportoCommentoCommentatoreText'] = item['RapportoCommentoCommentatoreText']; + commentsItem['RapportoCommentoCommentatoreText'] = item['RCC']; + //commentsItem['RapportoSoggettoOggetto'] = item['RapportoSoggettoOggetto']; + commentsItem['RapportoSoggettoOggetto'] = item['RSO']; + commentsItem['NomeAutoreCitazione'] = item['NomeAutore']; + commentsItem['TitoloFonteCitazione'] = item['TitoloFonte']; + commentsItem['VersoCitazione'] = item['Verso']; + + if (item['AutoreCitazione']==null){ + commentsItem['AutoreCitazione'] ='autore' + } + + if (item['TipoDiCitazione']=='no'){ + commentsItem['TipoCitazione'] ='' + } + else{ + commentsItem['TipoCitazione'] =item['TipoDiCitazione'] + } + //'CEP', 'CIM', 'CTE', 'CMO', 'CST', 'CTO' + + if (item['CEP']=='no'){ + commentsItem['CitEpisodi'] ='' + } + else{ + commentsItem['CitEpisodi'] =item['CEP'] + } + + if (item['CIM']=='no'){ + commentsItem['CitImmagini'] ='' + } + else{ + commentsItem['CitImmagini'] =item['CIM'] + } + + if (item['CTE']=='no'){ + commentsItem['CitTeorie'] ='' + } + else{ + commentsItem['CitTeorie'] =item['CTE'] + } + + if (item['CMO']=='no'){ + commentsItem['CitMotivi'] ='' + } + else{ + commentsItem['CitMotivi'] =item['CMO'] + } + + if (item['CST']=='no'){ + commentsItem['CitStilemi'] ='' + } + else{ + commentsItem['CitStilemi'] =item['CST'] + } + + if (item['CTO']=='no'){ + commentsItem['CitTopografie'] ='' + } + else{ + commentsItem['CitTopografie'] =item['CTO'] + } + + citazionitemp.push(commentsItem) + } + + }) + return citazionitemp; +} + + +//TEMPORANEAMENTE: gestione del grafo quando viene chiusa la finestra dal bottone, dovebbe essere spostato +const myiframe = document.getElementsByClassName("minimap__content"); +function resetGraphStruct(){ + + var periodograph=document.getElementById("periodograph"); + if (periodograph!=null){ + let showngr=document.getElementById("periodograph").getAttribute('name').split("_") + var tmpsent=showngr[0]+"_"+showngr[1]+"_s_"+showngr[2] + periodograph.parentNode.removeChild(periodograph); + + //var sentence = document.getElementsByClassName(lsentid); + var sentence = document.getElementsByClassName(tmpsent); + + for (let i = 0; i < sentence.length; i++) { + //var matches = listaClausoleRisultato.filter(s => s.includes(sentence[i].classList[0])); + sentence[i].classList.remove('font-italic'); + if (selectedVista!='frasi' && !listaPeriodiRisultato.includes(tmpsent)) + sentence[i].style.removeProperty('color'); + + sentence[i].classList.remove('font-weight-normal'); + + } + + //reset Minimap + + var iframeDocument = myiframe[0].contentDocument || myiframe[0].contentWindow.document; + if (!iframeDocument) { + throw "iframe couldn't be found in DOM."; + } + var iframeSentence = iframeDocument.getElementsByClassName(tmpsent); + for (let i = 0; i < iframeSentence.length; i++) { + iframeSentence[i].classList.remove('font-italic'); + if (selectedVista!='frasi') + iframeSentence[i].style.removeProperty('color'); + + iframeSentence[i].classList.remove('font-weight-normal'); + } + + emptyStructCard() + + if (tmpsent==lsentid){ + + return true + } + + return false + + } +} +//end + +var sottoCategorie = { + "verbovolgare": { + "Diatesi": { "Attivo": "TipoDiatesiVerboVolgare:VerboVolgareAttivo", "Passivo": "TipoDiatesiVerboVolgare:VerboVolgarePassivo" }, + "Transitivita": { "Intransitivo": "TipoTransitivitàVerboVolgare:VerboVolgareIntransitivo", "Transitivo": "TipoTransitivitàVerboVolgare:VerboVolgareTransitivo" }, + "Genere": { "Femminile": "TipoGenereVerboVolgare:GenereFemminileVerboVolgare", "Maschile": "TipoGenereVerboVolgare:GenereMaschileVerboVolgare" }, + "Numero": { "Singolare": "TipoNumeroVerboVolgare:NumeroSingolareVerboVolgare", "Plurale": "TipoNumeroVerboVolgare:NumeroPluraleVerboVolgare" }, + "Pers": { "Impersonale": "VerboVolgareImpersonale:VerboVolgareImpersonale" }, + "Rifl": { "Riflessivo": "VerboVolgareRiflessivo:VerboVolgareRiflessivo" }, + "Coniugazione": { + "Prima coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgarePrimaConiugazione", "Seconda coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareSecondaConiugazione", + "Terza coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareTerzaConiugazione", + "Essere coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareAusiliareEssere", + "Avere coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareAusiliareAvere" + }, + "Tempi": { + "Indicativo presente": "TipoTempoVerboVolgare:PresenteIndicativoVerboVolgare", "Indicativo passato prossimo": "TipoTempoVerboVolgare:PassatoProssimoIndicativoVerboVolgare", + "Indicativo imperfetto": "TipoTempoVerboVolgare:ImperfettoIndicativoVerboVolgare", "Indicativo passato remoto": "TipoTempoVerboVolgare:PassatoRemotoIndicativoVerboVolgare", + "Indicativo trapassato prossimo": "TipoTempoVerboVolgare:TrapassatoProssimoIndicativoVerboVolgare", "Indicativo trapassato remoto": "TipoTempoVerboVolgare:TrapassatoRemotoIndicativoVerboVolgare", + "Indicativo futuro semplice": "TipoTempoVerboVolgare:FuturoSempliceIndicativoVerboVolgare", "Indicativo futuro anteriore": "TipoTempoVerboVolgare:FuturoAnterioreIndicativoVerboVolgare", + "Congiuntivo presente": "TipoTempoVerboVolgare:PresenteCongiuntivoVerboVolgare", "Congiuntivo imperfetto": "TipoTempoVerboVolgare:ImperfettoCongiuntivoVerboVolgare", + "Congiuntivo passato": "TipoTempoVerboVolgare:PassatoCongiuntivoVerboVolgare", "Congiuntivo trapassato": "TipoTempoVerboVolgare:TrapassatoCongiuntivoVerboVolgare", + "Condizionale presente": "TipoTempoVerboVolgare:PresenteCondizionaleVerboVolgare", "Condizionale passato": "TipoTempoVerboVolgare:PassatoCondizionaleVerboVolgare", + "Imperativo presente": "TipoTempoVerboVolgare:PresenteImperativoVerboVolgare", "Infinito presente": "TipoTempoVerboVolgare:PresenteInfinitoVerboVolgare", + "Infinito passato": "TipoTempoVerboVolgare:PassatoInfinitoVerboVolgare", "Participio presente": "TipoTempoVerboVolgare:PresenteParticipioVerboVolgare", + "Participio passato": "TipoTempoVerboVolgare:PassatoParticipioVerboVolgare", "Gerundio presente": "TipoTempoVerboVolgare:PresenteGerundioVerboVolgare", + "Gerundio passato": "TipoTempoVerboVolgare:PassatoGerundioVerboVolgare" + }, + "Funzione": { + "Aggettivo": "TipoFunzioneVerboVolgare:VerboVolgareFunzioneAggettivo", "Sostantivo maschile": "TipoFunzioneVerboVolgare:VerboVolgareFunzioneSostantivoMaschile", + "Sostantivo femminile": "TipoFunzioneVerboVolgare:VerboVolgareFunzioneSostantivoFemminile" + }, + "Declinazione": { + "Prima declinazione": "TipoDeclinazioneVerboVolgare:PrimaDeclinazioneVerboVolgare", "Seconda declinazione": "TipoDeclinazioneVerboVolgare:SecondaDeclinazioneVerboVolgare", + "Terza declinazione": "TipoDeclinazioneVerboVolgare:TerzaDeclinazioneVerboVolgare" + }, + "Persona": { + "1ª persona singolare": "TipoPersonaVerboVolgare:PrimaPersonaSingolareVerboVolgare", "2ª persona singolare": "TipoPersonaVerboVolgare:SecondaPersonaSingolareVerboVolgare", + "3ª persona singolare": "TipoPersonaVerboVolgare:TerzaPersonaSingolareVerboVolgare", "1ª persona plurale": "TipoPersonaVerboVolgare:PrimaPersonaPluraleVerboVolgare", + "2ª persona plurale": "TipoPersonaVerboVolgare:SecondaPersonaPluraleVerboVolgare", "3ª persona plurale": "TipoPersonaVerboVolgare:TerzaPersonaPluraleVerboVolgare" + } + + }, + + "sostantivovolgare": { + "Genere_lemma": { "Lemma femminile": "TipoGenereLemmaSostantivoVolgare:GenereFemminileLemmaSostantivoVolgare", "Lemma maschile": "TipoGenereLemmaSostantivoVolgare:GenereMaschileLemmaSostantivoVolgare" }, + "Genere_forma": { "Forma femminile": "TipoGenereSostantivoVolgare:GenereFemminileSostantivoVolgare", "Forma maschile": "TipoGenereSostantivoVolgare:GenereMaschileSostantivoVolgare" }, + "Numero": { "Singolare": "TipoNumeroSostantivoVolgare:NumeroSingolareSostantivoVolgare", "Plurale": "TipoNumeroSostantivoVolgare:NumeroPluraleSostantivoVolgare" }, + "riflpers": { "In locuzione": "SostantivoVolgareInLocuzione:Lv_lv" }, + "Declinazione_sostantivo": { + "Prima declinazione": "TipoDeclinazioneSostantivoVolgare:PrimaDeclinazioneSostantivoVolgare", "Seconda declinazione": "TipoDeclinazioneSostantivoVolgare:SecondaDeclinazioneSostantivoVolgare", + "Terza declinazione": "TipoDeclinazioneSostantivoVolgare:TerzaDeclinazioneSostantivoVolgare" + } + }, + + "pronomevolgare": { + "Genere": { "Femminile": "generePronomeVolgare:PronomeVolgareFemminile", "Maschile": "generePronomeVolgare:PronomeVolgareMaschile" }, + "Numero": { "Singolare": "TipoNumeroPronomeVolgare:PronomeVolgareSingolare", "Plurale": "TipoNumeroPronomeVolgare:PronomeVolgarePlurale" }, + "Classe_Persona": { + "1ª": "TipoClassePersonaPronomeVolgare:PronomeVolgarePrimaClassePersona", + "2ª": "TipoClassePersonaPronomeVolgare:PronomeVolgareSecondaClassePersona", + "3ª": "TipoClassePersonaPronomeVolgare:PronomeVolgareTerzaClassePersona" + }, + "Tipo": { + "Personale": "TipoDelPronomeVolgare:PronomePersonaleVolgare", + "Riflessivo": "TipoDelPronomeVolgarePronomeRiflessivoVolgare", + "Interrogativo": "TipoDelPronomeVolgare:PronomeInterrogativoVolgare", + "Esclamativo": "TipoDelPronomeVolgare:PronomeEsclamativoVolgare", + "Dimostrativo": "TipoDelPronomeVolgare:PronomeDimostrativoVolgare", + "Relativo": "TipoDelPronomeVolgare:PronomeRelativoVolgare", + "Possessivo": "TipoDelPronomeVolgare:PronomePossessivoVolgare" + }, + "Forma_Personali_Riflessivi": { + "Libero": "TipoFormaPerRifPronomeVolgare:PronomeLiberoVolgare", + "Libero in Composizione": "TipoFormaPerRifPronomeVolgare:PronomeLiberoInComposizioneVolgare", + "Proclitico": "TipoFormaPerRifPronomeVolgare:PronomeProcliticoVolgare", "Enclitico": "TipoFormaPerRifPronomeVolgare:PronomeEncliticoVolgare" + }, + "Funzione_Personali": { + "Libero - soggetto": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoSoggetto", + "Libero - soggetto impersonale": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoSoggettoImpersonale", + "Libero - complemento": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoComplemento", "Libero - rafforzativo": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoRafforzativo", + "Clitico - accusativo": "TipoFunzionePronomeVolgare:PronomeVolgareCliticoAccusativo", "Clitico - dativo": "TipoFunzionePronomeVolgare:PronomeVolgareCliticoDativo", + "Clitico - partitivo": "TipoFunzionePronomeVolgare:PronomeVolgareCliticoPartitivo" + }, + "Tipo_Riflessivi": { + "Proprio": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareProprio", "Lessicalizzato": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareLessicalizzato", + "Impersonale": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareImpersonale", "Passivo": "TipoRiflessiviDelPronomeVolgare:PronomeVolgarePassivo", + "Reciproco": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareReciproco" + } + + }, + + "aggettivovolgare": { + "Classe": { "1ª": "TipoClasseAggettivoVolgare:AggettivoVolgarePrimaClasse", "2ª": "TipoClasseAggettivoVolgare:AggettivoVolgareSecondaClasse" }, + "Genere": { "Femminile": "TipoGenereAggettivoVolgare:AggettivoVolgareFemminile", "Maschile": "TipoGenereAggettivoVolgare:AggettivoVolgareMaschile" }, + "Numero": { "Singolare": "TipoNumeroAggettivoVolgare:AggettivoVolgareSingolare", "Plurale": "TipoNumeroAggettivoVolgare:AggettivoVolgarePlurale" }, + "Con_oggetto_indiretto": { "Con oggetto indiretto": "AggettivoVolgareConOggettoIndiretto:AggettivoVolgareConOggettoIndiretto" }, + "Tipo_aggettivo": { + "Qualificativo": "TipoDellAggettivoVolgare:AggettivoQualificativoVolgare", + "Indefinito": "TipoDellAggettivoVolgare:AggettivoIndefinitoVolgare", "Interrogativo": "TipoDellAggettivoVolgare:AggettivoInterrogativoVolgare", + "Esclamativo": "TipoDellAggettivoVolgare:AggettivoEsclamativoVolgare", "Numerale": "TipoDellAggettivoVolgare:AggettivoNumeraleVolgare", + "Dimostrativo": "TipoDellAggettivoVolgare:AggettivoDimostrativoVolgare", "Relativo": "TipoDellAggettivoVolgare:AggettivoRelativoVolgare", + "Possessivo": "TipoDellAggettivoVolgare:AggettivoPossessivoVolgare", "In locuzione": "TipoDellAggettivoVolgare:AggettivoVolgareInLocuzione" + }, + "Grado": { + "Comparativo di maggioranza": "TipoGradoAggettivoVolgare:AggettivoVolgareComparativoDiMaggioranza", "Comparativo di minoranza": "TipoGradoAggettivoVolgare:AggettivoVolgareComparativoDiMinoranza", + "Comparativo di uguaglianza": "TipoGradoAggettivoVolgare:AggettivoVolgareComparativoDiUgualianza", "Superlativo relativo": "TipoGradoAggettivoVolgare:AggettivoVolgareSuperlativorelativo", + "Superlativo assoluto": "TipoGradoAggettivoVolgare:AggettivoVolgareSuperlativoAssoluto" + }, + "Tipo_di_Complemento": { + "Introdotto da A": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaA", "Introdotto da CON": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaCON", + "Introdotto da CONTRO": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaCONTRO", "Introdotto da DA": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaDA", + "Introdotto da DI": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaDI", "Introdotto da IN": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaIN", + "Introdotto da PER": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaPER", "Introdotto da SU": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaSU", + "Introdotto da TRA": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaTRA", "Introdotto da VERSO": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaVERSO", + "Introdotto da SOPRA": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaSOPRA", "Introdotto da SOTTO": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaSOTTO", + "Introdotto da DINANZI": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaDINANZI", "Introdotto da prep.": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaPreposizione", + "Oggetto ind.": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareOggettoInd", "Ogg. indi. + compl. con DI": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareOggettoIndComplConDI", + "Ogg. ind. pronom.": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareOggettoIndPronom" + }, + "Tipo_di_frase": { + "Con infinito retto da A": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaA", "Con infinito retto da DA": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaDA", + "Con infinito retto da DI": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaDI", "Con infinito retto da PER": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaPER", + "Con infinito retto da SE": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaSE", "Con subordinata all'indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConSubordinataAllIndicativo", + "Con subordinata al cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConSubordinataAlCongiuntivo", "In locuzione imp.+infinito": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpInfinito", + "In locuzione imp.+che+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpCheIndicativo", "In locuzione imp.+che+cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpCheCongiuntivo", + "In locuzione imp.+se+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpSeIndicativo", "In locuzione imp.+se+cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpSeCongiuntivo", + "In locuzione imp.+come+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpComeIndicativo", "In locuzione imp.+quando+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpQuandoIndicativo", + "In locuzione imp.+perché+cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpPerchéCongiuntivo", "In locuzione imp.+a+infinito": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpAInfinito" + } + + }, + + "articolovolgare": { + "Genere": { "Femminile": "TipoGenereArticoloVolgare:ArticoloVolgareFemminile", "Maschile": "TipoGenereArticoloVolgare:ArticoloVolgareMaschile" }, + "Numero": { "Singolare": "TipoNumeroArticoloVolgare:ArticoloVolgareSingolare", "Plurale": "TipoNumeroArticoloVolgare:ArticoloVolgarePlurale" }, + "Tipo": { "Determinativo": "TipoDellArticoloVolgare:ArticoloVolgareDeterminativo", "Indeterminativo": "TipoDellArticoloVolgare:ArticoloVolgareIndeterminativo" } + + }, + "avverbiovolgare": { + "Tipo": { + "Al comparativo di maggioranza": "TipoDellAvverbioVolgare:AvverbioVolgareAlComparativoDiMaggioranza", + "Al comparativo di minoranza": "TipoDellAvverbioVolgare:AvverbioVolgareAlComparativoDiMinoranza", + "Al superlativo assoluto": "TipoDellAvverbioVolgare:AvverbioVolgareAlSuperlativoAssoluto", + "Al superlativo relativo": "TipoDellAvverbioVolgare:AvverbioVolgareAlSuperlativoRelativo", + "In Locuzione": "TipoDellAvverbioVolgare:AvverbioVolgareInLocuzione", + "In Locuzione separato": "TipoDellAvverbioVolgare:AvverbioVolgareInLocuzioneSeparato", + "Proclitico": "TipoDellAvverbioVolgare:AvverbioVolgareProclitico", + "Enclitico": "TipoDellAvverbioVolgare:AvverbioVolgareEnclitico", + "Al comparativo di ugualianza": "TipoDellAvverbioVolgare:AvverbioVolgareAlComparativoDiUgualianza" + } + }, + + "preposizionevolgare": { + "Tipo_I": { + "Propria": "TipoIDellaPreposizioneVolgare:PreposizioneVolgarePropria", + "Impropria": "TipoIDellaPreposizioneVolgare:PreposizioneVolgareImpropria" + }, + "Tipo_preposizione": { + "Semplice": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareSemplice", + "Articolata": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareArticolata", + "In locuzione": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareInLocuzione", + "In locuzione separata": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareInLocuzioneSeparata" + }, + "Sintassi": { + "Soggettiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareSoggettiva", "Oggettiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareOggettiva", + "Dichiarativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareDichiarativa", "Completiva obliqua": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareCompletivaObliqua", + "Finale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareFinale", + "Causale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareCausale", + "Concessiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareConcessiva", + "Consecutiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareConsecutiva", + "Temporale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareTemporale", + "Modale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareModale", + "Eccettuativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareEccettuativa", + "Esclusiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareEsclusiva", + "Limitativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareLimitativa", + "Comparativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareComparativa", + "Avversativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareAvversativa" + }, + "Complemento_(I)": { + "Di stato in luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiStatoInLuogo", + "Di moto a luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMotoALuogo", + "Di moto da luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMotoDaLuogo", + "Di moto per luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMotoPerLuogo", + "Di luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiLuogo", + "Predicativo del soggetto": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgarePredicativoDelSoggetto", + "Predicativo dell'oggetto": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgarePredicativoDellOggetto", + "Di distanza": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiDistanza", + "Di tempo determinato": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTempoDeterminato", + "Di tempo continuato": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTempoContinuato", + "Di tempo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTempo", + "Di termine": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTermine", + "Di vantaggio": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiVantaggio", + "Di svantaggio": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiSvantaggio", + "Di specificazione": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiSpecificazione", + "Di modo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiModo", + "Di mezzo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMezzo", + "Di compagnia": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiCompagnia", + "Di unione": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiUnione", + "Di allontanamento-separazione": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiAllontanamentoSeparazione", + "Di materia": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMateria" + }, + "Complemento_(II)": { + "Di limitazione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiLimitazione", + "Di qualità": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiQualità", + "Di causa": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiCausa", + "Di agente": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiAgente", + "Di causa efficiente": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiCausaEfficiente", + "Di fine o scopo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiFineScopo", + "Di paragone": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiParagone", + "Di argomento": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiArgomento", + "Distributivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDistributivo", + "Di sostituzione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiSostituzione", + "Di estensione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiEstensione", + "Di rapporto": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiRapporto", + "Di esclusione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiEsclusione", + "Di peso": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiPeso", + "Di quantità": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiQuantità", + "Di colpa": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiColpa", + "Di denominazione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiDenominazione", + "partitivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgarePartitivo", + "Di abbondanza-privazione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiAbbondanzaPrivazione", + "Di origine-provenienza": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiOrigineProvenienza", + "Concessivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareConcessivo", + "Di effetto": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiEffetto", + "Di pena": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiPena", + "Simmetrico": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareSimmetrico", + "Indiretto esperiente": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoEsperiente", + "Indiretto dativo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoDativo", + "Indiretto oggetto": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoOggetto", + "Indiretto possessore": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoPossessore", + "Indiretto benefattivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoBenefattivo" + } + }, + + "congiunzionevolgare": { + "Coo_sub": { + "Coordinativa": "TipoCooSubCongiunzioneVolgare:CongiunzioneVolgareCoordinativa", + "Subordinativa": "TipoCooSubCongiunzioneVolgare:CongiunzioneVolgareSubordinativa" + }, + "Tipo": { + "Semplice": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareSemplice", + "Composta": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareComposta", + "Locuzione": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareLocuzione", + "Locuzione separata": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareLocuzioneSeparata" + }, + "Coord_tipo": { + "Copulativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareCopulativa", + "Disgiuntiva": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareDisgiuntiva", + "Avversativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareAvversativa", + "Esplicativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareEsplicativa", + "Conclusiva": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareConclusiva", + "Correlativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareCorrelativa" + }, + "Subord_tipo": { + "Soggettiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareSoggettiva", + "Oggettiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareOggettiva", + "Dichiarativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareDichiarativa", + "Completiva obliqua": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareCompletivaObliqua", + "Interrogativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareInterrogativa", + "Finali": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareFinali", + "Causali": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareCausali", + "Concessiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareConcessiva", + "Consecutiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareConsecutiva", + "Temporale": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareTemporale", + "Modale": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareModale", + "Eccettuativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareEccettuativa", + "Comparativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareComparativa", + "Condizionale": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareCondizionale", + "Esclusiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareEsclusiva", + "Limitativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareLimitativa" + } + }, + + "onomasticavolgare": { + "Tipo": { + "Nome proprio": "TipoDellOnomasticaVolgare:NomeProprio", "Nome proprio separato": "TipoDellOnomasticaVolgare:NomeProprioSeparato", + "Titolo": "TipoDellOnomasticaVolgare:Titolo" + } + }, + + "citazionevolgare": { + "Tipo": { + "Latina": "TipoDellaCitazioneVolgare:CitazioneLatina", + "Provenzale": "TipoDellaCitazioneVolgare:CitazioneProvenzale", + "Francese": "TipoDellaCitazioneVolgare:CitazioneFrancese", + "Spagnola": "TipoDellaCitazioneVolgare:CitazioneSpagnola", + "Ebraica": "TipoDellaCitazioneVolgare:CitazioneEbraica", + "Greca": "TipoDellaCitazioneVolgare:CitazioneGreca" + } + + } +} + +/* +* +* SPARQL statements +* +*/ +data21 = `{"verbovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaVerboVolgare"}}, + "sostantivovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaSostantivoVolgare"}}, + "aggettivovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaAggettivoVolgare"}}, + "avverbiovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaAvverbioVolgare"}}, + "pronomevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaPronomeVolgare"}}, + "congiunzionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaCongiunzioneVolgare"}}, + "articolovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaArticoloVolgare"}}, + "preposizionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaPreposizioneVolgare"}}, + "interiezionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaInteriezioneVolgare"}}, + "onomasticavolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaOnomasticaVolgare"}}, + "citazionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaCitazioneVolgare"}}, + "locuzionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaLocuzioneVolgare"}} + } + ` + +writtenrepresentation = `{"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/ns/lemon/ontolex#writtenRep"}, "object": {"termType": "Variable", "value": "Rappresentazione"}}` + + +var morphgroup = `{"type": "group", + "patterns": [{"type": "bgp", + "triples": [ + {"subject": {"termType": "Variable","value": "form"}, + "predicate": {"termType": "NamedNode", "value": "http://www.w3.org/ns/lemon/ontolex#writtenRep"}, + "object": {"termType": "Variable","value": "Rappresentazione"}}, + {"subject": {"termType": "Variable","value": "lent"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/ns/lemon/ontolex#lexicalForm"}, + "object": {"termType": "Variable", "value": "form"}}, + {"subject": {"termType": "Variable","value": "lent"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/ns/lemon/ontolex#canonicalForm"}, + "object": {"termType": "Variable","value": "cf"}}, + {"subject": {"termType": "Variable","value": "cf"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/ns/lemon/ontolex#writtenRep"}, + "object": {"termType": "Variable","value": "lm"}}, + {"subject": {"termType": "Variable","value": "fa"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/occurrenceOf"}, + "object": {"termType": "Variable","value": "form"}}, + {"subject": {"termType": "Variable","value": "fa"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/OccursInRegion"}, + "object": {"termType": "Variable", "value": "reg"}}, + {"subject": {"termType": "Variable","value": "reg"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/fragmentRegionFrom"}, + "object": {"termType": "Variable","value": "pos1"}} + ] + } + ] + } +` +var syntgroup = ` { + "type": "group", + "patterns": [ + { + "type": "bgp", + "triples": [ + {"subject": {"termType": "Variable","value": "clocc"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/occurrenceOf"}, + "object": {"termType": "Variable","value": "cl"}}, + {"subject": {"termType": "Variable","value": "clocc"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P148_has_component"}, + "object": {"termType": "Variable","value": "fa"}}, + {"subject": {"termType": "Variable","value": "clocc"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/occursInRegion"}, + "object": {"termType": "Variable","value": "frag"}}, + {"subject": {"termType": "Variable","value": "sentence"}, + "predicate": {"termType": "NamedNode","value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, + "object": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/Sentence"}}, + {"subject": {"termType": "Variable","value": "sentence"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P148i_is_component_of"}, + "object": {"termType": "Variable","value": "canto"}}, + {"subject": {"termType": "Variable","value": "sentence"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/hasSyntacticalComponent"}, + "object": {"termType": "Variable","value": "cl"}}, + {"subject": {"termType": "Variable","value": "cl"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/hasClauseType"}, + "object": {"termType": "Variable","value": "clatype"}}, + {"subject": {"termType": "Variable","value": "cl"}, + "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P190_has_symbolic_content"}, + "object": {"termType": "Variable","value": "cltext"}}, + {"subject": {"termType": "Variable","value": "cl"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/hasClauseFunction"}, + "object": {"termType": "Variable","value": "clafunction"}}, + {"subject": {"termType": "Variable","value": "frag"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/fragmentRegionFrom"}, + "object": {"termType": "Variable","value": "clfr"}}, + {"subject": {"termType": "Variable","value": "frag"}, + "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/fragmentRegionTo"}, + "object": {"termType": "Variable","value": "clto"}} + ] + } + ] + } + +` +/* +* +*Tipi sintattici +* +*/ + +var funzione_clausola = +{ + "princ": "hasClauseFunction:MainClause", + "subord i": "hasClauseFunction:SubordinateClauseI", + "subord ii": "hasClauseFunction:SubordinateClauseII", + "subord iii": "hasClauseFunction:SubordinateClauseIII", + "subord iv": "hasClauseFunction:SubordinateClauseIV", + "subord v": "hasClauseFunction:SubordinateClauseV", + "subord vi": "hasClauseFunction:SubordinateClauseVI", + "subord vii": "hasClauseFunction:SubordinateClauseVII", + "coord": "hasClauseFunction:CoordinateClause", + "coord i": "hasClauseFunction:CoordinateClauseI", + "coord ii": "hasClauseFunction:CoordinateClauseII", + "coord iii": "hasClauseFunction:CoordinateClauseIII", + "coord iv": "hasClauseFunction:CoordinateClauseIV", + "coord v": "hasClauseFunction:CoordinateClauseV", + "pcoord": "hasClauseFunction:ParentheticalCoordinateClause", + "parent": "hasClauseFunction:ParentethicalClause", + "coord 0": "hasClauseFunction:PseudoCoordinateClause" +} + +//da completare + +var listaMacroTipiConSubTipo=['Concessiva', 'Comparativa', 'Ipotetica', 'Interrogativa', 'Iussiva', 'Ottativa', 'Avversativa', 'Relativa'] + +var macrotipi_sint = +{ + "macro avv": "hasClauseType:Avversativa", + "avv": "hasClauseType:Avversativa", + "macro caus": "hasClauseType:Causale", + "macro compar": "hasClauseType:Comparativa", + "macro conces": "hasClauseType:Concessiva", + "macro consec": "hasClauseType:Consecutiva", + "macro dich": "hasClauseType:Dichiarativa", + "macro eccettu": "hasClauseType:Eccettuativa", + "macro epesege": "hasClauseType:Epesegetica", + "macro escl": "hasClauseType:Esclamativa", + "macro esclu": "hasClauseType:Esclusiva", + "macro finale": "hasClauseType:Finale", + "macro inter princ": "hasClauseType:Interrogativa", + "macro inter sub": "hasClauseType:Interrogativa", + "macro ipotet": "hasClauseType:Ipotetica", + "macro iussi": "hasClauseType:Iussiva", + "macro limitat": "hasClauseType:Limitativa", + "macro maniera": "hasClauseType:DiManiera", + "macro modale": "hasClauseType:Modale", + "macro obliqua": "hasClauseType:Obliqua", + "macro oggettiva": "hasClauseType:Oggettiva", + "macro otta": "hasClauseType:Ottativa", + //"macro pare mod": "hasClauseType:ParenteticaModalizzante", + //"macro pare sub": "hasClauseType:ParenteticaConValoreDiSubordinata", + "macro pare mod": "hasClauseType:Modalizzante;hasClauseFunction:ParentethicalClause", + "macro pare sub": "hasClauseType:Subordinata;hasClauseFunction:ParentethicalClause", + "macro pred": "hasClauseType:Predicativa", + //"macro pseudo": "hasClauseType:Pseudocoordinata", + "macro pseudo": "hasClauseFunction:ParentheticalCoordinateClause", + "macro rel": "hasClauseType:Relativa", + "macro sog": "hasClauseType:Soggettiva", + "macro strum": "hasClauseType:Strumentale", + //"macro sub": "hasClauseType:SubordinataConFunzioneDiRipresa", + "macro sub": "hasClauseFunction:SubordinateClauseI;hasClauseType:FunzioneDiRipresa", + "macro temp": "hasClauseType:Temporale" +} + +var tipi_sint = +{ + "avv caus": "hasClauseType:CoordinataAvversativaCausale", + "avv comp ug": "hasClauseType:CoordinataAvversativaComparativaDiUguaglianza", + "avv cons antec": "hasClauseType:CoordinataAvversativaConsecutivaConAntecedente", + "avv dich": "hasClauseType:CoordinataAvversativaDichiarativa", + "avv fin": "hasClauseType:CoordinataAvversativaFinale", + "avv int x": "hasClauseType:CoordinataAvversativaInterrogativaDiTipoX", + "avv int x ret": "hasClauseType:CoordinataAvversativaInterrogativaDiTipoXRetorica", + "avv ipo caus": "hasClauseType:CoordinataAvversativaIpoteticaConValoreCausale", + "avv iuss dir": "hasClauseType:CoordinataAvversativaIussivaDiretta", + "avv iuss indir": "hasClauseType:CoordinataAvversativaIussivaIndiretta", + "avv modaliz ott intr": "hasClauseType:CoordinataAvversativaModalizzanteOttativaConIntroduttore", + "avv ogg": "hasClauseType:CoordinataAvversativaOggettiva", + "avv ogg perc": "hasClauseType:CoordinataAvversativaOggettiva", + "avv rel app": "hasClauseType:CoordinataAvversativaRelativaAppositiva", + "avv rel app comp ug": "hasClauseType:CoordinataAvversativaRelativaAppositivaInConstruttoComparativo", + "avv rel app cons antec": "hasClauseType:CoordinataAvversativaRelativaAppositivaConValoreConsecutivo", + "avv rel giust": "hasClauseType:CoordinataAvversativaRelativaGiustapposta", + "avv rel ind": "hasClauseType:CoordinataAvversativaRelativaIndipendente", + "avv rel ind temp": "hasClauseType:CoordinataAvversativaRelativaIndipendenteTemporale", + "avv rel restr": "hasClauseType:CoordinataAvversativaRelativaRestrittiva", + "avv rel restr comp ug": "hasClauseType:CoordinataAvversativaRelativaRestrittivaInCostruttoComparativo", + "avv sogg": "hasClauseType:CoordinataAvversativaSoggettiva", + "avv temp": "hasClauseType:CoordinataAvversativaTemporale", + "comp disug": "hasClauseType:ComparativaDiDisuguaglianza", + "comp disug ipo": "hasClauseType:ComparativaDiDisuguaglianzaConValoreIpotetico", + "comp fin": "hasClauseType:ComparativaConValoreFinale", + "comp ipo": "hasClauseType:ComparativaConValoreIpotetico", + "comp lim": "hasClauseType:ComparativaConValoreLimitativo", + "comp mod": "hasClauseType:ComparativaConValoreModale", + "comp temp": "hasClauseType:ComparativaConValoreTemporale", + "comp ug": "hasClauseType:ComparativaDiUguaglianza", + "comp ug rel ind temp": "hasClauseType:ComparativaDiUguaglianzaConValoreDiRelativaIndipendenteTemporale", + "conc acond": "hasClauseType:ConcessivaAcondizionale", + "conc cond": "hasClauseType:ConcessivaCondizionale", + "conc fatt": "hasClauseType:ConcessivaFattuale", + "cong asind comp ug": "hasClauseType:CoordinataAsindeticaComparativaDiUguaglianza", + "cong asind cons antec": "hasClauseType:CoordinataAsindeticaConsecutivaConAntecedente", + "cong asind dich": "hasClauseType:CoordinataAsindeticaDichiarativa", + "cong asind epes": "hasClauseType:CoordinataAsindeticaEpesegetica", + "cong asind esclam": "hasClauseType:CoordinataAsindeticaEsclamativa", + "cong asind fin": "hasClauseType:CoordinataAsindeticaFinale", + "cong asind int altern": "hasClauseType:CoordinataAsindeticaInterrogativaAlternativa", + "cong asind int altern ret": "hasClauseType:CoordinataAsindeticaInterrogativaAlternativaRetorica", + "cong asind int disg": "hasClauseType:CoordinataAsindeticaInterrogativaDisgiuntiva", + "cong asind int x": "hasClauseType:CoordinataAsindeticaInterrogativaDiTipoX", + "cong asind int x ret": "hasClauseType:CoordinataAsindeticaInterrogativaDiTipoXRetorica", + "cong asind ipo": "hasClauseType:CoordinataAsindeticaIpotetica", + "cong asind iuss dir": "hasClauseType:CoordinataAsindeticaIussivaDiretta", + "cong asind iuss indir": "hasClauseType:CoordinataAsindeticaIussivaIndiretta", + "cong asind man": "hasClauseType:CoordinataAsindeticaDiManiera", + "cong asind ogg": "hasClauseType:CoordinataAsindeticaOggettiva", + "cong asind ogg perc": "hasClauseType:CoordinataAsindeticaOggettiva", + "cong asind ott intr": "hasClauseType:CoordinataAsindeticaOttativaConIntroduttore", + "cong asind ott libera": "hasClauseType:CoordinataAsindeticaOttativaLibera", + "cong asind rel app": "hasClauseType:CoordinataAsindeticaRelativaAppositiva", + "cong asind rel app comp disug": "hasClauseType:CoordinataAsindeticaRelativaAppositivaInConstruttoComparativo", + "cong asind rel app giust": "hasClauseType:CoordinataAsindeticaRelativaGiustapposta", + "cong asind rel ind": "hasClauseType:CoordinataAsindeticaRelativaIndipendente", + "cong asind rel ind temp caus": "hasClauseType:CoordinataAsindeticaRelativaIndipendenteConValoreTemporaleCausale", + "cong asind rel restr": "hasClauseType:CoordinataAsindeticaRelativaRestrittiva", + "cong asind rel restr comp ug": "hasClauseType:CoordinataAsindeticaRelativaRestrittivaInConstruttoComparativo", + "cong asind sogg soll": "hasClauseType:CoordinataAsindeticaSoggettivaASollevamento", + "cong asind subord": "hasClauseType:CoordinataAsindeticaSubordinata", + "cong asind temp": "hasClauseType:CoordinataAsindeticaTemporale", + "cong caus": "hasClauseType:CoordinataCongiuntivaCausale", + "cong comp disug": "hasClauseType:CoordinataCongiuntivaComparativaDiDisuguaglianza", + "cong comp ipo": "hasClauseType:CoordinataCongiuntivaComparativaConValoreIpotetico", + "cong comp lim": "hasClauseType:CoordinataCongiuntivaComparativaConValoreLimitativo", + "cong comp mod": "hasClauseType:CoordinataCongiuntivaComparativaConValoreModale", + "cong comp ug": "hasClauseType:CoordinataCongiuntivaComparativaDiUguaglianza", + "cong conc cond": "hasClauseType:CoordinataCongiuntivaConcessivaCondizionale", + "cong conc fatt": "hasClauseType:CoordinataCongiuntivaConcessivaFattuale", + "cong concl cons antec": "hasClauseType:CoordinataConclusivaConsecutivaConAntecedente", + "cong concl dich": "hasClauseType:CoordinataConclusivaDichiarativa", + "cong concl dich ill": "hasClauseType:CoordinataConclusivaDichiarativaIllocutiva", + "cong concl iuss dir": "hasClauseType:CoordinataConclusivaIussivaDiretta", + "cong concl iuss dir perifr": "hasClauseType:CoordinataConclusivaIussivaDirettaPerifrastica", + "cong concl iuss indir": "hasClauseType:CoordinataConclusivaIussivaIndiretta", + "cong cons antec": "hasClauseType:CoordinataCongiuntivaConsecutivaConAntecedente", + "cong cons antec epes": "hasClauseType:CoordinataCongiuntivaConsecutivaConAntecedenteEpisegetica", + "cong cons antec fin": "hasClauseType:CoordinataCongiuntivaConsecutivaConAntecedenteConValoreFinale", + "cong cons caus": "hasClauseType:CoordinataConsecutivaCausale", + "cong cons dich": "hasClauseType:CoordinataConsecutivaDichiarativa", + "cong cons ell": "hasClauseType:CoordinataCongiuntivaConsecutivaEllittica", + "cong cons libera": "hasClauseType:CoordinataCongiuntivaConsecutivaLibera", + "cong cons libera fin": "hasClauseType:CoordinataCongiuntivaConsecutivaLiberaConValoreFinale", + "cong cons post": "hasClauseType:CoordinataCongiuntivaConsecutivaPosposta", + "cong corr dich": "hasClauseType:CoordinataCorrelativaDichiarativa", + "cong corr fin": "hasClauseType:CoordinataCorrelativaFinale", + "cong corr lim": "hasClauseType:CoordinataCorrelativaLimitativa", + "cong corr sogg infinitoprep": "hasClauseType:CoordinataCorrelativaSoggettivaAInfinitoPreposizionale", + "cong dich": "hasClauseType:CoordinataCongiuntivaDichiarativa", + "cong dich ill": "hasClauseType:CoordinataCongiuntivaDichiarativaIllocutiva", + "cong eccett": "hasClauseType:CoordinataCongiuntivaEccettuativa", + "cong epes": "hasClauseType:CoordinataCongiuntivaEpesegetica", + "cong esclam": "hasClauseType:CoordinataCongiuntivaEsclamativa", + "cong esclus": "hasClauseType:CoordinataCongiuntivaEsclusiva", + "cong espl dich": "hasClauseType:CoordinataEsplicativaDichiarativa", + "cong espl obl": "hasClauseType:CoordinataEsplicativaObliqua", + "cong espl ogg": "hasClauseType:CoordinataEsplicativaOggettiva", + "cong espl rel app antec": "hasClauseType:CoordinataEsplicativaRelativaAppositivaConAntecedente", + "cong espl rel ind mod": "hasClauseType:CoordinataEsplicativaRelativaIndipendenteConValoreModale", + "cong fin": "hasClauseType:CoordinataCongiuntivaFinale", + "cong int altern": "hasClauseType:CoordinataCongiuntivaInterrogativaAlternativa", + "cong int x": "hasClauseType:CoordinataCongiuntivaInterrogativaDiTipoX", + "cong int x ret": "hasClauseType:CoordinataCongiuntivaInterrogativaDiTipoXRetorica", + "cong ipo": "hasClauseType:CoordinataCongiuntivaIpotetica", + "cong ipo caus": "hasClauseType:CoordinataCongiuntivaIpoteticaConValoreCausale", + "cong ipo sogg": "hasClauseType:CoordinataCongiuntivaIpoteticaSoggettiva", + "cong iuss dir": "hasClauseType:CoordinataCongiuntivaIussivaDiretta", + "cong iuss indir": "hasClauseType:CoordinataCongiuntivaIussivaIndiretta", + "cong lim": "hasClauseType:CoordinataCongiuntivaLimitativa", + "cong man": "hasClauseType:CoordinataCongiuntivaDiManiera", + "cong modaliz ott intr": "hasClauseType:CoordinataCongiuntivaModalizzanteOttativaConIntroduttore", + "cong obl": "hasClauseType:CoordinataCongiuntivaObliqua", + "cong ogg": "hasClauseType:CoordinataCongiuntivaOggettiva", + "cong ogg perc": "hasClauseType:CoordinataCongiuntivaOggettiva", + "cong ott libera": "hasClauseType:CoordinataCongiuntivaLibera", + "cong rel app": "hasClauseType:CoordinataCongiuntivaRelativaAppositiva", + "cong rel app comp disug": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaInCostruttoComparativoDiDisuguaglianza", + "cong rel app comp ug": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaInCostruttoComparativoDiUguaglianza", + "cong rel app cons": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreConsecutivo", + "cong rel app epes": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreDiEpisegetica", + "cong rel app fin": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreFinale", + "cong rel app giust": "hasClauseType:CoordinataCongiuntivaRelativaGiustapposta", + "cong rel app giust caus": "hasClauseType:CoordinataCongiuntivaRelativaGiustappostaConValoreCausale", + "cong rel app temp": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreTemporale", + "cong rel impl": "hasClauseType:CoordinataCongiuntivaRelativaImplicita", + "cong rel impl lim": "hasClauseType:CoordinataCongiuntivaRelativaImplicitaConValoreLimitativo", + "cong rel ind": "hasClauseType:CoordinataCongiuntivaRelativaIndipendente", + "cong rel ind acond": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteAcondizionale", + "cong rel ind ipo": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteConValoreIpotetico", + "cong rel ind mod": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteConValoreModale", + "cong rel ind mod comp ug": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteInCostruttoComparativoModale", + "cong rel ind temp": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteTemporale", + "cong rel pseudo": "hasClauseType:CoordinataCongiuntivaPseudoRelativa", + "cong rel restr": "hasClauseType:CoordinataCongiuntivaRelativaRestrittiva", + "cong rel restr caus": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaConValoreCausale", + "cong rel restr comp": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaInCostruttoComparativo", + "cong rel restr comp ug": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaInCostruttoComparativoDiUguaglianza", + "cong rel restr cons": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaConValoreConsecutivo", + "cong rel restr temp": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaTemporale", + "cong rip": "hasClauseType:CoordinataCongiuntivaConFunzioneDiRipresa", + "cong sogg": "hasClauseType:CoordinataCongiuntivaSoggettiva", + "cong spec": "hasClauseType:CoordinataCongiuntivaSpecificativa", + "cong strum": "hasClauseType:CoordinataCongiuntivaStrumentale", + "cong subord": "hasClauseType:CoordinataCongiuntivaSubordinata", + "cong temp": "hasClauseType:CoordinataCongiuntivaTemporale", + "cong temp caus": "hasClauseType:CoordinataCongiuntivaTemporaleConValoreCausale", + "cons antec": "hasClauseType:ConsecutivaConAntecedente", + "cons antec epes": "hasClauseType:ConsecutivaConAntecedenteEpesegetica", + "cons antec fin": "hasClauseType:ConsecutivaConAntecedenteConValoreFinale", + "cons antec temp": "hasClauseType:ConsecutivaConAntecedenteConValoreTemporale", + "cons ell": "hasClauseType:ConsecutivaEllittica", + "cons libera": "hasClauseType:ConsecutivaLibera", + "cons libera fin": "hasClauseType:ConsecutivaLiberaConValoreFinale", + "cons post": "hasClauseType:ConsecutivaPosposta", + "dich": "hasClauseType:Dichiarativa", + "dich ill": "hasClauseType:DichiarativaIllocutiva", + "disg comp disug temp": "hasClauseType:CoordinataDisgiuntivaComparativaDiDisuguaglianzaConValoreTemporale", + "disg conc acond": "hasClauseType:CoordinataDisgiuntivaConcessivaAcondizionale", + "disg conc cond": "hasClauseType:CoordinataDisgiuntivaConcessivaCondizionale", + "disg cons libera": "hasClauseType:CoordinataDisgiuntivaConsecutivaLibera", + "disg corr dich": "hasClauseType:CoordinataDisgiuntivaCorrelativaDichiarativa", + "disg dich": "hasClauseType:CoordinataDisgiuntivaDichiarativa", + "disg epes": "hasClauseType:CoordinataDisgiuntivaEpesegetica", + "disg esclus": "hasClauseType:CoordinataDisgiuntivaEsclusiva", + "disg int altern": "hasClauseType:CoordinataDisgiuntivaInterrogativaAlternativa", + "disg int disg": "hasClauseType:CoordinataDisgiuntivaInterrogativaDisgiuntiva", + "disg int x": "hasClauseType:CoordinataDisgiuntivaInterrogativaDiTipoX", + "disg ipo": "hasClauseType:CoordinataDisgiuntivaIpotetica", + "disg lim": "hasClauseType:CoordinataDisgiuntivaLimitativa", + "disg man": "hasClauseType:CoordinataDisgiuntivaDiManiera", + "disg obl": "hasClauseType:CoordinataDisgiuntivaObliqua", + "disg ogg": "hasClauseType:CoordinataDisgiuntivaOggettiva", + "disg rel ind": "hasClauseType:CoordinataDisgiuntivaRelativaIndipendente", + "disg rel ind acond": "hasClauseType:CoordinataDisgiuntivaRelativaIndipendenteAcondizionale", + "disg rel ind temp": "hasClauseType:CoordinataDisgiuntivaRelativaIndipendenteTemporale", + "disg rel restr": "hasClauseType:CoordinataDisgiuntivaRestrittiva", + "disg rel restr cons": "hasClauseType:CoordinataDisgiuntivaRestrittivaConValoreConsecutivo", + "disg sogg": "hasClauseType:CoordinataDisgiuntivaSoggettiva", + "disg temp": "hasClauseType:CoordinataDisgiuntivaTemporale", + "eccett": "hasClauseType:Eccettuativa", + "eccett comp ug": "hasClauseType:EccettuativaConValoreDiComparativaDiUguaglianza", + "epes": "hasClauseType:Epesegetica", + "esclam": "hasClauseType:Esclamativa", + "esclus": "hasClauseType:Esclusiva", + "faltern": "hasClauseType:FalsaAlternativa", + "fcong": "hasClauseType:FalsaCongiuntiva", + "fin": "hasClauseType:Finale", + "fin ipo": "hasClauseType:FinaleConValoreIpotetico", + "fin rel giust": "hasClauseType:ConcorrenzaDelRelativoInFraseFinale", + "int altern": "hasClauseType:InterrogativaAlternativa", + "int altern ret": "hasClauseType:InterrogativaAlternativaRetorica", + "int disg": "hasClauseType:InterrogativaDisgiuntiva", + "int disg ret": "hasClauseType:InterrogativaDisgiuntivaRetorica", + "int x": "hasClauseType:InterrogativaDiTipoX", + "int x ret": "hasClauseType:InterrogativaDiTipoXRetorica", + "ipo": "hasClauseType:Ipotetica", + "ipo biaff": "hasClauseType:IpoteticaBiaffermativa", + "ipo caus": "hasClauseType:IpoteticaConValoreCausale", + "ipo eccett": "hasClauseType:IpoteticaConValoreEccettuativo", + "ipo obl": "hasClauseType:IpoteticaObliqua", + "ipo rel giust": "hasClauseType:IpoteticaRelativaGiustapposta", + "ipo sogg": "hasClauseType:IpoteticaSoggettiva", + "iuss aug": "hasClauseType:IussivaAugurativa", + "iuss dir": "hasClauseType:IussivaDiretta", + "iuss dir perifr": "hasClauseType:IussivaDirettaPerifrastica", + "iuss indir": "hasClauseType:IussivaIndiretta", + "lim": "hasClauseType:Limitativa", + "lim caus": "hasClauseType:LimitativaConValoreCausale", + "lim caus eccett": "hasClauseType:LimitativaConValoreCausaleEccettuativo", + "lim eccett": "hasClauseType:LimitativaConValoreEccettuativo", + "man": "hasClauseType:DiManiera", + "man gerundioprep": "hasClauseType:DiManieraAGerundioPreposizionale", + "man rel giust": "hasClauseType:ConcorrenzaDelRelativoInFraseDiManiera", + "mod": "hasClauseType:Modale", + "modaliz": "hasClauseType:Modalizzante", + "modaliz ott intr": "hasClauseType:ModalizzanteOttativaConIntroduttore", + "modalizz ott libera": "hasClauseType:ModalizzanteOttativaLibera", + "obl": "hasClauseType:Obliqua", + "ogg": "hasClauseType:Oggettiva", + "ogg aci": "hasClauseType:Oggettiva", + "ogg perc": "hasClauseType:Oggettiva", + "ott intr": "hasClauseType:OttativaConIntroduttore", + "ott libera": "hasClauseType:OttativaLibera", + "pred": "hasClauseType:Predicativa", + "rel app antec": "hasClauseType:RelativaAppositivaConAntecedente", + "rel app antec caus": "hasClauseType:RelativaAppositivaConAntecedenteConValoreCausale", + "rel app antec comp disug": "hasClauseType:RelativaAppositivaConAntecedenteInCostruttoComparativoDiDisuguaglianza", + "rel app antec comp ug": "hasClauseType:RelativaAppositivaConAntecedenteInCostruttoComparativoDiUguaglianza", + "rel app antec comp ug": "hasClauseType:RelativaConAntecedenteInCostruttoComparativoDiUguaglianza", + "rel app antec cons": "hasClauseType:RelativaAppositivaConAntecedenteConValoreConsecutivo", + "rel app antec eccett": "hasClauseType:RelativaAppositivaConAntecedenteInCostruttoEccettuativo", + "rel app antec fin": "hasClauseType:RelativaAppositivaConAntecedenteConValoreFinale", + "rel app antec fin cons": "hasClauseType:RelativaAppositivaConAntecedenteConValoreConsecutivoFinale", + "rel app antec giust": "hasClauseType:RelativaAppositivaConAntecedenteGiustapposta", + "rel app antec giust cons": "hasClauseType:RelativaAppositivaGiustappostaConValoreConsecutivo", + "rel app antec giust ipo": "hasClauseType:RelativaAppositivaGiustappostaConValoreIpotetico", + "rel app antec giust man": "hasClauseType:RelativaAppositivaGiustappostaConValoreDiManiera", + "rel app antec strum": "hasClauseType:RelativaAppositivaConAntecedenteConValoreStrumentale", + "rel giust": "hasClauseType:RelativaGiustapposta", + "rel impl": "hasClauseType:RelativaImplicita", + "rel impl cons": "hasClauseType:RelativaImplicitaConValoreConsecutivo", + "rel impl deon": "hasClauseType:RelativaImplicitaDeontica", + "rel impl fin": "hasClauseType:RelativaImplicitaConValoreFinale", + "rel impl lim": "hasClauseType:RelativaImplicitaConValoreLimitativo", + "rel ind": "hasClauseType:RelativaIndipendente", + "rel ind acond": "hasClauseType:RelativaIndipendenteAcondizionale", + "rel ind caus": "hasClauseType:RelativaIndipendenteInCostruttoCausale", + "rel ind comp": "hasClauseType:RelativaIndipendenteInCostruttoComparativo", + "rel ind ipo": "hasClauseType:RelativaIndipendenteConValoreIpotetico", + "rel ind mod": "hasClauseType:RelativaIndipendenteConValoreModale", + "rel ind mod comp ug": "hasClauseType:RelativaIndipendenteInCostruttoComparativoModale", + "rel ind temp": "hasClauseType:RelativaIndipendenteConValoreTemporale", + "rel ind temp acond": "hasClauseType:RelativaIndipendenteConValoreTemporaleAcondizionale", + "rel ind temp caus": "hasClauseType:RelativaIndipendenteConValoreTemporaleCausale", + "rel ind temp comp ug": "hasClauseType:RelativaIndipendenteInCostruttoComparativoDiUguaglianza", + "rel pseudo": "hasClauseType:PseudoRelativa", + "rel pseudo fin": "hasClauseType:PseudoRelativaConValoreFinale", + "rel pseudo scissa": "hasClauseType:PseudoRelativaScissa", + "rel pseudo scissa temp": "hasClauseType:PseudoRelativaScissaConValoreTemporale", + "rel restr antec": "hasClauseType:RelativaRestrittivaConAntecedente", + "rel restr antec caus": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreCausale", + "rel restr antec comp disug": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoComparativoDiDisuguaglianza", + "rel restr antec comp mod": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoComparativoModale", + "rel restr antec comp ug": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoComparativoDiUguaglianza", + "rel restr antec conc cond": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreDiConcessivaCondizionale", + "rel restr antec conc fatt": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreDiConcessivaFattuale", + "rel restr antec cons": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreConsecutivo", + "rel restr antec eccett": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoEccettuativo", + "rel restr antec fin": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreFinale", + "rel restr antec ipo": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreIpotetico", + "rel restr antec lim": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoLimitativo", + "rel restr antec temp": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreTemporale", + "rip": "hasClauseType:FunzioneDiRipresa", + "sogg": "hasClauseType:Soggettiva", + "sogg aci": "hasClauseType:Soggettiva", + "sogg id": "hasClauseType:Soggettiva", + "sogg infinitoprep": "hasClauseType:Soggettiva", + "sogg scissa": "hasClauseType:SoggettivaScissa", + "sogg soll": "hasClauseType:SoggettivaASollevamento", + "spec": "hasClauseType:Specificativa", + "spec aci": "hasClauseType:Specificativa", + "spec infinitoprep": "hasClauseType:Specificativa", + "strum": "hasClauseType:Strumentale", + "subord": "hasClauseType:Subordinata", + "temp": "hasClauseType:Temporale", + "temp comp ug": "hasClauseType:TemporaleConValoreComparativo", + "temp ipo": "hasClauseType:TemporaleConValoreIpotetico", +}