func (x *Imp) Defined(s string) bool {
//
if uint(len(s)) > x.wd {
return false
}
str.RemAllSpaces(&s)
// n:= x.wd / 2
// P, L:= make ([]uint, n), make ([]uint, n)
// n = nat.NDigitSequences (s, &P, &L)
n, t, p, l := nat.DigitSequences(s)
if n == 0 || n > 2 || l[0] > x.pre {
return false
}
if n == 2 {
c := s[p[1]-1]
if l[1] > 2 || !(c == '.' || c == ',') {
return false
}
}
var n1 uint
nat.Defined(&n1, t[0])
x.r = float64(n1)
if n == 2 {
nat.Defined(&n, t[1])
if n < 10 {
n *= 10
}
x.r = x.r + float64(n)/100
}
if s[0] == '-' {
x.r = -x.r
}
return true
}
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
}
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
}
func (x *Imp) Defined(s string) bool {
//
var n uint
if nat.Defined(&n, s) {
x.n = n
return true
}
return false
}
func (x *Imp) Defined(s string) bool {
//
if str.Empty(s) {
x.Clr()
return true
}
i := uint(0)
str.Move(&s, true)
l := str.ProperLen(s)
if str.Contains(s, ' ', &i) && s[0] == '0' {
n := uint(0)
if nat.Defined(&n, s[1:i]) { // i <= l
x.prefix = uint16(n)
if l == i {
return false
}
s = s[i:l]
} else {
return false
}
} else {
x.prefix = 0
}
str.Move(&s, true)
str.RemAllSpaces(&s)
if s == "" {
x.number = uint(x.prefix)
x.prefix = 0
return true
}
if nat.Defined(&x.number, s) {
return true
} else {
x.prefix = 0
x.number = 0
}
return false
}
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
}
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)
}
func (x *Imp) Edit(N, N1 node.Node, directed bool) {
//
n, n1 := N.(*node.Imp), N1.(*node.Imp)
x.Write(n, n1, directed, true, false)
x0, y0, _, _, _ := x.pos(n, n1, directed)
if zk == 0 || !WithValues {
/* accept only Del
_, c, _:= kbd.Read () // ?
if c == kbd.Del { x.val = 0 }
*/
} else {
T := nat.StringFmt(x.val, zk, false)
bx.ColourF(Farbe[0])
for {
bx.EditGr(&T, x0, y0)
if nat.Defined(&x.val, T) {
break
}
}
}
}
func (x *Imp) Defined(s string) bool {
//
if str.Empty(s) {
x.cent = undefined
return true
}
a, t, P, L := nat.DigitSequences(s)
var k uint
hatKomma := str.Contains(s, ',', &k)
if !hatKomma {
hatKomma = str.Contains(s, '.', &k)
}
var n uint
if !nat.Defined(&n, t[0]) {
return false
}
switch a {
case 1:
if hatKomma && k < P[0] { // Komma vor der Ziffernfolge
switch L[0] {
case 1:
x.cent = 10 * n
case 2:
x.cent = n
default:
return false
}
return true
}
if hatKomma && k >= P[0]+L[0] || !hatKomma {
if L[0] <= nDigits {
x.cent = hundred * n
return true
}
}
case 2:
if !hatKomma {
return false
}
if k < P[0]+L[0] || P[1] <= k {
return false
}
if L[0] > nDigits {
return false
} else {
x.cent = hundred * n
}
if !nat.Defined(&n, t[1]) {
return false
}
switch L[1] {
case 1:
x.cent += 10 * n
case 2:
x.cent += n
default:
return false
}
return true
}
return false
}
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)
}