// 2025-2026 Богданович Давид Когут Прихожденко

взяти визначення КД;
взяти визначення мавка;
взяти визначення мавка/розбирач;

простір мавка {
  внутрішня дія КД_виділити_сиру_памʼять(система: *КД::Система, розмір: природне) -> *п8 {
    змінна М = система.дані як *Машина;
    вернути виділити<п8>(М, розмір);
  }

  внутрішня дія КД_перевиділити_сиру_памʼять(система: *КД::Система, значення: *п8, новий_розмір: природне) -> *п8 {
    змінна М = система.дані як *Машина;
    вернути перевиділити<п8>(М, значення, новий_розмір);
  }

  внутрішня дія КД_звільнити_сиру_памʼять(система: *КД::Система, значення: адреса) {
    змінна М = система.дані як *Машина;
    звільнити(М, значення);
  }

  дія перекодувати_ю8_в_кд(М: *Машина, значення: ю8, вихід: *кд, вихід_позиції_помилки: *природне) -> логічне {
    змінна система_КД = КД::Система {
      дані = М,
      виділити_сиру_памʼять = КД_виділити_сиру_памʼять,
      звільнити_сиру_памʼять = КД_звільнити_сиру_памʼять,
      перевиділити_сиру_памʼять = КД_перевиділити_сиру_памʼять
    };

    вернути КД::перекодувати_з_ю8(
      система_КД::адреса,
      значення,
      ні,
      так,
      вихід,
      вихід_позиції_помилки
    );
  }

  дія перекодувати_кд_в_ю8(М: *Машина, значення: кд, вихід: *ю8, вихід_позиції_помилки: *природне) -> логічне {
    змінна система_КД = КД::Система {
      дані = М,
      виділити_сиру_памʼять = КД_виділити_сиру_памʼять,
      звільнити_сиру_памʼять = КД_звільнити_сиру_памʼять,
      перевиділити_сиру_памʼять = КД_перевиділити_сиру_памʼять
    };

    вернути КД::перекодувати_в_ю8(
      система_КД::адреса,
      значення,
      так,
      вихід,
      вихід_позиції_помилки
    );
  }

  внутрішня дія єрозділшляху(М: *Машина, значення: п8) -> логічне {
    вернути значення == М.налаштування.розділювач_шляху або значення == КД::символи::Похила;
  }

  дія отримати_шлях_до_паку_з_шляху_теки_модулів(
    М: *Машина,
    шлях_до_теки_модулів: *ПредметТексту,
    шлях_до_теки_паків: *ПредметТексту,
    вихід: **ПредметТексту
  ) -> логічне {
    змінна п: природне;
    змінна позиція_наступного_слешу: природне;
    змінна початок: природне;
    змінна знайдено: логічне;

    якщо шлях_до_теки_модулів.значення.розмір <= шлях_до_теки_паків.значення.розмір {
      вернути ні;
    }

    п = 0;
    поки п < шлях_до_теки_паків.значення.розмір {
      якщо шлях_до_теки_модулів.значення.дані[п] != шлях_до_теки_паків.значення.дані[п] {
        вернути ні;
      }

      п += 1;
    }

    позиція_наступного_слешу = 0;
    знайдено = ні;

    початок = шлях_до_теки_паків.значення.розмір;
    якщо початок < шлях_до_теки_модулів.значення.розмір і єрозділшляху(М, шлях_до_теки_модулів.значення.дані[початок]) {
      початок += 1;
    }

    п = початок;
    поки п < шлях_до_теки_модулів.значення.розмір {
      якщо єрозділшляху(М, шлях_до_теки_модулів.значення.дані[п]) {
        позиція_наступного_слешу = п;
        знайдено = так;
        стрибнути к1;
      }

      п += 1;
    }

  к1:
    якщо не знайдено {
      позиція_наступного_слешу = шлях_до_теки_модулів.значення.розмір;
    }

    змінна розмір = позиція_наступного_слешу;
    змінна дані = виділити<п8>(М, розмір);
    якщо дані == пусто {
      вернути ні;
    }

    п = 0;
    поки п < позиція_наступного_слешу {
      дані[п] = шлях_до_теки_модулів.значення.дані[п];

      п += 1;
    }

    вихід::вміст = створити_текст_без_копіювання(
      М,
      розмір,
      дані
    );

    вернути так;
  }

  дія збити_шлях_до_модуля(
    М: *Машина,
    кількість_елементів: природне,
    елементи: **ПредметТексту,
  ) -> *ПредметТексту {
    змінна п: природне;
    змінна суфікс = ".м";
    змінна загальний_розмір = (кількість_елементів - 1) + суфікс.розмір;

    п = 0;
    поки п < кількість_елементів {
      загальний_розмір += елементи[п].значення.розмір;

      п += 1;
    }

    змінна дані = виділити<п8>(М, загальний_розмір);
    якщо дані == пусто {
      вернути пусто;
    }

    змінна позиція: природне = 0;

    п = 0;
    поки п < кількість_елементів {
      змінна пп: природне = 0;
      поки пп < елементи[п].значення.розмір {
        дані[позиція] = елементи[п].значення.дані[пп];
        позиція += 1;

        пп += 1;
      }

      якщо п < (кількість_елементів - 1) {
        дані[позиція] = М.налаштування.розділювач_шляху;
        позиція += 1;
      }

      п += 1;
    }

    п = 0;
    поки п < суфікс.розмір {
      дані[позиція] = суфікс.дані[п];
      позиція += 1;

      п += 1;
    }

    вернути створити_текст_без_копіювання(
      М,
      загальний_розмір,
      дані
    );
  }

  внутрішня дія отримати_теку(М: *Машина, шлях: кд) -> кд {
    якщо шлях.розмір == 0 {
      вернути ".";
    }

    поки (шлях.розмір > 1) і єрозділшляху(М, шлях.дані[шлях.розмір - 1]) {
      шлях.розмір -= 1;
    }

    якщо (шлях.розмір == 1) і єрозділшляху(М, шлях.дані[0]) {
      вернути шлях;
    }

    змінна пс: природне = шлях.розмір;
    змінна знайдено_пс = ні;
    поки пс > 0 {
      пс -= 1;

      якщо єрозділшляху(М, шлях.дані[пс]) {
        знайдено_пс = так;
        стрибнути далі;
      }
    }

  далі:
    якщо знайдено_пс {
      якщо пс == 0 {
        вернути "/";
      } інакше {
        шлях.розмір = пс;
      }
      вернути шлях;
    }

    вернути ".";
  }

  дія отримати_теку_шляху(
    М: *Машина,
    шлях: *ПредметТексту,
    глибина: природне,
  ) -> *ПредметТексту {
    змінна п: природне;
    змінна тека: кд;

    тека = шлях.значення;

    п = 0;
    поки п < глибина {
      тека = отримати_теку(М, тека);

      п += 1;
    }

    змінна д = виділити<п8>(М, тека.розмір);
    п = 0;
    поки п < тека.розмір {
      д[п] = тека.дані[п];

      п += 1;
    }

    вернути створити_текст_без_копіювання(М, тека.розмір, д);
  }

  дія отримати_теку_до_паків(
    М: *Машина,
    шлях: *ПредметТексту,
  ) -> *ПредметТексту {
    змінна доповнення = "паки";
    змінна п: природне;
    змінна пп: природне;
    змінна закінчується_рш = ні;

    якщо шлях.значення.розмір > 0 {
      закінчується_рш = єрозділшляху(М, шлях.значення.дані[шлях.значення.розмір - 1]);
    }

    змінна розмір = шлях.значення.розмір + природне(не закінчується_рш) + доповнення.розмір;
    змінна дані = виділити<п8>(М, розмір);

    п = 0;
    поки п < шлях.значення.розмір {
      дані[п] = шлях.значення.дані[п];
      п += 1;
    }

    якщо не закінчується_рш {
      дані[п] = М.налаштування.розділювач_шляху;
      п += 1;
    }

    пп = 0;
    поки пп < доповнення.розмір {
      дані[п] = доповнення.дані[пп];
      п += 1;

      пп += 1;
    }

    вернути створити_текст_без_копіювання(
      М,
      розмір,
      дані,
    );
  }

  внутрішня дія базованазва(М: *Машина, шлях: кд) -> кд {
    якщо шлях.розмір == 0 {
      вернути ".";
    }

    поки (шлях.розмір > 1) і єрозділшляху(М, шлях.дані[шлях.розмір - 1]) {
      шлях.розмір -= 1;
    }

    якщо (шлях.розмір == 1) і єрозділшляху(М, шлях.дані[0]) {
      вернути шлях;
    }

    змінна пс: природне = шлях.розмір;
    змінна знайдено_пс = ні;
    поки пс > 0 {
      пс -= 1;

      якщо єрозділшляху(М, шлях.дані[пс]) {
        знайдено_пс = так;
        стрибнути далі;
      }
    }

  далі:
    якщо знайдено_пс {
      вернути кд { шлях.дані[пс + 1]::адреса, шлях.розмір - (пс + 1) };
    }

    вернути шлях;
  }

  дія отримати_назву_модуля_з_шляху(
    М: *Машина,
    шлях_до_файлу: *ПредметТексту,
  ) -> *ПредметТексту {
    змінна суфікс = ".м";
    змінна назва = базованазва(М, шлях_до_файлу.значення);
    змінна п: природне;

    якщо назва.розмір >= суфікс.розмір {
      змінна має_суфікс = так;

      п = 0;
      поки п < суфікс.розмір {
        якщо назва.дані[назва.розмір - суфікс.розмір + п] != суфікс.дані[п] {
          має_суфікс = ні;
          стрибнути вийти_поки1;
        }

        п += 1;
      }

  вийти_поки1:
      якщо має_суфікс {
        назва.розмір -= суфікс.розмір;
      }
    }

    вернути створити_текст(М, назва);
  }

  дія розібрати_шлях_початкового_модуля(
    М: *Машина,
    шлях: *ПредметТексту,
    вихід_абсолютного_шляху: **ПредметТексту,
    вихід_теки_модулів: **ПредметТексту,
    вихід_теки_паків: **ПредметТексту,
    вихід_назви_модуля: **ПредметТексту
  ) -> логічне {
    змінна успіх: логічне;

    успіх = перевірити_чи_шлях_існує_і_є_файлом(
      М,
      шлях,
    );
    якщо не успіх {
      вернути ні;
    }

    вихід_абсолютного_шляху::вміст = отримати_абсолютний_шлях(
      М,
      шлях,
    );
    якщо вихід_абсолютного_шляху::вміст == пусто {
      вернути ні;
    }

    вихід_теки_модулів::вміст = отримати_теку_шляху(
      М,
      вихід_абсолютного_шляху::вміст,
      1,
    );
    якщо вихід_теки_модулів::вміст == пусто {
      вернути ні;
    }

    вихід_теки_паків::вміст = отримати_теку_до_паків(
      М,
      вихід_теки_модулів::вміст,
    );
    якщо вихід_теки_паків::вміст == пусто {
      вернути ні;
    }

    вихід_назви_модуля::вміст = отримати_назву_модуля_з_шляху(
      М,
      вихід_абсолютного_шляху::вміст,
    );
    якщо вихід_назви_модуля::вміст == пусто {
      вернути ні;
    }

    вернути так;
  }
}