init here

исх/строка/строка.tri

@@ -0,0 +1,184 @@
+модуль строка
+
+импорт "стд::строки"
+импорт "стд::юникод"
+импорт "исх/массивы"
+
+тип Байты = []Байт
+
+фн tri_substring(с: Строка8, первый-байт: Цел64, число-байтов: Цел64): Строка @внеш
+фн tri_substring_from_bytes(байты: Байты, первый-байт: Цел64, число-байтов: Цел64): Строка @внеш
+
+фн заменить*(с: Строка, подстрока: Строка, замена: Строка): Строка {
+    надо длина(подстрока) > 0 иначе вернуть с
+
+    пусть с8 = с(:Строка8)
+    пусть п8 = подстрока(:Строка8)
+    
+    пусть № := индекс(с, 0, подстрока)
+    надо № >= 0 иначе вернуть с
+    
+    пусть сб = строки.Сборщик{}
+    пусть №-старт := 0
+    пока истина {
+        сб.добавить строку(строки.извлечь(с8(:Строка), №-старт, № - №-старт))
+        сб.добавить строку(замена)
+        
+        №-старт := № + длина(п8)
+        № := индекс(с, №-старт, подстрока)
+        надо № >= 0 иначе прервать
+        надо №-старт < длина(замена) иначе прервать
+    }
+    сб.добавить строку(строки.извлечь(с8(:Строка), №-старт, длина(с8) - №-старт))
+
+    вернуть сб.строка()
+}
+
+фн разобрать*(с: Строка, разделитель: Строка): массивы.Строки {
+    пусть р8 = разделитель(:Строка8)
+
+    выбор длина(р8) {
+    когда 0: вернуть массивы.Строки[с]
+    когда 1: 
+        вернуть разобрать1(с, р8[0])
+    другое
+        авария("не реализовано - длина разделителя > 1")
+    }
+    вернуть массивы.Строки[]
+}
+
+фн соединить*(разделитель: Строка, строчки: ...Строка): Строка {
+    вернуть строки.соединить(разделитель, строчки...)
+}
+
+фн ф*(формат: Строка, аргументы: ...*): Строка {
+    пусть сб = строки.Сборщик{}
+    сб.ф(формат, аргументы...)
+    вернуть сб.строка()
+}
+
+фн разобрать1(с: Строка, разделитель: Байт): массивы.Строки {
+    пусть рез = массивы.Строки[]
+    пусть с8 = с(:Строка8)
+    пусть № := 0
+    пусть №-разд := -1
+    пока № < длина(с8) {
+        если с8[№] = разделитель  {
+            если №-разд + 1 = № {
+                рез.добавить("")
+            } иначе {
+                рез.добавить(tri_substring(с8, №-разд+1, № - №-разд - 1))
+            }
+            №-разд := №
+        }
+        №++
+    }
+    рез.добавить(tri_substring(с8, №-разд+1, длина(с8) - №-разд - 1))
+    
+    вернуть рез
+}
+
+фн собрать*(список строк: ...Строка): Строка {
+    надо длина(список строк) > 0 иначе вернуть ""
+
+    пусть размер := 0
+    пусть № := 0
+    пока № < длина(список строк) {
+        размер := размер + длина(список строк[№](:Строка8))
+        №++
+    }
+
+    пусть сб = строки.Сборщик{}
+    № := 0
+    пока № < длина(список строк) {
+        сб.добавить строку(список строк[№])
+        №++
+    }
+
+    вернуть сб.строка()
+}
+
+фн индекс*(с: Строка, №-старт: Цел64, подстрока: Строка): Цел64 {
+    вернуть строки.индекс(с, №-старт, подстрока)
+}
+
+фн извлечь*(с: Строка, №-байта: Цел64, число-байтов: Цел64): Строка {
+    вернуть строки.извлечь(с, №-байта, число-байтов)
+}
+
+фн обрезать пробельные символы*(с: Строка): Строка {
+
+    пусть с8 = с(:Строка8)
+    пусть №1 := 0
+    пока №1 < длина(с8) {
+        надо с8[№1] < 0x80(:Байт) иначе прервать
+        надо юникод.пробельный символ?(с8[№1](:Символ)) иначе прервать
+        №1++
+    }
+
+    пусть №2 := длина(с8) 
+    пока №2 > №1 {
+        пусть байт = с8[№2-1]
+        надо  байт < 0x80(:Байт) иначе прервать
+        надо юникод.пробельный символ?(байт(:Символ)) иначе прервать
+        №2--
+    }
+    
+    вернуть tri_substring(с8, №1, №2 - №1)
+}
+
+фн разделить*(с: Строка, разделитель: Строка, первая := Строка, вторая := Строка): Лог {
+
+    пусть и = индекс(с, 0, разделитель)
+    надо и >= 0 иначе {
+        первая := с
+        вторая := ""
+        вернуть ложь
+    }
+
+    пусть с8 = с(:Строка8)
+    пусть р8 = разделитель(:Строка8)
+
+    первая := tri_substring(с8, 0, и)
+    вторая := tri_substring(с8, и + длина(р8), длина(с8) - (и +длина(р8)))
+
+    вернуть истина
+}
+
+фн извлечь цел*(с: Строка, №-байта := Цел64, рез := Цел64): Лог {
+    рез := 0
+    
+    пусть с8 = с(:Строка8)
+    надо №-байта < длина(с8) иначе вернуть ложь
+
+    пусть нег = с8[№-байта] =  '-'(:Байт)
+    если нег | с8[№-байта] =  '+'(:Байт) {
+        №-байта++
+        надо №-байта < длина(с8) иначе вернуть ложь
+    }
+    
+    пусть сим := с8[№-байта](:Символ)
+    надо сим >= '0' & сим <= '9' иначе вернуть ложь
+
+    пусть число := 0
+    пока истина {
+        пусть цифра = сим(:Цел64) - '0'(:Цел64)
+        
+        // проверка выхода за границу
+        надо число <= (0x7FFFFFFFFFFFFFFF(:Цел64) - цифра) / 10 иначе вернуть ложь
+        
+        число := число*10 + цифра
+        №-байта++
+        если №-байта >= длина(с8) { 
+            если нег {
+                число := - число
+            }
+            рез := число
+            вернуть истина
+        }
+        сим := с8[№-байта](:Символ)
+
+        надо сим >= '0' & сим <= '9' иначе прервать
+    }
+    вернуть ложь
+}