Esempio n. 1
0
func (x *Imp) String() string {
	//
	if x.r == x.invalid {
		return str.Clr(x.wd)
	}
	s := real.String(x.r)
	str.Move(&s, true)
	str.RemSpaces(&s)
	str.Norm(&s, x.wd)
	str.Move(&s, false)
	return s
}
Esempio n. 2
0
func (x *Imp) Edit(Z, S uint) {
	//
	x.Write(Z, S)
	bx.Edit(&x.text, Z, S)
	str.Move(&x.text, true)
	x.Write(Z, S)
}
Esempio n. 3
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
}
Esempio n. 4
0
func string_(x float64) string {
	//
	s := strconv.FormatFloat(x, 'f', 2, 64)
	str.Move(&s, true)
	str.RemSpaces(&s)
	return s
}
Esempio n. 5
0
func defined(s string) (float64, bool) {
	//
	str.Move(&s, true)
	str.RemSpaces(&s)
	r, e := strconv.ParseFloat(s, 64)
	if e != strconv.ErrSyntax {
		return r, true
	}
	return math.NaN(), false
}
Esempio n. 6
0
func EditActual(Z, S uint) {
	//
	actual.Write(Z, S)
	bx.Edit(&actual.text, Z, S)
	str.Move(&actual.text, true)
	str.RemSpaces(&actual.text)
	str.Norm(&actual.text, length)
	actual.Write(Z, S)
	file.Seek(0)
	file.Put(actual.text)
}
Esempio n. 7
0
func (x *Imp) String() string {
	//
	if x.denom == 0 {
		return "Zähler/Nenner"
	}
	s := nat.StringFmt(x.num, 9, false)
	str.Move(&s, true)
	str.RemSpaces(&s)
	if !x.geq0 {
		s = "-" + s
	}
	if x.denom == 1 {
		return s
	}
	s += "/"
	t := nat.StringFmt(x.denom, 9, false)
	str.Move(&t, true)
	str.RemSpaces(&t)
	return s + t
}
Esempio n. 8
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
}
Esempio n. 9
0
func (x *Imp) Name(s string) {
	//
	x.name = s
	str.Move(&x.name, true)
	str.RemSpaces(&x.name)
	n := pseq.Length(x.name)
	if n > 0 {
		buf := make([]byte, n)
		f := pseq.New(buf)
		f.Name(x.name)
		buf = f.Get().([]byte)
		f.Terminate()
		x.Decode(buf)
	}
}
Esempio n. 10
0
func (x *Imp) Rename(s string) {
	//
	x.name = s
	str.Move(&x.name, true)
	str.RemSpaces(&x.name)
	// rest of implementation TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO
	n := pseq.Length(x.name)
	if n > 0 {
		buf := make([]byte, n)
		f := pseq.New(buf)
		f.Rename(x.name)
		//    buf = f.Get ().([]byte)
		f.Terminate()
		//    x.Decode (buf)
	}
}
Esempio n. 11
0
func defined(n *uint, s string) bool {
	//
	if s == "" {
		return false
	}
	str.Move(&s, true)
	l := str.ProperLen(s)
	*n = uint(0)
	var b byte
	for i := 0; i < int(l); i++ {
		if isDigit(s[i]) {
			b = s[i] - '0'
			if *n <= (MaxNat-uint(b))/10 {
				*n = 10**n + uint(b)
			} else {
				return false
			}
		} else {
			return false
		}
	}
	return true
}
Esempio n. 12
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
}
Esempio n. 13
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)
}