Update functions.c

functions.c

@@ -1 +1,208 @@
-test
+test
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include "str.h"
+#include "util.h"
+
+#define INIT_SZ 20
+
+// Внутренняя функция,
+// позволяет убедиться что строка может вместить как минимум newsz символов
+void
+_str_ensure(str *s, int newsz)
+{
+    int tmp;
+        newsz += 1; // добавляем единичку чтобы влез нулевой байт
+            if (newsz < s->capacity)
+                    return;
+
+                        tmp = s->capacity * 2;
+                            if (tmp > newsz) {
+                                    newsz = tmp;
+                                        }
+                                            s->ptr = xrealloc(s->ptr, newsz);
+                                                s->capacity = newsz;
+                                                }
+
+                                                void
+                                                str_init(str *s)
+                                                {
+                                                    assert(s);
+                                                        s->len = 0;
+                                                            s->capacity = INIT_SZ;
+                                                                s->ptr = xmalloc(s->capacity);
+                                                                    s->ptr[0] = '\0';
+                                                                    }
+
+                                                                    void
+                                                                    str_deinit(str *s)
+                                                                    {
+                                                                        if (s->ptr)
+                                                                                free(s->ptr);
+                                                                                    s->ptr = NULL;
+                                                                                        s->len = 0;
+                                                                                            s->capacity = 0;
+                                                                                            }
+
+                                                                                            void
+                                                                                            str_init_data(str *s, const char *initial)
+                                                                                            {
+                                                                                                assert(s && initial);
+                                                                                                    int len = strlen(initial);
+                                                                                                        s->len = len;
+                                                                                                            s->capacity = len + 1;
+                                                                                                                if (s->capacity < INIT_SZ) {
+                                                                                                                        s->capacity = INIT_SZ;
+                                                                                                                            }
+                                                                                                                                s->ptr = xmalloc(s->capacity);
+                                                                                                                                    strcpy(s->ptr, initial);
+                                                                                                                                    }
+
+                                                                                                                                    char *
+                                                                                                                                    str_data(str *s)
+                                                                                                                                    {
+                                                                                                                                        assert(s);
+                                                                                                                                            return s->ptr;
+                                                                                                                                            }
+
+                                                                                                                                            void
+                                                                                                                                            str_set(str *s, char *cstr)
+                                                                                                                                            {
+                                                                                                                                                assert(s && cstr);
+                                                                                                                                                    int len = strlen(cstr);
+                                                                                                                                                        _str_ensure(s, len);
+                                                                                                                                                            strcpy(s->ptr, cstr);
+                                                                                                                                                                s->len = len;
+                                                                                                                                                                }
+
+                                                                                                                                                                str
+                                                                                                                                                                str_copy(str *s)
+                                                                                                                                                                {
+                                                                                                                                                                    assert(s);
+                                                                                                                                                                        str new_str;
+                                                                                                                                                                            str_init(&new_str);
+                                                                                                                                                                                _str_ensure(&new_str, s->len);
+                                                                                                                                                                                    strcpy(new_str.ptr, s->ptr);
+                                                                                                                                                                                        new_str.len = s->len;
+                                                                                                                                                                                            return new_str;
+                                                                                                                                                                                            }
+
+                                                                                                                                                                                            int
+                                                                                                                                                                                            str_count(str *s, char ch)
+                                                                                                                                                                                            {
+                                                                                                                                                                                                assert(s);
+                                                                                                                                                                                                    int count = 0;
+                                                                                                                                                                                                        for (int i = 0; i < s->len; i++) {
+                                                                                                                                                                                                                if (s->ptr[i] == ch) {
+                                                                                                                                                                                                                            count++;
+                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                            return count;
+                                                                                                                                                                                                                                            }
+
+                                                                                                                                                                                                                                            void
+                                                                                                                                                                                                                                            str_append(str *s, char *cstr)
+                                                                                                                                                                                                                                            {
+                                                                                                                                                                                                                                                assert(s && cstr);
+                                                                                                                                                                                                                                                    str_append_n(s, cstr, strlen(cstr));
+                                                                                                                                                                                                                                                    }
+
+                                                                                                                                                                                                                                                    void
+                                                                                                                                                                                                                                                    str_append_n(str *s, char *cstr, int len)
+                                                                                                                                                                                                                                                    {
+                                                                                                                                                                                                                                                        assert(s && cstr);
+                                                                                                                                                                                                                                                            _str_ensure(s, s->len + len);
+                                                                                                                                                                                                                                                                memcpy(s->ptr + s->len, cstr, len);
+                                                                                                                                                                                                                                                                    s->len += len;
+                                                                                                                                                                                                                                                                        s->ptr[s->len] = '\0';
+                                                                                                                                                                                                                                                                        }
+
+                                                                                                                                                                                                                                                                        void
+                                                                                                                                                                                                                                                                        str_shrink(str *s, int len)
+                                                                                                                                                                                                                                                                        {
+                                                                                                                                                                                                                                                                            assert(s && len >= 0);
+                                                                                                                                                                                                                                                                                if (len > s->len) {
+                                                                                                                                                                                                                                                                                        len = s->len;
+                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                s->len = len;
+                                                                                                                                                                                                                                                                                                    s->ptr[s->len] = '\0';
+                                                                                                                                                                                                                                                                                                    }
+
+                                                                                                                                                                                                                                                                                                    int
+                                                                                                                                                                                                                                                                                                    str_find(str *s, char *substr)
+                                                                                                                                                                                                                                                                                                    {
+                                                                                                                                                                                                                                                                                                        assert(s && substr);
+                                                                                                                                                                                                                                                                                                            char *p = strstr(s->ptr, substr);
+                                                                                                                                                                                                                                                                                                                if (p == NULL)
+                                                                                                                                                                                                                                                                                                                        return -1;
+                                                                                                                                                                                                                                                                                                                            return p - s->ptr;
+                                                                                                                                                                                                                                                                                                                            }
+
+                                                                                                                                                                                                                                                                                                                            str
+                                                                                                                                                                                                                                                                                                                            str_sub(str *s, int start_idx, int length)
+                                                                                                                                                                                                                                                                                                                            {
+                                                                                                                                                                                                                                                                                                                                assert(s && start_idx >= 0 && length >= 0);
+
+                                                                                                                                                                                                                                                                                                                                    str s2;
+                                                                                                                                                                                                                                                                                                                                        str_init(&s2);
+                                                                                                                                                                                                                                                                                                                                            
+                                                                                                                                                                                                                                                                                                                                                if (start_idx >= s->len) {
+                                                                                                                                                                                                                                                                                                                                                        return s2; // пустая строка
+                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                
+                                                                                                                                                                                                                                                                                                                                                                    if (start_idx + length > s->len) {
+                                                                                                                                                                                                                                                                                                                                                                            length = s->len - start_idx;
+                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                    
+                                                                                                                                                                                                                                                                                                                                                                                        _str_ensure(&s2, length);
+                                                                                                                                                                                                                                                                                                                                                                                            memcpy(s2.ptr, s->ptr + start_idx, length);
+                                                                                                                                                                                                                                                                                                                                                                                                s2.ptr[length] = '\0';
+                                                                                                                                                                                                                                                                                                                                                                                                    s2.len = length;
+                                                                                                                                                                                                                                                                                                                                                                                                        
+                                                                                                                                                                                                                                                                                                                                                                                                            return s2;
+                                                                                                                                                                                                                                                                                                                                                                                                            }
+
+                                                                                                                                                                                                                                                                                                                                                                                                            // Hint: you can create temporary string object!
+                                                                                                                                                                                                                                                                                                                                                                                                            int
+                                                                                                                                                                                                                                                                                                                                                                                                            str_replace(str *s, char *substr, char *replacement)
+                                                                                                                                                                                                                                                                                                                                                                                                            {
+                                                                                                                                                                                                                                                                                                                                                                                                                assert(s && substr && replacement);
+                                                                                                                                                                                                                                                                                                                                                                                                                    
+                                                                                                                                                                                                                                                                                                                                                                                                                        int count = 0;
+                                                                                                                                                                                                                                                                                                                                                                                                                            str result;
+                                                                                                                                                                                                                                                                                                                                                                                                                                str_init(&result);
+                                                                                                                                                                                                                                                                                                                                                                                                                                    
+                                                                                                                                                                                                                                                                                                                                                                                                                                        int substr_len = strlen(substr);
+                                                                                                                                                                                                                                                                                                                                                                                                                                            int replacement_len = strlen(replacement);
+                                                                                                                                                                                                                                                                                                                                                                                                                                                
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    char *current = s->ptr;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        char *found;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                while ((found = strstr(current, substr)) != NULL) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Добавляем часть до найденной подстроки
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                int prefix_len = found - current;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if (prefix_len > 0) {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    str_append_n(&result, current, prefix_len);
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Добавляем замену
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    str_append_n(&result, replacement, replacement_len);
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    current = found + substr_len;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            count++;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Добавляем оставшуюся часть строки
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (*current != '\0') {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    str_append(&result, current);
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // Заменяем исходную строку результатом
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    free(s->ptr);
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s->ptr = result.ptr;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            s->len = result.len;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                s->capacity = result.capacity;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        return count;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }