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
}
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)
}
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 string_(x float64) string {
//
s := strconv.FormatFloat(x, 'f', 2, 64)
str.Move(&s, true)
str.RemSpaces(&s)
return s
}
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
}
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)
}
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
}
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) 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)
}
}
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)
}
}
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
}
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(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)
}
