Example #1
0
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
}
Example #2
0
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
}
Example #3
0
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
}
Example #4
0
func (x *Imp) Defined(s string) bool {
	//
	var n uint
	if nat.Defined(&n, s) {
		x.n = n
		return true
	}
	return false
}
Example #5
0
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
}
Example #6
0
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
}
Example #7
0
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)
}
Example #8
0
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
			}
		}
	}
}
Example #9
0
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
}
Example #10
0
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)
}