Все виды(способы) объявления переменных, функций, классов, типов и т.п. на С++

@ShinaZin · Регистрация: 03.04.2014

Author24 — интернет-сервис помощи студентам

Пишу обфускатор кода, написанного на С++ и появилась необходимость знания всевозможных способов объявления чего-либо на С++. Так как планирую с входным файлом следующее:
1)Прочесать весь файл посимвольно
2)Выделять имена (переменных, функций, и т.п.) и заносить в список имен
3)Сгенерировать список рандомных строк.
4)Заменить во входном файле каждое слово из списка имен, на слова из списка рандомных строк.

Так вот, самое сложное во втором пункте, т.е. в распознании факта объявления. Есть ли какая-то общая черта всех способов объявления? И по какому признаку можно понять, что в строке произошло объявление?

Пока я для себя выделил такие вот случаи(примеры):

C++

//Для наглядности
1) int a;
2) int a, b;
3) int a[100], b[CONSTName];
4) STACK <int> IntStack
5) int MyFunc();
6) int MyFunc(int a, int b);
7) class MyClass{..}
8) struct MyStruct{..}

Что я еще пропустил? (Подозреваю, что много)

@zss · 28.03.2015, 18:32

C++

int & a;
int * a;
const int a;
static int a;
long int a;
unsigned int a;
union MyStruct{..}
enum num{...}

@SmittWesson · 28.03.2015, 18:45

И зачем всё это глобально объявлять?

@hoggy · 28.03.2015, 18:53

Сообщение от ShinaZin

Что я еще пропустил? (Подозреваю, что много)

слишком многое.

вообще попытка проконтролировать типо-образования - плохой путь.
потому что их очень много. и есть множество рецептов таких образований.

намного проще идентифицировать имена без учета типа-образования:

на языке с++ любые символы в исходном коде,
которые не являются ключевыми словами языка - это какие то объявления.

а ключевых слов языка не так уж и много.

например:

C++

1	struct MyStruct{..} trololo; //<--- MyStruct - имя, trololo - имя

Здесь нужно
1. маскировать: 'MyStruct' и 'trololo'
2. выпиливать полностью весь комментарий

комментариев бывает три вида:

C++

// ololo

C++

1	/* ololo */

C++

1
2
3

#if 0
ololo
#endif

пропасти комментарии связанные с препроцессором - это жесть.
потому что там можно по всякому изголяццо:

C++

// хэдэр
#if SURPRIZE
 
// сюрприз определяется в  спп файле, который этот хэдэр инклюдит
// поэтому, в некоторых случаях блок будет исключен из компиляции
// а в некоторых может быть включен
 
#endif

@ShinaZin · 28.03.2015, 19:19 **[ТС]**

Суть не в глобальности, мне не важно, в каком контексте и блоке произошло объявление, мне необходимо понять, как выдрать имя объявляемого, из факта объявления, нужная какая-то общая маска. А выявить ее не так уж и легко как я понял и считать количество слов бессмысленно. Наверное придется затачивать свой "выдиратель имен" под вид "(модификаторы и т.д.) тип (разделитель пробел или табуляция) (*, &, ' ')имя1 ( = значение, имяN = значение"). Но при таком подходе программе нужно как-то понять, что очередное слово это тип данных (в том числе библиотечные типы, и пользовательские). Вопрос - как?

Добавлено через 16 минут

Сообщение от hoggy

вообще попытка проконтролировать типо-образования - плохой путь.
потому что их очень много. и есть множество рецептов таких образований.
намного проще идентифицировать имена без учета типа-образования:
на языке с++ любые символы в исходном коде,
которые не являются ключевыми словами языка - это какие то объявления.
а ключевых слов языка не так уж и много.

В самом начале я тоже об этом думал, но тут возникла другая проблема. Как исключить из рассмотрения библиотечные функции, типы и т.д.? всякие cin, cout, string, Stack, system, strcpy, ifstream, pow... Лезть в хэдеры и проверять там? Там свои проблемы вылезут..

@hoggy · 28.03.2015, 19:37

Сообщение от ShinaZin

В самом начале я тоже об этом думал, но тут возникла другая проблема. Как исключить из рассмотрения библиотечные функции, типы и т.д.?

а зачем их исключать?

@ShinaZin · 28.03.2015, 19:55 **[ТС]**

cin, cout, string, Stack, system, strcpy, ifstream, pow

Ведь все это обфускатор не должен заменять, ибо код станет нерабочим.
Даже если и заменять, то заменять полноценно рабочими аналогами с рандомным именем, но копировать каждую библиотечную функцию это бред.

@retmas · 28.03.2015, 20:06

Сообщение от ShinaZin

Есть ли какая-то общая черта всех способов объявления? И по какому признаку можно понять, что в строке произошло объявление?

конечно есть. и этих черт не мало

этим ~~чертям~~ чертам посвящены главы 7(declarations) и 8(declarators) стандарта

@hoggy · 28.03.2015, 20:07

Сообщение от ShinaZin

Ведь все это обфускатор не должен заменять, ибо код станет нерабочим.

наверное, все таки он должен суметь заменить так, что бы все работало.

так то существует 100500 разных способов, как заморочить голову вашему обусфактору,
в том плане, что ему будет очень сложно отличить:
что здесь стандартное, а что пользовательское.

вопрос: "а как в принципе определить, что тут стандартное, а что местное" - это отдельный инженерный ребус.
---------------------------------------------------------------------------------

например...
обусфактор может составить список всех имен, которые найдет в исходнике.
а потом запутать их при помощи препроцессора.

в самом исходнике мы увидим дибильные имена.
если сильно присмотреться: в самом начале подключается волшебный инклюд,
который содержит всю магию.

Croessmah · 28.03.2015, 20:19

Сообщение от hoggy

если сильно присмотреться: в самом начале подключается волшебный инклюд,
который содержит всю магию.

тогда будет достаточно пропустить код через препроцессор и получим всё на блюдичке.

@ShinaZin · 28.03.2015, 20:26 **[ТС]**

Сообщение от retmas

главы 7(declarations) и 8(declarators) стандарта

Сообщение от hoggy

вопрос: "а как в принципе определить, что тут стандартное, а что местное" - это отдельный инженерный ребус.

Но, теперь я уже не знаю, с какой стороны лучше подойти. Делать мб огромный файл с зарезервированными словами, которые нельзя заменять(или такой список уже есть где-то), или все же пытаться поймать все объявления и вырезать оттуда имена(что более логично, но очень тяжело). Куда копать?

@retmas · 28.03.2015, 20:39

Сообщение от ShinaZin

Делать мб огромный файл с зарезервированными словами, которые нельзя заменять

даже не могу представить такой список для проектов использующих boost/MFC/VCL/прочее.
уж лучше и надежнее парсить объявления, которые подчинены строгому и главное конечному числу правил

@ShinaZin · 28.03.2015, 21:01 **[ТС]**

всем спасибо за мнения и советы. Буду думать над парсингом. Возможно тут меня спасут регулярные выражения, но пока я не знаю, есть ли такие библиотеки/или что то, для работы с такими выражениями на с++.

Не по теме:

Может в конце вовсе обращусь к баш скриптам с его утилитами.

@hoggy · 28.03.2015, 21:25

Сообщение от Croessmah

тогда будет достаточно пропустить код через препроцессор и получим всё на блюдичке.

верная мысль.
но препроцессором путать следы все равно нужно.
что бы стандартные имена не выпячивались.

просто это нужно использовать в комплексе с подменой имен пользовательских.

Сообщение от ShinaZin

Но, теперь я уже не знаю, с какой стороны лучше подойти. Делать мб огромный файл с зарезервированными словами, которые нельзя заменять(или такой список уже есть где-то), или все же пытаться поймать все объявления и вырезать оттуда имена(что более логично, но очень тяжело). Куда копать?

Вариант №1

сначала вам нужно произвести подмену имен путем анализа типо-образования.
причем, не обязательно пытаться сразу охватить все возможные случаи.
достаточно замаскировать наиболее распространенные варианты.

далее, полученный файл проходит обработку "маскировка препроцессором".

в результате получаем непонятную кашу.

даже если и глянуть выхлоп препроцессора, то мы увидим: где то появятся имена наподобие cout,
но основная масса кода все равно будет оставаться нечитабельной.

а дальше уже нужно смотреть по обстоятельствам:
если хочется замаскировать ещё больше - просто анализируем больше всяких типа-образований.

-----------------------------

Вариант №2

при запуске обусфактора, ему указывается каталог, где находится исходный код проекта.
обусфактор рекурсивно обходит весь каталог, и собирает список путей всех исходных файлов проекта.

далее, рассмотрим код:

C++

#include<iostream>
int main()
{
    int v = 10;
    std::cout << v;
}

обусфактор, зная пути к всем исходникам проекта однозначно может определить,
что iostream - это стандартный заголовочный файл.

он может рекурсивно пройтись по нему, собирая все имена.

и тогда он сможет абсолютно точно вам сказать:

cout - стандартное имя (было обнаружено внутри стандартных заголовков)
все остальное - местное.

что бы ускорить работу обусфактора, можно кэшировать информацию о стандартных именах.
и тогда повстречав cout в следующий раз (возможно в другом исходнике),
ему уже не нужно будет лазить по стандартным заголовкам.

@Renji · 28.03.2015, 21:26

Сообщение от ShinaZin

2)Выделять имена (переменных, функций, и т.п.) и заносить в список имен

Этого мало, так как можно написать имя и как string, и как std::string. И вообще говоря, в зависимости от контекста это могут быть разные вещи (в std один стринг, а у меня другой). Тут надо делать полноценный парсер C++.

@ShinaZin · 28.03.2015, 21:51 **[ТС]**

Сообщение от hoggy

Вариант №1
сначала вам нужно произвести подмену имен путем анализа типо-образования.
причем, не обязательно пытаться сразу охватить все возможные случаи.
достаточно замаскировать наиболее распространенные варианты.

Данный вариант мне больше приглянулся, буду делать его (ибо мне пока что только в учебных и самообразовательных целях), но правильнее вариант 2, так что, возможно, реализация будет чем-то средним между этими вариантами. Осталось подумать(придумать) как именно парсить и какие варианты объявлений распространены больше всего. Ну это я уж сам, наверное тему можно закрыть. Спасибо за то, что нашли время.

@ShinaZin 0 / 0 / 0 Регистрация: 03.04.2014 Сообщений: 13
	28.03.2015, 20:26 [ТС]	11
	Сообщение от retmas главы 7(declarations) и 8(declarators) стандарта Сообщение от hoggy вопрос: "а как в принципе определить, что тут стандартное, а что местное" - это отдельный инженерный ребус. Но, теперь я уже не знаю, с какой стороны лучше подойти. Делать мб огромный файл с зарезервированными словами, которые нельзя заменять(или такой список уже есть где-то), или все же пытаться поймать все объявления и вырезать оттуда имена(что более логично, но очень тяжело). Куда копать? 0

@retmas Жарю без масла 867 / 749 / 225 Регистрация: 13.01.2012 Сообщений: 1,702
	28.03.2015, 20:39	12
	Сообщение от ShinaZin Делать мб огромный файл с зарезервированными словами, которые нельзя заменять даже не могу представить такой список для проектов использующих boost/MFC/VCL/прочее. уж лучше и надежнее парсить объявления, которые подчинены строгому и главное конечному числу правил 0

@ShinaZin 0 / 0 / 0 Регистрация: 03.04.2014 Сообщений: 13
	28.03.2015, 21:01 [ТС]	13
	всем спасибо за мнения и советы. Буду думать над парсингом. Возможно тут меня спасут регулярные выражения, но пока я не знаю, есть ли такие библиотеки/или что то, для работы с такими выражениями на с++. Не по теме: Может в конце вовсе обращусь к баш скриптам с его утилитами. 0

@SmittWesson 236 / 196 / 21 Регистрация: 04.06.2014 Сообщений: 1,309
	28.03.2015, 18:45	3
	И зачем всё это глобально объявлять? 0

@ShinaZin 0 / 0 / 0 Регистрация: 03.04.2014 Сообщений: 13
	28.03.2015, 19:19 [ТС]	5
	Суть не в глобальности, мне не важно, в каком контексте и блоке произошло объявление, мне необходимо понять, как выдрать имя объявляемого, из факта объявления, нужная какая-то общая маска. А выявить ее не так уж и легко как я понял и считать количество слов бессмысленно. Наверное придется затачивать свой "выдиратель имен" под вид "(модификаторы и т.д.) тип (разделитель пробел или табуляция) (, &, ' ')имя1 ( = значение, имяN = значение"). Но при таком подходе программе нужно как-то понять, что очередное слово это тип данных (в том числе библиотечные типы, и пользовательские). Вопрос - как? Добавлено через 16 минут* Сообщение от hoggy вообще попытка проконтролировать типо-образования - плохой путь. потому что их очень много. и есть множество рецептов таких образований. намного проще идентифицировать имена без учета типа-образования: на языке с++ любые символы в исходном коде, которые не являются ключевыми словами языка - это какие то объявления. а ключевых слов языка не так уж и много. В самом начале я тоже об этом думал, но тут возникла другая проблема. Как исключить из рассмотрения библиотечные функции, типы и т.д.? всякие cin, cout, string, Stack, system, strcpy, ifstream, pow... Лезть в хэдеры и проверять там? Там свои проблемы вылезут.. 0

@hoggy 8739 / 4317 / 960 Регистрация: 15.11.2014 Сообщений: 9,760
	28.03.2015, 19:37	6
	Сообщение от ShinaZin В самом начале я тоже об этом думал, но тут возникла другая проблема. Как исключить из рассмотрения библиотечные функции, типы и т.д.? а зачем их исключать? 0

@ShinaZin 0 / 0 / 0 Регистрация: 03.04.2014 Сообщений: 13
	28.03.2015, 19:55 [ТС]	7
	cin, cout, string, Stack, system, strcpy, ifstream, pow Ведь все это обфускатор не должен заменять, ибо код станет нерабочим. Даже если и заменять, то заменять полноценно рабочими аналогами с рандомным именем, но копировать каждую библиотечную функцию это бред. 0

@retmas Жарю без масла 867 / 749 / 225 Регистрация: 13.01.2012 Сообщений: 1,702
	28.03.2015, 20:06	8
	Сообщение от ShinaZin Есть ли какая-то общая черта всех способов объявления? И по какому признаку можно понять, что в строке произошло объявление? конечно есть. и этих черт не мало этим ~~чертям~~ чертам посвящены главы 7(declarations) и 8(declarators) стандарта 0

@hoggy 8739 / 4317 / 960 Регистрация: 15.11.2014 Сообщений: 9,760
	28.03.2015, 20:07	9
	Сообщение от ShinaZin Ведь все это обфускатор не должен заменять, ибо код станет нерабочим. наверное, все таки он должен суметь заменить так, что бы все работало. так то существует 100500 разных способов, как заморочить голову вашему обусфактору, в том плане, что ему будет очень сложно отличить: что здесь стандартное, а что пользовательское. вопрос: "а как в принципе определить, что тут стандартное, а что местное" - это отдельный инженерный ребус. --------------------------------------------------------------------------------- например... обусфактор может составить список всех имен, которые найдет в исходнике. а потом запутать их при помощи препроцессора. в самом исходнике мы увидим дибильные имена. если сильно присмотреться: в самом начале подключается волшебный инклюд, который содержит всю магию. 0

Croessmah Неэпический 17870 / 10635 / 2054 Регистрация: 27.09.2012 Сообщений: 26,736 Записей в блоге: 1
	28.03.2015, 20:19	10
	Сообщение от hoggy если сильно присмотреться: в самом начале подключается волшебный инклюд, который содержит всю магию. тогда будет достаточно пропустить код через препроцессор и получим всё на блюдичке. 0

@Renji 2782 / 1935 / 570 Регистрация: 05.06.2014 Сообщений: 5,600
	28.03.2015, 21:26	15
	Сообщение от ShinaZin 2)Выделять имена (переменных, функций, и т.п.) и заносить в список имен Этого мало, так как можно написать имя и как string, и как std::string. И вообще говоря, в зависимости от контекста это могут быть разные вещи (в std один стринг, а у меня другой). Тут надо делать полноценный парсер C++. 0

@ShinaZin 0 / 0 / 0 Регистрация: 03.04.2014 Сообщений: 13
	28.03.2015, 21:51 [ТС]	16
	Сообщение от hoggy Вариант №1 сначала вам нужно произвести подмену имен путем анализа типо-образования. причем, не обязательно пытаться сразу охватить все возможные случаи. достаточно замаскировать наиболее распространенные варианты. Данный вариант мне больше приглянулся, буду делать его (ибо мне пока что только в учебных и самообразовательных целях), но правильнее вариант 2, так что, возможно, реализация будет чем-то средним между этими вариантами. Осталось подумать(придумать) как именно парсить и какие варианты объявлений распространены больше всего. Ну это я уж сам, наверное тему можно закрыть. Спасибо за то, что нашли время. 0