diff --git a/index_5.1.html b/index_5.1.html
index ad36e30..1313ce6 100644
--- a/index_5.1.html
+++ b/index_5.1.html
@@ -39,7 +39,7 @@
<script type="module" src="./js/browseMgr_5.1.js"></script>
<script type="text/javascript" src="./js/minimap_4.3.js"></script>
<script type="text/javascript" src="./js/partext.js"></script>
-<script type="text/javascript" src="./js/utilsMgr_5.0.js"></script>
+<script type="text/javascript" src="./js/utilsMgr_5.1.js"></script>
<script type="text/javascript" src="./js/citazionijson.js"></script>
<script type="module" src="./js/script_5.1.js"></script>
<script type="text/javascript" src="./js/sparqltemplates.js"></script>
diff --git a/js/browseMgr_5.1.js b/js/browseMgr_5.1.js
index b66d9db..d43b15b 100644
--- a/js/browseMgr_5.1.js
+++ b/js/browseMgr_5.1.js
@@ -1,7 +1,7 @@
/**
*
*/
-import { getVersiConCitazioni, queryRiferimenti, getListaRis, cleanListaRis, getFormaCntxt, getListaIdCommenti} from './dataMgr_5.0.js';
+import { getVersiConCitazioni, queryRiferimenti, getListaRis, cleanListaRis, getFormaCntxt, getListaIdCommenti, queryRiferimentimul} from './dataMgr_5.1.js';
import { getJsonQuery, emptyStructCard } from './script_5.1.js';
import {resetGraphStr} from './syntgraph_5.1.js'
@@ -1509,7 +1509,14 @@ $(document).ready(function() {
else
unitaRicerca = jsonQuery['unitaRicerca']
if (unitaRicerca=='riferimenti'){
- listaRisultatiCommenti=queryRiferimenti(jsonQuery.Riferimento100, cantoDisplayed)
+ var esprLR=jsonQuery.EsprLogicaRif
+ if(esprLR.length && esprLR.length==1){
+ listaRisultatiCommenti=queryRiferimenti(jsonQuery[esprLR[0].trim()], cantoDisplayed)
+ return
+ }
+ else{
+ listaRisultatiCommenti=queryRiferimentimul(jsonQuery, cantoDisplayed)
+ }
return
}
console.log("got json query, unita ricerca: " + unitaRicerca)
diff --git a/js/dataMgr_5.1.js b/js/dataMgr_5.1.js
index 10dd901..f813dac 100644
--- a/js/dataMgr_5.1.js
+++ b/js/dataMgr_5.1.js
@@ -9,7 +9,7 @@ var rif_autori = [];
var rif_areetematiche = [];
var rif_fonti = [];
var listaidversi = []
-var listaidcommenti=[]
+var listaidcommenti = []
const cantobadgeclassBis = 'badge badge-outline-warning badge-pill'
const JSDELIVR_BUNDLES = duckdb.getJsDelivrBundles();
@@ -99,7 +99,7 @@ export function getListaIdCommenti() {
}
export function cleanListaRis() {
listaidversi = [];
- listaidcommenti=[]
+ listaidcommenti = []
}
export function getFontiS() {
@@ -147,10 +147,11 @@ export async function getVersiConCitazioni(canticapar = '', cantopar = '') {
return result4
}
-export async function queryRiferimenti(filtro, cid) {
+function getWhere(filtro) {
if (filtro == null) {
return
}
+ var queryfi = ''
console.log(filtro)
var contenuti_riferimento = {
'personaggio': " and CPER !='' and CPER !='no'",
@@ -161,27 +162,27 @@ export async function queryRiferimenti(filtro, cid) {
'stilema': " and CST !='' and CST !='no'",
'topografia': " and CTO !='' and CTO !='no'"
}
- const tconn = await db.connect();
- var tmpfiltro=''
- var querytl = 'select IdRiferimento, Cantica, Canto, Verso from riferimenti'
- var queryfi = ' where '
- if (filtro.Commentatore != null && filtro.Commentatore.trim() != 'all'){
- tmpfiltro=filtro.Commentatore.trim()
- tmpfiltro=tmpfiltro.replace("\'", "_")
+
+ var tmpfiltro = ''
+
+ queryfi = ' '
+ if (filtro.Commentatore != null && filtro.Commentatore.trim() != 'all') {
+ tmpfiltro = filtro.Commentatore.trim()
+ tmpfiltro = tmpfiltro.replace("\'", "_")
queryfi += "Com like'" + tmpfiltro + "'"
}
-
+
else
queryfi += "Com like '%'"
- if (filtro.Autore_Fonte != null && filtro.Autore_Fonte.trim() != 'all'){
-
- tmpfiltro=filtro.Autore_Fonte
- tmpfiltro=tmpfiltro.replace("\'", "_")
+ if (filtro.Autore_Fonte != null && filtro.Autore_Fonte.trim() != 'all') {
+
+ tmpfiltro = filtro.Autore_Fonte
+ tmpfiltro = tmpfiltro.replace("\'", "_")
//console.log(tmpfiltro)
- queryfi += " and Aut like '" + tmpfiltro.trim()+ "'"
-
+ queryfi += " and Aut like '" + tmpfiltro.trim() + "'"
+
}
-
+
if (filtro.Fonte != null && filtro.Fonte.trim() != 'all')
queryfi += " and TiFo='" + filtro.Fonte.trim() + "'"
@@ -203,28 +204,212 @@ export async function queryRiferimenti(filtro, cid) {
queryfi += " and Ann like '%" + filtro.Testo_Nota.trim() + "%'"
if (filtro.contesto != null) {
var marray = JSON.parse(filtro.contesto);
- var infiltro=false
- var oplog=' and ('
- var tfi=filtroContesto(marray[0], 'Inferno', oplog)
- queryfi+=tfi
- if (tfi.trim()!='')
- infiltro=true
- oplog=' or '
- tfi=''
- tfi=filtroContesto(marray[1], 'Purgatorio', oplog)
- if (tfi!=''){
- infiltro=true
+ var infiltro = false
+ var oplog = ' and ('
+ var tfi = filtroContesto(marray[0], 'Inferno', oplog)
+ queryfi += tfi
+ if (tfi.trim() != '')
+ infiltro = true
+ oplog = ' or '
+ tfi = ''
+ tfi = filtroContesto(marray[1], 'Purgatorio', oplog)
+ if (tfi != '') {
+ infiltro = true
queryfi += tfi
- oplog=' or '
+ oplog = ' or '
}
- tfi=''
- tfi=filtroContesto(marray[2], 'Paradiso', oplog)
- if (tfi!=''){
- infiltro=true
+ tfi = ''
+ tfi = filtroContesto(marray[2], 'Paradiso', oplog)
+ if (tfi != '') {
+ infiltro = true
queryfi += tfi
- }
+ }
if (infiltro)
- queryfi +=")"
+ queryfi += ")"
+ }
+ return (queryfi)
+}
+var tmpc = ''
+function getWherePart(iclause, query, cls) {
+ console.log(cls)
+ for (var filt in iclause) {
+ if ('TERM' in iclause[filt]) {
+ var rifterm = iclause[filt]['TERM']
+ console.log(getWhere(query[rifterm]))
+ /*tmpc += '('+getWhere(query[rifterm])*/
+ console.log(parseInt(filt) + 1)
+ if (parseInt(filt) == 0) {
+ tmpc += '(' + getWhere(query[rifterm])
+ tmpc += ') '
+ }
+
+ else {
+ tmpc += cls + ' (' + getWhere(query[rifterm])
+ tmpc += ') '
+ }
+
+ }
+ else {
+ var myop = Object.keys(iclause[filt])[0];
+ if (parseInt(filt) > 0)
+ tmpc += ' ' + cls
+ getWherePart(iclause[filt][myop], query, myop)
+ }
+ }
+ //tmpc+=')'
+ return tmpc
+}
+
+export async function queryRiferimentimul(query, cid) {
+ var wherecl = ' where '
+ var parser = peg.generate(hdnriferquerygrammar);
+ var test = query['EsprLogicaRif'].join(" ");
+ test = test.replaceAll("( ", "(")
+ test = test.replaceAll(" )", ")")
+ var rifclauses = parser.parse(test);
+ var jsonclauses = JSON.parse(rifclauses)
+ tmpc = ''
+ for (var cls in jsonclauses) {
+ wherecl += '('+getWherePart(jsonclauses[cls], query, cls)+')'
+
+ }
+ console.log(wherecl)
+ const tconn = await db.connect();
+
+ var querytl = 'select IdRiferimento, Cantica, Canto, Verso from riferimenti'
+ var rs = await tconn.query(querytl + wherecl)
+ var result4 = rs.toArray().map((row) => row.toJSON());
+
+ await tconn.close();
+ var resxcantica = Object.groupBy(result4, ({ Cantica }) => Cantica);
+ console.log(resxcantica)
+ showResult(resxcantica, cid)
+}
+
+function showResult(resxcantica, cid) {
+ listaidversi = []
+ var numcid = cid.split('_')[1]
+ for (var cantica in resxcantica) {
+ var $nctags = $(' .navig-canto')
+
+ console.log(resxcantica[cantica].length)
+ var i = 1;
+ if (cantica == 'Purgatorio')
+ i = 2
+ if (cantica == 'Paradiso')
+ i = 3
+ var spanbadgecantica = $('<span />');
+ spanbadgecantica.attr('class', 'badge badge-warning badge-pill mx-2');
+ spanbadgecantica.append(resxcantica[cantica].length)
+ spanbadgecantica.appendTo($('#cantica' + i + '-badge'))
+
+
+ var tmp = resxcantica[cantica]
+ var resxcanto = Object.groupBy(tmp, ({ Canto }) => Canto);
+ for (var canto in resxcanto) {
+ var tmpv = resxcanto[canto]
+ var spanbadge = $('<span />');
+ spanbadge.attr('class', cantobadgeclassBis);
+ spanbadge.append(resxcanto[canto].length)
+ if (canto.startsWith('0')) {
+ canto = canto.replace('0', '')
+ }
+ spanbadge.appendTo($nctags.filter('[name="' + cantica + 'Canto ' + canto + '"]'))
+ for (const tmpvi of tmpv) {
+ let myveid = '#' + cantica + '_Canto_' + canto + '_' + tmpvi.Verso.split('-')[0]
+ //console.log(myveid)
+ listaidversi.push(myveid)
+ listaidcommenti.push(tmpvi.IdRiferimento)
+ if (cid.includes(cantica) && numcid == canto)
+ $(myveid).addClass("mark ")
+ }
+
+ }
+ drawMinimap(cid, true)
+
+ }
+ /*console.log(resxcantica)*/
+ return listaidversi
+}
+
+export async function queryRiferimenti(filtro, cid) {
+ if (filtro == null) {
+ return
+ }
+ console.log(filtro)
+ var contenuti_riferimento = {
+ 'personaggio': " and CPER !='' and CPER !='no'",
+ 'episodio': " and CEP !='' and CEP !='no'",
+ 'motivo': " and CMO !='' and CMO !='no'",
+ 'immagine': " and CIM !='' and CIM !='no'",
+ 'teoria': " and CTE !='' and CTE !='no'",
+ 'stilema': " and CST !='' and CST !='no'",
+ 'topografia': " and CTO !='' and CTO !='no'"
+ }
+ const tconn = await db.connect();
+ var tmpfiltro = ''
+ var querytl = 'select IdRiferimento, Cantica, Canto, Verso from riferimenti'
+ var queryfi = ' where '
+ if (filtro.Commentatore != null && filtro.Commentatore.trim() != 'all') {
+ tmpfiltro = filtro.Commentatore.trim()
+ tmpfiltro = tmpfiltro.replace("\'", "_")
+ queryfi += "Com like'" + tmpfiltro + "'"
+ }
+
+ else
+ queryfi += "Com like '%'"
+ if (filtro.Autore_Fonte != null && filtro.Autore_Fonte.trim() != 'all') {
+
+ tmpfiltro = filtro.Autore_Fonte
+ tmpfiltro = tmpfiltro.replace("\'", "_")
+ //console.log(tmpfiltro)
+ queryfi += " and Aut like '" + tmpfiltro.trim() + "'"
+
+ }
+
+ if (filtro.Fonte != null && filtro.Fonte.trim() != 'all')
+ queryfi += " and TiFo='" + filtro.Fonte.trim() + "'"
+
+ if (filtro.Area_Tematica != null && filtro.Area_Tematica.trim() != 'all')
+ queryfi += " and CA='" + filtro.Area_Tematica.trim() + "'"
+
+ if (filtro.Tipo_Riferimento != null && filtro.Tipo_Riferimento.trim() != 'all')
+ queryfi += " and NaRi='" + filtro.Tipo_Riferimento.trim().toUpperCase() + "'"
+ if (filtro.Contenuto_Riferimento != null && filtro.Contenuto_Riferimento != 'all')
+ queryfi += contenuti_riferimento[filtro.Contenuto_Riferimento.trim()]
+
+ if (filtro.Rapporto_Testo_Fonte != null && filtro.Rapporto_Testo_Fonte != 'all')
+ queryfi += " and UPPER(RSO)=UPPER('" + filtro.Rapporto_Testo_Fonte.trim() + "')"
+
+ if (filtro.Testo_Fonte != null && filtro.Testo_Fonte.trim() != '')
+ queryfi += " and TF like '%" + filtro.Testo_Fonte.trim() + "%'"
+
+ if (filtro.Testo_Nota != null && filtro.Testo_Nota.trim() != '')
+ queryfi += " and Ann like '%" + filtro.Testo_Nota.trim() + "%'"
+ if (filtro.contesto != null) {
+ var marray = JSON.parse(filtro.contesto);
+ var infiltro = false
+ var oplog = ' and ('
+ var tfi = filtroContesto(marray[0], 'Inferno', oplog)
+ queryfi += tfi
+ if (tfi.trim() != '')
+ infiltro = true
+ oplog = ' or '
+ tfi = ''
+ tfi = filtroContesto(marray[1], 'Purgatorio', oplog)
+ if (tfi != '') {
+ infiltro = true
+ queryfi += tfi
+ oplog = ' or '
+ }
+ tfi = ''
+ tfi = filtroContesto(marray[2], 'Paradiso', oplog)
+ if (tfi != '') {
+ infiltro = true
+ queryfi += tfi
+ }
+ if (infiltro)
+ queryfi += ")"
}
var rs = await tconn.query(querytl + queryfi)
@@ -310,16 +495,16 @@ function opzioniRiferimenti() {
function filtroContesto(marray, cantica, op) {
var filtrost = ''
if (marray.every((val, i, arr) => val === 1)) {
- return op+ " Cantica='"+cantica+"'"
+ return op + " Cantica='" + cantica + "'"
}
if (marray.some((val, i, arr) => val === 1)) {
var tearr = marray.reduce(function(tearr, n, i) { if (n === 1) tearr.push(i); return tearr; }, []);
for (const ic in tearr) {
- var canto = (tearr[ic]+1).toString()
- if ((tearr[ic]+1) < 10)
+ var canto = (tearr[ic] + 1).toString()
+ if ((tearr[ic] + 1) < 10)
canto = '0' + canto
if (ic == 0)
- filtrost += op+" (Cantica='"+cantica+"' and (Canto='" + canto + "'"
+ filtrost += op + " (Cantica='" + cantica + "' and (Canto='" + canto + "'"
else
filtrost += " or Canto='" + canto + "'"
@@ -329,22 +514,22 @@ function filtroContesto(marray, cantica, op) {
console.log(filtrost)
}
return filtrost
-}
+}
//Contesto
export async function getFormaCntxt(formaid, numversi = 3) {
const tconn = await db.connect();
- var querycnt = "select * from commedia where index>=((select index from commedia where Position='"+formaid+"')-25) order by index limit 50"
- console.log(" "+formaid)
+ var querycnt = "select * from commedia where index>=((select index from commedia where Position='" + formaid + "')-25) order by index limit 50"
+ console.log(" " + formaid)
var rs = await tconn.query(querycnt)
var result4 = rs.toArray().map((row) => row.toJSON());
-
-
+
+
console.log(result4)
console.log('-----------------------------------------')
-
-
+
+
await tconn.close();
}
diff --git a/js/utilsMgr_5.1.js b/js/utilsMgr_5.1.js
new file mode 100644
index 0000000..e4f46c1
--- /dev/null
+++ b/js/utilsMgr_5.1.js
@@ -0,0 +1,2209 @@
+
+
+var hdnquerygrammar = `
+Expression
+ = head:((_)?"("(_)?("AND "/"OR ") Filtro+ (_)?(")")?){return '{"'+head[3]+'": ['+head[4]+"]}"}//{ return head}.join("").replaceAll(", ,","").replaceAll("(,","(").replaceAll(",("," (")}
+ / resu:Filtro {return resu[1].split().join()+' ';}
+Filtro
+ = (_)"("?head:(("AND "/"OR "))? tail:(Clausola+ / Filtronick+) (_)? closecl:(")")?
+
+ {if (head != null) return ' {"'+head+'":['+tail+"]}";
+ else if (tail!=null & tail.length <2) return ' '+tail+''
+ else return ""+tail+"";}
+ / cl:Clausola
+
+Clausola
+ = cla:("Clausola"Integer)(_)? {return ' {"TERM": "'+cla[0]+cla[1]+'"}';}
+
+Filtronick
+ =fil:("filtro-"Integer)(_)? {return ' {"TERM": "'+fil[0]+fil[1]+'"}';}
+
+
+Integer "integer"
+ = _ [0-9]+ { return parseInt(text(), 10); }
+
+_ "whitespace"= " "*
+
+`
+var hdnriferquerygrammar = `
+Expression
+ = head:((_)?"("(_)?("AND "/"OR ") Filtro+ (_)?(")")?){return '{"'+head[3]+'": ['+head[4]+"]}"}//{ return head}.join("").replaceAll(", ,","").replaceAll("(,","(").replaceAll(",("," (")}
+ / resu:Filtro {return resu[1].split().join()+' ';}
+Filtro
+ = (_)"("?head:(("AND "/"OR "))? tail:(Riferimento+ / Filtronick+) (_)? closecl:(")")?
+
+ {if (head != null) return ' {"'+head+'":['+tail+"]}";
+ else if (tail!=null & tail.length <2) return ' '+tail+''
+ else return ""+tail+"";}
+ / cl:Riferimento
+
+Riferimento
+ = cla:("Riferimento"Integer)(_)? {return ' {"TERM": "'+cla[0]+cla[1]+'"}';}
+
+Filtronick
+ =fil:("filtro-"Integer)(_)? {return ' {"TERM": "'+fil[0]+fil[1]+'"}';}
+
+
+Integer "integer"
+ = _ [0-9]+ { return parseInt(text(), 10); }
+
+_ "whitespace"= " "*
+
+`
+
+
+var testmm = 0
+
+
+
+var ontoSparqlQuerySynt = `
+PREFIX ecrm: <http://erlangen-crm.org/current/>
+PREFIX orl: <https://dantenetwork.it/ontology/orl/current/>
+PREFIX ontolex: <http://www.w3.org/ns/lemon/ontolex#>
+PREFIX olires: <https://dantenetwork.it/ontology/olires/current/>
+PREFIX syntit: <https://dantenetwork.it/ontology/syntit/current/>
+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 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> 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/'
+
+
+function getFraseContext(fraseids, numversi = 3) {
+ var context = []
+ var listaforme = formeprima;
+ var fraseid = fraseids[0]
+
+ var mainid = fraseid.split('-')[0]
+ var cantica = mainid.split('_')[0]
+ var offset = parseInt(fraseid.split('-')[2]);
+ if (cantica == '2') {
+ offset = parseInt(fraseid.split('-')[2]) - 33374
+ listaforme = formeseconda;
+ console.log(listaforme.length)
+ }
+
+ if (cantica == '3') {
+ offset = parseInt(fraseid.split('-')[2]) - 66588
+ listaforme = formeterza;
+ }
+ maxpos = listaforme.length - 1
+ var pos = 0
+ var startindex = Math.max(0, (offset - 30))
+
+ for (i = startindex; i < listaforme.length; i++) {
+ var tmpos = listaforme[i].split('_')[2]
+
+ if (parseInt(tmpos) == parseInt(fraseid.split('-')[2])) {
+ pos = i;
+ break;
+ }
+ }
+ console.log (fraseid +" - " + parseInt(fraseid.split('-')[2])+ ' - '+pos)
+
+ var pos2 = pos
+
+ if (fraseids.length > 1)
+ lastfraseid = fraseids[fraseids.length - 1]
+ else
+ lastfraseid = fraseids[0]
+
+ for (j = pos; j < listaforme.length; j++) {
+
+ var tmpos2 = listaforme[j].split('_')[2]
+ if (parseInt(tmpos2) == parseInt(lastfraseid.split('-')[3])) {
+ pos2 = j;
+ break;
+ }
+ }
+
+
+ var minpos = 0;
+ var limitv = Math.max((numversi), 3)
+ var item = listaforme[pos].split('_');
+ var numverso = item[3]
+ var spannum = (4 * limitv)
+
+ var contextinf = Math.max(minpos, parseInt(pos) - spannum)
+ var contextsup = Math.min(maxpos, parseInt(pos2) + spannum)
+
+ /*var contextinf = parseInt(fraseid.split('-')[2])
+ var contextsup = parseInt(fraseid.split('-')[3])*/
+ 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 - 1;
+ 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;
+}
+
+function getContextLastPosition(formaid, numversi = 3) {
+
+ var listaforme = formeprima;
+
+ var limitv = Math.max((numversi), 3)
+ var maxpos = 0;
+ var 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
+
+ }
+ 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;
+ break;
+ }
+ }
+
+ var spannum = (11 * limitv)
+
+ var contextsup = Math.min(maxpos, parseInt(pos) + spannum)
+ var tmpform = listaforme[contextsup].split('_');
+ return (parseInt(tmpform[2]))
+
+
+}
+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 = parseInt(formaid);
+
+
+ /*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;
+ }
+ }
+
+
+ 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'] = (parseInt(cantica) + 1) + '_' + 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 posBindConcatStatement = ''
+
+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']]
+
+ 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' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso') {//Multiple Conditions UR=Periodo
+ multipleCondSpQuery = spqparser.parse(sentencetargetquery);
+ bindConcatStatement = JSON.parse(sentencetarget_functionbind);
+ occBindConcatStatement = JSON.parse(sentencetarget_occbind);
+ posBindConcatStatement = JSON.parse(sentencetarget_posbind);
+
+ }
+ else
+ multipleCondSpQuery = spqparser.parse(ontoSparqlQueryMultCond);
+ var parser = peg.generate(hdnquerygrammar);
+ var 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' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso') {
+ multipleCondSpQuery.where.push(bindConcatStatement)
+ multipleCondSpQuery.where.push(occBindConcatStatement)
+
+ if (posBindConcatStatement['expression']['args'].length) {
+ multipleCondSpQuery.where.push(posBindConcatStatement)
+ multipleCondSpQuery.variables.push(JSON.parse(sentencetarget_posVariable))
+ //multipleCondSpQuery.where.push(sentencetargetstatement_posCoalesce)
+ }
+
+ }
+
+}
+
+//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;
+ }
+ var clausolaS='Clausola0'
+ 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]['typeSyntax0'].trim() != '' && stquery[clause]['typeSyntax0'].trim() != '.+') ||
+ stquery[clause]['functionSyntax'].trim() != '.+') &&
+ stquery[clause]['typeGramm0'].trim() == 'all') {//solo filtro 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
+ }
+ if ((stquery[clause]['typeSyntax0'].trim() == '.+' && stquery[clause]['functionSyntax'].trim() == '.+') &&
+ stquery[clause]['typeGramm0'].trim() != 'all') {//solo filtro grammaticale
+ myquery = buildClause(stquery[clause], parsedquery, 2)
+ if (filtroContesto.length > 0) {
+ for (tmpc of filtroContesto) {
+ console.log(filtroContesto[0])
+ myquery.where.splice(1, 0, tmpc)
+ }
+
+ if (stquery[clause]['queryText'].trim() == "") {
+ if (myquery.where[0].type == 'filter')
+ myquery.where.splice(0, 1)
+ }
+
+ }
+ return (myquery)
+ }
+
+
+ if (((stquery[clause]['typeSyntax0'].trim() != '' && stquery[clause]['typeSyntax0'].trim() != '.+') ||
+ (stquery[clause]['functionSyntax'].trim() != '' && stquery[clause]['functionSyntax'].trim() != '.+')) &&
+ stquery[clause]['typeGramm0'].trim() != 'all') {//entrambi i filtri
+ console.log('entrambi i filtri')
+ //preparo la query sparql
+ var tmpCont = stquery[clause]['contesto']
+ var tmpCl0 = stquery['Clausola0']
+ var tmpUnric = stquery['unitaRicerca']
+
+ var tmpCl2 = {
+ "queryText": stquery[clause]["queryText"],
+ "lemma_forma": stquery[clause]["lemma_forma"],
+ "opzioni_testo": stquery[clause]["opzioni_testo"],
+ "TipoClausola": "Sintattico",
+ "Attiva": "1",
+ "typeSyntax0": stquery[clause]["typeSyntax0"],
+ "functionSyntax": stquery[clause]["functionSyntax"],
+ "contesto": tmpCont
+ }
+
+ var tmpCl1J = stquery['Clausola1']
+ //var tmpCl1J= JSON.parse(tC1);
+ delete tmpCl1J['typeSyntax0'];
+ delete tmpCl1J['functionSyntax'];
+ tmpCl1J["TipoClausola"] = "Grammaticale"
+ var tmpJ = {
+ "EsprLogica": ["(", "AND", "Clausola1", "Clausola2", ")"],
+ "LogicaGui": ["(", "AND", "Clausola1", "Clausola2", ")"],
+ "QueryAvanzata": "1",
+ "unitaRicerca": tmpUnric,
+ "LiDaVersion": "1.0",
+ "Clausola0": tmpCl0,
+ "Clausola1": tmpCl1J,
+ "Clausola2": tmpCl2
+ }
+ console.log(tmpJ);
+ buildSPQuery(tmpJ);
+ return multipleCondSpQuery;
+
+ }
+ if (stquery[clause]['queryText'].trim() != "")
+ clausolaS=clause
+ }
+ //Simple query
+
+ filtroContestoJson = getFiltroContestoJson(JSON.parse(stquery[clausolaS]['contesto']))
+ if (filtroContestoJson.length > 0) {
+ for (tmpc of filtroContestoJson) {
+ //console.log(filtroContesto[0])
+ parsedquery.where.splice(1, 0, tmpc)
+ }
+
+
+ }
+
+ if (stquery[clausolaS]['queryText'] != "" && stquery[clausolaS]['Attiva'] == 1) {
+ searchtext = stquery[clausolaS]['queryText']
+ let strval = "^" + searchtext.trim() + "$"
+
+ if (stquery[clausolaS]['opzioni_testo'] == 'parola') {
+ strval = "^" + searchtext.trim() + "$";
+ }
+ if (stquery[clausolaS]['opzioni_testo'] == 'sottostringa') {
+ strval = searchtext.trim();
+ }
+ if (stquery[clausolaS]['opzioni_testo'] == 'suffisso') {
+ strval = searchtext.trim() + "$";
+ }
+ if (stquery[clausolaS]['opzioni_testo'] == 'prefisso') {
+ strval = "^" + searchtext.trim();
+ }
+
+
+
+
+ parsedquery.where[0].expression.args[1].value = strval;
+ if (stquery[clausolaS]['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) {
+ //
+ var tmpgroup = ''
+ if (clause['TipoClausola'] == "Sintattico") {
+ if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso')
+ tmpgroup = JSON.parse(sentencetarget_syntgroup)
+ else
+ tmpgroup = JSON.parse(syntgroup)
+ }
+ if (clause['TipoClausola'] == "Grammaticale") {
+ if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso') {
+ tmpgroup = JSON.parse(sentencetarget_morphgroup_short)
+ }
+
+ else
+ tmpgroup = JSON.parse(morphgroup)
+ }
+
+
+ if (clause['queryText'] != null && clause['queryText'].trim() != "") {
+
+
+ var stmt = buildFilterStatement(clause['lemma_forma'], clause['queryText'].trim(), clause['opzioni_testo'])
+ tmpgroup.patterns.unshift(stmt)
+ //tmpgroup.patterns.push(JSON.parse(unionop)['bgp']);
+ tmpgroup.patterns.splice(1, 0, JSON.parse(unionop)['bgp']);
+ if (clause['lemma_forma'] == 'lemma') {
+ tmpgroup.patterns.at(-1).triples.push(JSON.parse(lemma_lexicalform))
+ tmpgroup.patterns.at(-1).triples.push(JSON.parse(lemma_canonicalform))
+ tmpgroup.patterns.at(-1).triples.push(JSON.parse(lemma_writtenrepresentation))
+ }
+ else {
+ tmpgroup.patterns[1].triples.push(JSON.parse(writtenrepresentation))
+ //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'] == 'Grammaticale') {
+ if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso') {
+ var tmpg = JSON.stringify(tmpgroup)
+ tmpg = tmpg.replaceAll('"Rappresentazione"', '"Rappresentazione' + token + '"')
+ tmpg = tmpg.replaceAll('"form"', '"form' + token + '"')
+ tmpg = tmpg.replaceAll('"lent"', '"lent' + token + '"')
+ tmpg = tmpg.replaceAll('"cf"', '"cf' + token + '"')
+ tmpg = tmpg.replaceAll('"fa"', '"fa' + token + '"')
+ tmpg = tmpg.replaceAll('"pos"', '"pos' + token + '"')
+ tmpg = tmpg.replaceAll('"lm"', '"lm' + token + '"')
+ tmpg = tmpg.replaceAll('"reg"', '"reg' + token + '"')
+ tmpg = tmpg.replaceAll('"clg"', '"clg' + token + '"')
+ tmpg = tmpg.replaceAll('"cloccte"', '"cloccte' + token + '"')
+ tmpgroup = JSON.parse(tmpg)
+ var tmppos = `{
+ "type": "operation",
+ "operator": "str",
+ "args": [
+ {
+ "termType": "Variable",
+ "value": "pos`+ token + `"
+ }
+ ]
+ }
+ `
+ posBindConcatStatement['expression']['args'].push(JSON.parse(tmppos))
+ tmppos = `{
+ "termType": "Literal",
+ "value": ";",
+ "language": "",
+ "datatype": {
+ "termType": "NamedNode",
+ "value": "http://www.w3.org/2001/XMLSchema#string"
+ }
+ }`
+ posBindConcatStatement['expression']['args'].push(JSON.parse(tmppos))
+ }
+ }
+
+ // CLAUSOLA SINTATTICA
+
+ if (clause['TipoClausola'] == "Sintattico") {
+ tmpgroup.patterns.push(JSON.parse(unionop)['bgp']);
+
+ //controllo se tra i filtri c'e una stringa
+ if (clause['queryText'] != null && clause['queryText'].trim() != "") {
+ //aggiungo statements per legare la stringa alla clausola
+
+ tmpgroup.patterns[1].triples.push(JSON.parse(occurrenceof_form))
+ tmpgroup.patterns[1].triples.push(JSON.parse(clauseocc_hascomponent_formocc))
+ tmpgroup.patterns[1].triples.push(JSON.parse(occurrenceof_clause))
+ }
+ 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]
+
+ 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' || theguiQ['unitaRicerca'] == 'frase' || theguiQ['unitaRicerca'] == 'verso') {
+ mytest = JSON.stringify(tmpgroup)
+ mytest = mytest.replaceAll(':"cl"', ':"cl' + token + '"')
+ mytest = mytest.replaceAll(':"clatype"', ':"clatype' + token + '"')
+ mytest = mytest.replaceAll(':"clafunction"', ':"clafunction' + token + '"')
+ mytest = mytest.replaceAll(':"cloccu"', ':"cloccu' + token + '"')
+ mytest = mytest.replaceAll(':"fa"', ':"fa' + token + '"')
+ mytest = mytest.replaceAll(':"form"', ':"form' + token + '"')
+ mytest = mytest.replaceAll(':"Rappresentazione"', ':"Rappresentazione' + 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 of sctk) {
+
+ keval = clause[ke]
+ if (keval != null && keval != '') {
+ sttmts = sctmp[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['Ann'];
+ commentsItem['commentario'] = item['Com'];
+ commentsItem['frammentoNota'] = item['FrN'];
+ commentsItem['AutoreCitazione'] = item['AC'];
+ commentsItem['FonteCitazione'] = item['F'];
+ commentsItem['LuogoFonteCitazione'] = item['LF'];
+ commentsItem['NotaFonteCitazione'] = item['NF'];
+ commentsItem['TestoFonteCitazione'] = item['TF'];
+ commentsItem['URLFonteCitazione'] = item['UF'];
+ commentsItem['NaturaRiferimento'] = item['NaRi'];
+ commentsItem['RapportoCommentoCommentatoreText'] = item['RCC'];
+ commentsItem['RapportoSoggettoOggetto'] = item['RSO'];
+ commentsItem['NomeAutoreCitazione'] = item['Aut'];
+ commentsItem['TitoloFonteCitazione'] = item['TiFo'];
+ commentsItem['VersoCitazione'] = item['Verso'];
+
+ if (item['AC'] == '') {
+ commentsItem['AutoreCitazione'] = 'autore'
+ }
+
+ if (item['TiCi'] == 'no') {
+ commentsItem['TipoCitazione'] = ''
+ }
+ else {
+ commentsItem['TipoCitazione'] = item['TiCi']
+ }
+ //'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;
+}
+
+//inizializzazione UI per query sulle citazioni
+function getAutoriFontiCitazioni() {
+ var listaAutori = new Set()
+ citazioni.map(function(item) {
+ listaAutori.add(item['Aut']);
+
+ if (item['Aut'] == '') {
+ listaAutori.add('Sconosciuto')
+ }
+
+ })
+
+ return Array.from(listaAutori)
+}
+
+function getCommentatori() {
+ var listaCommentatori = new Set()
+ citazioni.map(function(item) {
+ listaCommentatori.add(item['Com']);
+
+ if (item['Com'] == '') {
+ listaCommentatori.add('Sconosciuto')
+ }
+
+ })
+
+ return Array.from(listaCommentatori)
+}
+*/
+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 (!vistaPeriodi && !listaPeriodiRisultato.includes(tmpsent)
+ && listaClausoleRisultato.filter(cl => cl.split('-')[0] == tmpsent).length == 0)
+ 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 (!vistaPeriodi)
+ iframeSentence[i].style.removeProperty('color');
+
+ iframeSentence[i].classList.remove('font-weight-normal');
+ }
+ //EMPTY CARD
+ 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",
+}