Утилізатор.ц

взяти визначення МаМа;

секція МаМа {
  місцева дія зробити_утилізатор(М: адреса<Машина>): Утилізатор {
    ціль утилізатор: Утилізатор;
    утилізатор.останній_предмет = пусто;
    утилізатор.кількість_предметів = 0;
    утилізатор.кількість_предметів_щоб_запустити_утилізацію = 0;
    утилізатор.кількість_середовищ_щоб_запустити_утилізацію = 0;
    утилізатор.початок_середовищ = пусто;
    утилізатор.кількість_середовищ = 0;
    вернути утилізатор;
  }

  місцева дія позначити(М: адреса<Машина>) {
    змінна ціль п: позитивне = 0;
    поки п < М.сховище_констант.розмір {
      позначити_предмет(М, М.сховище_констант.дані[п]);
      п += 1;
    }
    змінна ціль пів: позитивне = 0;
    поки пів < М.історія.розмір {
      позначити_предмет_дії(М, М.історія.дані[пів].предмет_дії);
      позначити_середовище(М, М.історія.дані[пів].середовище);
      пів += 1;
    }
    п = 0;
    поки п < М.історія_виконання_перед_падінням.розмір {
      позначити_предмет(М, М.історія_виконання_перед_падінням.дані[п]);
      п += 1;
    }
    п = 0;
    поки п < М.НатО.розмір {
      позначити_предмет(М, М.НатО.дані[п]);
      п += 1;
    }
    п = 0;
    поки п < М.НаО.розмір {
      позначити_предмет(М, М.НаО.дані[п]);
      п += 1;
    }
    п = 0;
    поки п < М.НаРАрг.розмір {
      змінна ціль р: позитивне = 0;
      поки р < М.НаРАрг.дані[п].розмір {
        позначити_предмет(М, М.НаРАрг.дані[п].елементи[р].значення);
        р += 1;
      }
      п += 1;
    }
    п = 0;
    поки п < М.НаРПар.розмір {
      змінна ціль р: позитивне = 0;
      поки р < М.НаРПар.дані[п].розмір {
        змінна ціль пр: позитивне = 0;
        поки пр < М.НаРПар.дані[п].елементи[р].значення.типи.розмір {
          позначити_предмет_структури(М, М.НаРПар.дані[п].елементи[р].значення.типи.дані[пр]);
          пр = пр + 1;
        }
        р += 1;
      }
      п += 1;
    }
    п = 0;
    поки п < М.НаОТ.розмір {
      позначити_предмет(М, М.НаОТ.дані[п]);
      п += 1;
    }
    п = 0;
    поки п < М.взяті_модулі.розмір {
      позначити_предмет_модуля(М, М.взяті_модулі.елементи[п].значення);
      п += 1;
    }
    позначити_середовище(М, М.глобальне_середовище);
    позначити_предмет_структури(М, М.предмет_структури_предмет);
    позначити_предмет_структури(М, М.предмет_структури_Структура);
    позначити_предмет_структури(М, М.предмет_структури_Дія);
    позначити_предмет_структури(М, М.предмет_структури_НативнаДія);
    позначити_предмет_структури(М, М.предмет_структури_число);
    позначити_предмет_структури(М, М.предмет_структури_текст);
    позначити_предмет_структури(М, М.предмет_структури_юнікод);
    позначити_предмет_структури(М, М.предмет_структури_Модуль);
    позначити_предмет_структури(М, М.предмет_структури_список);
    позначити_предмет_структури(М, М.предмет_структури_словник);
    позначити_предмет_структури(М, М.предмет_структури_логічне);
  }

  місцева дія утилізувати(М: адреса<Машина>) {
//    надрукувати_Ю8(М, ю8"Починаємо утилізацію...");
//    надрукувати_п64(М, М.утилізатор.кількість_предметів);
//    надрукувати_п64(М, М.утилізатор.кількість_середовищ);
//    надрукувати_п64(М, М.утилізатор.кількість_предметів_щоб_запустити_утилізацію);
//    надрукувати_п64(М, М.утилізатор.кількість_середовищ_щоб_запустити_утилізацію);
    позначити(М);
    змінна ціль наступний_предмет: адреса<Предмет> = пусто;
    змінна ціль предмет = М.утилізатор.останній_предмет;
    поки предмет != пусто {
      ціль попередній_предмет = предмет.попередній_предмет;
      якщо предмет.позначено == позитивне(ні) {
        якщо наступний_предмет == пусто {
          М.утилізатор.останній_предмет = попередній_предмет;
        } інакше {
          наступний_предмет.попередній_предмет = попередній_предмет;
        }
        звільнити_предмет(предмет, М);
        М.утилізатор.кількість_предметів = М.утилізатор.кількість_предметів - 1;
      } інакше {
        наступний_предмет = предмет;
      }
      предмет = попередній_предмет;
    }
    змінна ціль попереднє_середовище: адреса<Середовище> = пусто;
    змінна ціль середовище = М.утилізатор.початок_середовищ;
    поки середовище != пусто {
      ціль наступне_середовище = середовище.наступне_середовище;
      якщо середовище.позначено == позитивне(ні) {
        якщо попереднє_середовище == пусто {
          М.утилізатор.початок_середовищ = наступне_середовище;
        } інакше {
          попереднє_середовище.наступне_середовище = наступне_середовище;
        }
        звільнити_середовище(М, середовище);
        М.утилізатор.кількість_середовищ = М.утилізатор.кількість_середовищ - 1;
      } інакше {
        попереднє_середовище = середовище;
      }
      середовище = наступне_середовище;
    }
    предмет = М.утилізатор.останній_предмет;
    поки предмет != пусто {
      предмет.позначено = позитивне(ні);
      предмет = предмет.попередній_предмет;
    }
    середовище = М.утилізатор.початок_середовищ;
    поки середовище != пусто {
      середовище.позначено = позитивне(ні);
      середовище = середовище.наступне_середовище;
    }
    М.утилізатор.кількість_предметів_щоб_запустити_утилізацію = (М.утилізатор.кількість_предметів * 5) + 1;
    М.утилізатор.кількість_середовищ_щоб_запустити_утилізацію = (М.утилізатор.кількість_середовищ * 5) + 1;
  }

  місцева дія позначити_властивості(М: адреса<Машина>, властивості: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>) {
    змінна ціль пв: позитивне = 0;
    поки пв < властивості.розмір {
      позначити_предмет(М, властивості.елементи[пв].значення);
      пв += 1;
    }
  }

  місцева дія позначити_параметри(М: адреса<Машина>, параметри: адреса<Реєстр<адреса<Назва>, Параметр>>) {
    змінна ціль пп: позитивне = 0;
    поки пп < параметри.розмір {
      ціль параметр = параметри.елементи[пп].значення;
      змінна ціль птп: позитивне = 0;
      поки птп < параметр.типи.розмір {
        позначити_предмет_структури(М, параметр.типи.дані[птп]);
        птп += 1;
      }
      пп += 1;
    }
  }

  місцева дія позначити_методи(М: адреса<Машина>, методи: адреса<Реєстр<адреса<Назва>, адреса<Предмет>>>) {
    змінна ціль мп: позитивне = 0;
    поки мп < методи.розмір {
      позначити_предмет(М, методи.елементи[мп].значення);
      мп += 1;
    }
  }

  // мітка: прохід по типах предметів
  місцева дія позначити_предмет(М: адреса<Машина>, предмет: адреса<Предмет>) {
    якщо предмет == пусто {
      вернути;
    }
    якщо предмет.тип == М.предмет_структури_Структура {
      позначити_предмет_структури(М, предмет як адреса<ПредметСтруктури>);
    } інакше якщо предмет.тип == М.предмет_структури_Дія {
      позначити_предмет_дії(М, предмет як адреса<ПредметДії>);
    } інакше якщо предмет.тип == М.предмет_структури_НативнаДія {
      позначити_предмет_нативної_дії(М, предмет як адреса<ПредметНативноїДії>);
    } інакше якщо предмет.тип == М.предмет_структури_число {
      позначити_предмет_числа(М, предмет як адреса<ПредметЧисла>);
    } інакше якщо предмет.тип == М.предмет_структури_текст {
      позначити_предмет_тексту(М, предмет як адреса<ПредметТексту>);
    } інакше якщо предмет.тип == М.предмет_структури_юнікод {
      позначити_предмет_юнікоду(М, предмет як адреса<ПредметЮнікоду>);
    } інакше якщо предмет.тип == М.предмет_структури_Модуль {
      позначити_предмет_модуля(М, предмет як адреса<ПредметМодуля>);
    } інакше якщо предмет.тип == М.предмет_структури_список {
      позначити_предмет_списку(М, предмет як адреса<ПредметСписку>);
    } інакше якщо предмет.тип == М.предмет_структури_словник {
      позначити_предмет_словника(М, предмет як адреса<ПредметСловника>);
    } інакше якщо предмет.тип == М.предмет_структури_логічне {
      позначити_предмет_логічного(М, предмет як адреса<ПредметЛогічного>);
    } інакше якщо предмет.тип == М.предмет_структури_байти {
      позначити_предмет_байтів(М, предмет як адреса<ПредметБайтів>);
    } інакше якщо предмет.тип == М.предмет_структури_адреса {
      позначити_предмет_адреси(М, предмет як адреса<ПредметАдреси>);
    } інакше {
      позначити_складений_предмет(М, предмет як адреса<СкладенийПредмет>);
    }
  }

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

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

  місцева дія позначити_предмет_нативної_дії(М: адреса<Машина>, предмет_нативної_дії: адреса<ПредметНативноїДії>) {
    якщо предмет_нативної_дії == пусто {
      вернути;
    }
    якщо предмет_нативної_дії.позначено == позитивне(так) {
      вернути;
    }
    предмет_нативної_дії.позначено = позитивне(так);
    позначити_предмет_структури(М, предмет_нативної_дії.тип);
    позначити_властивості(М, предмет_нативної_дії.властивості::адреса);
  }

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

  місцева дія позначити_предмет_тексту(М: адреса<Машина>, предмет_тексту: адреса<ПредметТексту>) {
    якщо предмет_тексту == пусто {
      вернути;
    }
    якщо предмет_тексту.позначено == позитивне(так) {
      вернути;
    }
    предмет_тексту.позначено = позитивне(так);
    позначити_предмет_структури(М, предмет_тексту.тип);
  }

  місцева дія позначити_предмет_юнікоду(М: адреса<Машина>, предмет_юнікоду: адреса<ПредметЮнікоду>) {
    якщо предмет_юнікоду == пусто {
      вернути;
    }
    якщо предмет_юнікоду.позначено == позитивне(так) {
      вернути;
    }
    предмет_юнікоду.позначено = позитивне(так);
    позначити_предмет_структури(М, предмет_юнікоду.тип);
  }

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

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

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

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

  місцева дія позначити_предмет_байтів(М: адреса<Машина>, предмет_байтів: адреса<ПредметБайтів>) {
    якщо предмет_байтів == пусто {
      вернути;
    }
    якщо предмет_байтів.позначено == позитивне(так) {
      вернути;
    }
    предмет_байтів.позначено = позитивне(так);
    позначити_предмет_структури(М, предмет_байтів.тип);
    позначити_властивості(М, предмет_байтів.властивості::адреса);
  }

  місцева дія позначити_предмет_адреси(М: адреса<Машина>, предмет_адреси: адреса<ПредметАдреси>) {
    якщо предмет_адреси == пусто {
      вернути;
    }
    якщо предмет_адреси.позначено == позитивне(так) {
      вернути;
    }
    предмет_адреси.позначено = позитивне(так);
    позначити_предмет_структури(М, предмет_адреси.тип);
  }

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

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