예제 #1
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func (x *Imp) Defined(s string) bool {
	//
	n, i, p := uint(len(s)), uint(0), uint(0)
	if str.Contains(s, separator, &i) && i < n &&
		nat.Defined(&p, str.Part(s, i+1, n-(i+1))) {
		return x.Defined2(str.Part(s, 0, i), p)
	}
	return false
}
예제 #2
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func names(mask, suffix string, n uint, l, c uint, f, b col.Colour) (string, string) {
	//
	t, t1 := uint(len(mask)), uint(0)
	if t > 0 {
		t1 = 1 + t
	}
	scr.Save(l, c, t1+n, 1)
	if t > 0 {
		mbx.Wd(t)
		mbx.ColoursScreen()
		mbx.Write(mask, l, c)
	}
	bx.Wd(n)
	bx.Colours(f, b)
	ptSuffix = "." + suffix
	errh.Hint("falls Dateien vorhanden, auswählen F2-, dann Pfeil-/Eingabetaste, ggf. Esc")
	name := env.Par(1)
	if name == "" {
		name = str.Clr(n) // Wörkeraunt um Fehler in box/imp.go
	}
	var p uint
	if str.Contains(name, '.', &p) {
		name = str.Part(name, 0, p)
	}
	bx.Edit(&name, l, c+t1)
	str.RemSpaces(&name)
	if str.Contains(name, '.', &p) {
		name = str.Part(name, 0, p)
	}
	filename := name + ptSuffix
	a := files.NumPred(hasSuffix)
	if a > 0 {
		var d uint
		switch kbd.LastCommand(&d) {
		case kbd.Esc:
			return "", "" // str.Clr (n), ""
		case kbd.Enter:
			// entered
		case kbd.LookFor:
			i := uint(0)
			select_(aus, a, a, n, &i, l, c+t1, b, f)
			if i == a {
				return "", "" // str.Clr (n), ""
			} else {
				str.Set(&filename, files.NamePred(hasSuffix, i))
			}
		}
	}
	errh.DelHint()
	str.RemSpaces(&filename)
	if str.Contains(filename, '.', &p) {
		name = str.Part(filename, 0, p)
	}
	scr.Restore(l, c, t1+n, 1)
	return name, filename
}
예제 #3
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func (x *Imp) Defined(t string) bool {
	//
	x.Clr()
	if str.Empty(t) {
		return true
	}
	n, ss, P, L := nat.DigitSequences(t)
	if n == 0 || n > 3 {
		return false
	}
	if n == 3 {
		if x.fmt == Hh_mm {
			return false
		}
	}
	if L[0] >= textlength[x.fmt] {
		return false
	}
	h, m, s := uint(0), uint(0), uint(0)
	if n == 1 {
		if !nat.Defined(&h, str.Part(t, P[0], 2)) {
			return false
		}
		if L[0] > 2 {
			if !nat.Defined(&m, str.Part(t, P[0]+2, 2)) {
				return false
			}
			if L[0] > 4 {
				if !nat.Defined(&s, str.Part(t, P[0]+4, 2)) {
					return false
				}
			}
		}
	} else {
		if !nat.Defined(&h, ss[0]) {
			return false
		}
		if !nat.Defined(&m, ss[1]) {
			return false
		}
		if n == 2 && x.fmt == Mm_ss {
			s, m, h = m, h, 0
		}
		if n == 3 {
			if !nat.Defined(&s, ss[2]) {
				return false
			}
		}
	}
	return x.defined(h, m, s)
}
예제 #4
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func defined(z *int, s string) bool {
	//
	str.Move(&s, true)
	negative := s[0] == '-'
	var n uint
	if negative {
		n = uint(len(s))
		s = str.Part(s, 1, n-1)
	}
	if str.Empty(s) {
		return false
	}
	if nat.Defined(&n, s) {
		if negative {
			if n < m2 {
				*z = -int(n)
				return true
			} else if n == m2 {
				*z = MinInt
				return true
			}
		} else if n <= MaxInt {
			*z = int(n)
			return true
		}
	}
	return false
}
예제 #5
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func (x *Imp) Defined(s string) bool {
	//
	x.Clr()
	n := uint(len(s))
	if n < 7 {
		return false
	}
	if s[0] != '(' || s[n-1] != ')' {
		return false
	}
	t := str.Part(s, 1, n-2) + ","
	var p uint
	for d := D0; d < NDirs; d++ {
		if !str.Contains(t, ',', &p) {
			return false
		}
		r, err := strconv.ParseFloat(t[:p], 64)
		if err == nil {
			x.x[d] = r
		} else {
			return false
		}
		str.Rem(&t, 0, p+1)
	}
	return true
}
예제 #6
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func aus(n, l, c uint, f, b col.Colour) {
	//
	N := files.NamePred(hasSuffix, n)
	var p uint
	if str.IsPart(ptSuffix, N, &p) {
		N = str.Part(N, 0, p)
	}
	bx.Colours(f, b)
	bx.Write(N, l, c)
}
예제 #7
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func (x *Imp) SetReal(r float64) {
	//
	i, _ := math.Modf(r + 0.5)
	s := strconv.FormatFloat(i, 'f', -1, 64)
	p := uint(0)
	if str.Contains(s, '.', &p) {
		s = str.Part(s, 0, p)
	}
	if _, ok := x.n.SetString(s, 10); !ok {
		x.n.SetInt64(0)
	}
}
예제 #8
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func (x *Imp) Defined(s string) bool {
	//
	x.Clr()
	if str.Empty(s) {
		return true
	}
	str.Move(&s, true)
	x.geq0 = s[0] != '-'
	switch s[0] {
	case '+', '-':
		str.Rem(&s, 0, 1)
	}
	n := str.ProperLen(s)
	var p uint
	if str.Contains(s, '/', &p) {
		s1 := str.Part(s, p+1, n-p-1)
		if nat.Defined(&x.denom, s1) {
			if x.denom >= max {
				return false
			}
		} else {
			return false
		}
	} else {
		p = n
		x.denom = 1
	}
	s1 := str.Part(s, 0, p)
	if nat.Defined(&x.num, s1) {
		if x.num >= max {
			return false
		}
	} else {
		return false
	}
	return true
}
예제 #9
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func isMonth(Monat *uint, Wort string) bool {
	//
	var T string
	n := str.ProperLen(Wort)
	if n > 0 {
		for m := uint(1); m <= maxmonth; m++ {
			T = str.Part(nameMonth[m], 0, n)
			if Wort == T { // str.QuasiEq (Wort, T) {
				*Monat = uint(m)
				return true
			}
		}
	}
	return false
}
예제 #10
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func (x *Imp) String() string {
	//
	if x.year == emptyYear {
		return str.Clr(length[x.fmt])
	}
	const mitNullen = true
	s := ""
	switch x.fmt {
	case Dd, Dd_mm_, Dd_mm_yy, Dd_mm_yyyy, Dd_M, Dd_M_yyyy:
		if x.day == 0 {
			Panic("day.String: x.day == 0")
		}
		s = nat.StringFmt(x.day, 2, mitNullen)
		if x.fmt == Dd {
			return s
		}
		s += "."
		switch x.fmt {
		case Dd_M, Dd_M_yyyy:
			s += " " + nameMonth[x.month]
			str.RemSpaces(&s)
			if x.fmt == Dd_M {
				return s
			}
			s += " "
		default:
			s += nat.StringFmt(x.month, 2, mitNullen) + "."
		}
		switch x.fmt {
		case Dd_mm_:

		case Dd_mm_yy:
			s += nat.StringFmt(x.year, 2, true)
		default: // Dd_mm_yyyy, Dd_M_yyyy:
			s += nat.StringFmt(x.year, 4, false)
		}
	case Yymmdd:
		s = nat.StringFmt(x.year%100, 2, true) +
			nat.StringFmt(x.month, 2, true) +
			nat.StringFmt(x.day, 2, true)
	case Yyyymmdd:
		s = nat.StringFmt(x.year, 4, true) +
			nat.StringFmt(x.month, 2, true) +
			nat.StringFmt(x.day, 2, true)
	case Yy:
		s = nat.StringFmt(x.year, 2, true)
	case Yyyy:
		s = nat.StringFmt(x.year, 4, false)
	case Wd:
		s = WdShorttext[x.Weekday(Daily)]
	case WD:
		s = WdText[x.Weekday(Daily)]
	case Mmm, M:
		s = nameMonth[x.month]
		if x.fmt == Mmm {
			s = str.Part(s, 0, 3)
		}
	case Myyyy:
		s = nameMonth[x.month] + " " +
			nat.StringFmt(x.year, 4, false)
	case Wn, WN, WNyyyy:
		s = nat.StringFmt(x.Weeknumber(), 2, false)
		if x.fmt > Wn {
			s += ".Woche"
		}
		if x.fmt == WNyyyy {
			s += " " + nat.StringFmt(x.year, 4, false)
		}
	case Qu:
		switch (x.month - 1) / 3 {
		case 0:
			s = "  I"
		case 1:
			s = " II"
		case 2:
			s = "III"
		case 3:
			s = " IV"
		}
		s += "/" + nat.StringFmt(x.year, 2, true)
	}
	return s
}
예제 #11
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func (x *Imp) Defined(s string) bool {
	//
	if str.Empty(s) {
		x.Clr()
		return true
	}
	var d Imp
	d.day, d.month, d.year = x.day, x.month, x.year
	var T string
	var l, p uint
	n, ss, P, L := nat.DigitSequences(s)
	switch x.fmt {
	case Dd, // e.g. " 8"
		Dd_mm_,     // e.g. " 8.10."
		Dd_mm_yy,   // e.g. " 8.10.07"
		Dd_mm_yyyy: // e.g. " 8.10.2007" *):
		switch n {
		case 1:
			l = 2
		case 2, 3:
			l = L[0]
		default:
			return false
		} // see below
	case Dd_M, // e.g. "8. Oktober"
		Dd_M_yyyy: // e.g. "8. Oktober 2007"
		if x.fmt == Dd_M {
			if n != 1 {
				return false
			}
		} else {
			if n != 2 {
				return false
			}
		}
		if !str.Contains(s, '.', &p) {
			return false
		}
		if x.fmt == Dd_M_yyyy {
			//      l = str.ProperLen (s)
			//      T = str.Part (s, p, l - p)
			T = ss[1]
			if !nat.Defined(&d.year, T) {
				return false
			}
		}
		T = ss[0]
		str.Move(&T, true)
		if !nat.Defined(&d.day, T) {
			return false
		}
		T = str.Part(s, p+1, P[1]-p-1)
		str.Move(&T, true)
		if !isMonth(&d.month, T) {
			return false
		}
		return x.defined(d.day, d.month, d.year)
	case Yymmdd: // e.g. "090418"
		if !nat.Defined(&d.year, str.Part(s, 0, 2)) {
			return false
		}
		if !nat.Defined(&d.month, str.Part(s, 2, 2)) {
			return false
		}
		if !nat.Defined(&d.day, str.Part(s, 4, 2)) {
			return false
		}
		return x.defined(d.day, d.month, d.year)
	case Yyyymmdd: // e.g. "20090418"
		if !nat.Defined(&d.year, str.Part(s, 0, 4)) {
			return false
		}
		if !nat.Defined(&d.month, str.Part(s, 4, 2)) {
			return false
		}
		if !nat.Defined(&d.day, str.Part(s, 6, 2)) {
			return false
		}
		return x.defined(d.day, d.month, d.year)
	case Yy, // e.g. "08"
		Yyyy: // e.g. "2007"
		if n != 1 {
			return false
		}
		if nat.Defined(&d.year, ss[0]) {
			return x.defined(d.day, d.month, d.year)
		} else {
			return false
		}
	case Wd, // e.g. "Mo"
		WD: // e.g. "Monday"
		return false // Fall noch nicht erledigt
	case Mmm, // e.g. "Mon"
		M: // e.g. "Oktober"
		if !isMonth(&d.month, s) {
			return false
		}
		return x.defined(d.day, d.month, d.year)
	case Myyyy: // e.g. "Oktober 2007"
		if n != 1 {
			return false
		}
		if !nat.Defined(&d.year, ss[0]) {
			return false
		}
		if !str.Contains(s, ' ', &p) {
			return false
		}
		if !isMonth(&d.month, str.Part(s, 0, p)) {
			return false
		}
		return x.defined(d.day, d.month, d.year)
	case Wn, // e.g. "1" (.Woche)
		WN: // e.g. "1.Woche"
		if n != 1 {
			return false
		}
		if nat.Defined(&n, T) {
			if 0 < n && n <= 3 {
				d.day, d.month, d.year = 1, 1, x.year
				c := internalCode(d)
				w := weekday(d)
				if w > Thursday {
					c += 7
				} // see Weeknumber
				if c < uint16(w) {
					return false
				}
				c -= uint16(w) // so c is a Monday
				d.Decode(Encode(uint(c) + 7*n))
				if d.year == x.year {
					x.day = d.day
					x.month = d.month
					return true
				}
			}
			return false
		}
	case WNyyyy: // e.g. "1.Woche 2007"
		return false // not yet implemented
	case Qu: // e.g. "  I/06"
		if n != 1 {
			return false
		}
		if !str.Contains(s, '/', &p) {
			return false
		}
		if !nat.Defined(&d.year, ss[0]) {
			return false
		}
		T = str.Part(s, 0, p)
		str.Move(&T, true)
		n = str.ProperLen(T)
		if T[0] != 'I' {
			return false
		}
		switch n {
		case 1:
			d.month = 1
		case 2:
			switch T[1] {
			case 'I':
				d.month = 4
			case 'V':
				d.month = 10
			default:
				return false
			}
		case 3:
			if T[1] == 'I' && T[2] == 'I' {
				d.month = 7
			}
		default:
			return false
		}
		return x.defined(d.day, d.month, d.year)
	}
	if !nat.Defined(&d.day, str.Part(s, P[0], l)) {
		return false
	}
	if n == 1 {
		if L[0] > 8 {
			return false
		} // maximal "Dd_mm_yyyy"
		if L[0] > 2 {
			if !nat.Defined(&d.month, str.Part(s, P[0]+2, 2)) {
				return false
			}
		}
		if L[0] > 4 {
			if !nat.Defined(&d.year, str.Part(s, P[0]+4, L[0]-4)) {
				return false
			}
		}
	} else { // n == 2, 3
		if !nat.Defined(&d.month, ss[1]) {
			return false
		}
		if n == 2 && x.Empty() {
			d.year = today.(*Imp).year
		}
		if n == 3 {
			if !nat.Defined(&d.year, ss[2]) {
				return false
			}
		}
	}
	return x.defined(d.day, d.month, d.year)
}
예제 #12
0
파일: imp.go 프로젝트: CaptainSoOmA/Uni
func init() {
	//
	l[Title] = []string{"",
		"Dr.", "Dr.med.", "Dr.med.dent.", "Dr.rer.nat.", "Dr.phil.",
		"Dr.iur.", "Dr.med.vet.", "Dr.rer.pol.", "Dr.-Ing.",
		"Prof.Dr.", "Prof.Dr.med.", "Prof.Dr.-Ing."}
	s[Title] = l[Title]

	l[Composer] = []string{"",
		"Monteverdi, Claudio (1567-1643)",
		"Frescobaldi, Girolamo (1583-1643)",
		"Schütz, Heinrich (1585-1672)",
		"Lully, Jean Baptiste (1632-1687)",
		"Buxtehude, Dietrich (1637-1707)",
		"Corelli, Arcangelo (1653-1713)",
		"Purcell, Henry (1659-1695)",
		"Scarlatti, Alessandro (1659-1725)",
		"Couperin, Francois (1668-1733)",
		"Caldara, Antonio (1670-1736)",
		"Albinoni, Tomaso (1671-1751)",
		"Vivaldi, Antonio (1680-1743)",
		"Telemann, Georg Philipp (1681-1767)",
		"Rameau, Jean-Philippe (1683-1764)  ",
		"Bach, Johann Sebastian (1685-1750) ",
		"Händel, Georg Friedrich (1685-1759)",
		"Pergolesi, Giovanni Battista (1710-1736)",
		"Gluck, Christoph Willibald (1714-1787)",
		"Bach, Philip Emanuel (1714-1788)", // 19, see 15
		"Haydn, Joseph (1732-1809)",
		"Boccherini, Luigi (1743-1805)",
		"Mozart, Wolfgang Amadeus (1756-1791)",
		"Cherubini, Luigi (1760-1842)",
		"Beethoven, Ludwig van (1770-1827)",
		"Spohr, Ludwig (1774-1859)",
		"Paganini, Niccolo (1782-1840)",
		"Weber, Carl Maria von (1786-1826)",
		"Rossini, Gioacchino (1792-1868)",
		"Schubert, Franz (1797-1828)",
		"Lortzing, Albert (1801-1851)",
		"Berlioz, Hector (1803-1869)",
		"Glinka, Michael (1804-1857)",
		"Mendelssohn-Bartholdy, Felix (1809-1874)",
		"Schumann, Robert (1810-1856)",
		"Chopin, Frederic (1810-1849)",
		"Liszt, Franz (1811-1886)",
		"Wagner, Richard (1813-1883)",
		"Verdi, Giuseppe (1813-1901)",
		"Franck, Cesar (1822-1890)",
		"Lalo, Edouard (1823-1892)",
		"Smetana, Friedrich (1824-1884)",
		"Bruckner, Anton (1824-1896)",
		"Strauss, Johann (1825-1899)",
		"Brahms, Johannes (1833-1897)",
		"Borodin, Alexander (1834-1887)",
		"Saint-Saens, Camille (1835-1921)",
		"Bizet, Georges (1836-1875)",
		"Mussorgski, Modest (1839-1881)",
		"Tschaikowskij, Peter (1840-1893)",
		"Dvorak, Antonin (1841-1904)",
		"Grieg, Edward (1843-1907)",
		"Rimskij-Korssakow, Nikolai (1844-1908)",
		"Janacek, Leos (1854-1928)",
		"Mahler, Gustav (1860-1911)",
		"Debussy, Claude (1862-1918)",
		"Strauß, Richard (1864-1949)",
		"Sibelius, Jean (1865-1957)",
		"Pfitzner, Hans (1869-1949)",
		"Scriabin, Alexander (1872-1915)",
		"Reger, Max (1873-1916)",
		"Rachmaninow, Sergej (1873-1947)",
		"Schönberg, Arnold (1874-1951)",
		"Ravel, Maurice (1875-1937)",
		"Falla, Manuel de (1876-1946)",
		"Bartok, Bela (1881-1945)",
		"Strawinsky, Igor (1882-1971)",
		"Webern, Anton von (1883-1945)",
		"Berg, Alban (1885-1935)",
		"Furtwängler, Wilhelm (1886-1954)",
		"Prokofieff, Serge (1891-1953)",
		"Honegger, Arthur (1892-1955)",
		"Hindemith, Paul (1895-1963)",
		"Orff, Carl (1895-1982)",
		"Blacher, Boris (1903-1975)",
		"Chatschaturian, Aram (1903-1978)",
		"Schostakowitsch, Dimitri (1906-1975)",
		"Fortner, Wolfgang (1907-1987)",
		"Britten, Benjamin (1913-1976)",
		"Boulez, Pierre (1925-)",
		"Henze, Hans Werner (1926-2012)"}
	n := uint(len(l[Composer]))
	s[Composer] = make([]string, n)
	s[Composer][0] = ""
	for i := uint(1); i < n; i++ {
		s[Composer][i] = str.Part(l[Composer][i], 0, str.Pos(l[Composer][i], ','))
	}
	s[Composer][19] = "Bach, Ph.E."

	l[RecordLabel] = []string{"",
		"2001", "Angel", "BMG", "CBS",
		"Decca", "Denon", "Deutsche Grammophon",
		"EMI", "Erato", "Harmonia mundi",
		"Melodia", "Philips", "Polygram",
		"Sony", "Supraphon", "Teldec",
		"UMG", "Warner", "Zyx"}
	s[RecordLabel] = l[RecordLabel]

	l[AudioMedium] = []string{"",
		"Single Play record", "Long Play record",
		"Composeract disk", "Digital versatile disc",
		"Super Audio CD", "Blu-ray disc"}
	s[AudioMedium] = []string{"",
		"SP", "LP", "CD", "DVD", "SACD", "BD"}

	l[SparsCode] = []string{"AAA",
		"AAD", "ADD", "DAD", "DDD"}
	s[SparsCode] = l[SparsCode]

	l[Religion] = []string{"keine",
		"evangelisch", "katholisch", "jüdisch", "muslimisch",
		"hinduistisch", "buddhistisch", "andere"}
	s[Religion] = l[Religion]

	l[Subject] = []string{"keinFach",
		"Deutsch", "Englisch", "Französisch", "Italienisch", "Spanisch",
		"Polnisch", "Russisch", "Türkisch", "Japanisch", "Chinesisch",
		"Latein", "Griechisch",
		"Musik", "BildendeKunst", "DarstellendesSpiel",
		"Politikwissenschaft", "Geschichte", "Geografie",
		"Sozialwissenschaften", "Psychologie", "Philosophie", "Recht",
		"Wirtschaftswissenschaft", "Pädagogik", "RechnungswesenUndControlling", "Wirtschaft",
		"Mathematik", "Physik", "Chemie", "Biologie", "Informatik",
		"Physiktechnik", "Physiklabortechnik", "Elektrotechnik", "RegenerativeEnergietechnik",
		"Bautechnik", "Mechatronik", "Metalltechnik_Maschinenbau",
		"Chemietechnik", "Chemielabortechnik",
		"Biologietechnik", "Biologielabortechnik", "Biotechnologie", "AgrartechnikMitBiologie",
		"Gesundheit", "Ernährung", "Medizintechnik", "Umwelttechnik",
		"Wirtschaftsinformatik", "TechnischeInformatik", "Medizininformatik", "Informationstechnik",
		"Medientechnik", "GestaltungsMedientechnik", "Gestaltung",
		"Sport"}
	s[Subject] = []string{"  ",
		"de", "e ", "f ", "i ", "s ",
		"p ", "r ", "t ", "j ", "c ",
		"l ", "g ",
		"mu", "ku", "ds",
		"pw", "ge", "gg",
		"sw", "ps", "ph", "re",
		"ww", "pa", "rc", "wi",
		"ma", "ph", "ch", "bi", "in",
		"pt", "pt", "et", "rt",
		"bt", "me", "mm",
		"ct", "c",
		"bt", "bt", "bt", "ab",
		"gs", "er", "me", "ut",
		"wi", "ti", "mi", "it",
		"mt", "gm", "gt",
		"sp"}

	l[LexicalCategory] = []string{"",
		"Substantiv", "Adjektiv", "Pronomen", "Numerale",
		"Verb", "Adverb", "Präposition", "Konjunktion", "Interjektion"}
	s[LexicalCategory] = []string{"",
		"Subst.", "Adj.", "Pron.", "Num.",
		"Verb", "Adv.", "Präp.", "Konj.", "Interj."}

	l[Casus] = []string{"",
		"Nominativ", "Genitiv", "Dativ", "Akkusativ", "Ablativ"}
	s[Casus] = []string{"",
		"Nom.", "Gen.", "Dat.", "Akk.", "Abl."}

	l[Genus] = []string{"",
		"masc.", "fem.", "neut."}
	//                        "maskulinum", "femininum", "neutrum" }
	s[Genus] = []string{"",
		"m.", "f.", "n."}

	l[Persona] = []string{"",
		"1.", "2.", "3."}
	s[Persona] = l[Persona]

	l[Numerus] = []string{"",
		"Sing.", "Plur."}
	//                          "Singular", "Plural" }
	s[Numerus] = []string{"",
		"Sg.", "Pl."}

	l[Tempus] = []string{"",
		"Präsens", "Imperfekt", "FuturI", "Perfekt", "Plusquamp.", "FuturII"}
	s[Tempus] = []string{"",
		"Präs.", "Impf.", "Fut.I", "Perf.", "Plusq.", "Fut.II"}

	l[Modus] = []string{"",
		"Indikativ", "Konjunktiv"}
	s[Modus] = []string{"",
		"Ind.", "Konj."}

	l[GenusVerbi] = []string{"",
		"Aktiv", "Passiv"}
	s[GenusVerbi] = []string{"",
		"Akt.", "Pass."}
}