LINUX.ORG.RU

Metaprog: универсальная графическая среда программирования [в разработке]

 , , ,


6

7

Почему, несмотря на обилие «чудесных» ООП-языков, Си, разработанный в 1973 году, до сих пор не умер? Потому что не выхдящие за рамки текстового программирования попытки «улучшить» или заменить Си давали и дают проблем больше, чем решали.

Какой из ныне существующих языков программирования позволяет программировать мышкой, а не клавиатурой? На чем можно программировать графически, а не в тексте? Пока что это позволяет на приличном уровне только пропиетарное LabVIEW. Трудно поверить, но это единственная полностью графическая среда программирования серьезного уровня в 2019 году! Но даже в LabVIEW есть куча недостатков (которые невозможно самостоятельно устранить из-за пропиетарности).

Графическое программирование намного проще и понятнее. Если в качестве бэкенда брать Си и манипулировать функциями из сишной стандартной библиотеки, это не будет создавать никаких лишних абстракций, зато серьезно упростит жизнь программистам и особенно людям, имеющим дело с чужим кодом. Код любого уровня и любой сложности, представленный в виде графических блоков, станет открытым не только для узких специалистов, но и вообще любому продвинутому пользователю. Простота программирования и эффективность, не меньшая, чем у Си, убьет C++, Python, Java, Javascript и прочую ерунду с раздутыми и полными багов абстракциями (которые Линус не раз крыл матом).

Я уже делаю некое подобие LabVIEW на самом LabVIEW, назовем его Metaprog. Так же, как в 1991 Линус Торвальдс делал линукс, пользуясь пропиетарным Minix. И так же жаловался на кучу недостатков в Minix, желая устранить их в своей системе.

Я уже рисую простенькие блок-схемы. Добился того, что функции, типы, структуры, юнионы из сишных #include сразу отображаются в виде меню, что серьезно упрощает знакомство со стандартной библиотекой Си.

Примеры

Примеры с кодом на Си генерируются автоматически. Они тут же скармливаются компилятору и не предназначены для чтения эстетами, не любящими «абракадабру». Здесь они приведены лишь как пример работы транслятора и для возможности самостоятельно скомпилировать графические диаграммы со скринов. Так сказать, приобщиться к прекрасному.

Самое простое - Hello World. Скомпилируйте (gcc -o ./test ./code.c).

https://i.postimg.cc/YCywWbSh/fwrite.png

#include <stdio.h>

int main(){
char metaprog_array_pointer_10156130170823954432[] = {72,101,108,108,111,32,87,111,114,108,100};
unsigned long int metaprog_variable_13830126042312755200 = 1;
unsigned long int metaprog_array_size_10156130170823954432 = 11;
fwrite(metaprog_array_pointer_10156130170823954432,metaprog_variable_13830126042312755200,metaprog_array_size_10156130170823954432,stdout);

}

Я подписываю терминалы на украинском (сам оттуда), с таким же успехом их можно подписывать на русском, а не только на английском. Можно будет перевести все, кроме, разве что, вызываемых сишных функций, а gcc этого и не заметит (посмотрите код). При работе международной командой можно к каждой подписи/надписи прилагать словарь с нужными языками. Игры ж локализируют, чем визуальное программирование хуже?

Массив декларируется не как строка в кавычках, а как последовательность байтов, а байт - это цифра. Строки редактируются отдельным редактором (пока что средствами LabVIEW, но это временно). Больше никаких проблем и глюков с управляющими символами, кавычками итп (очень серьезная проблема при программировании на Си, Shell scripting и вообще всех текстовых языках).

Константа-массив имеет отдельные терминалы для указателя на массив и длины массива (известной редактору кода). Если терминал длины подключен - декларируется отдельная переменная. Не подключен - незачем и декларировать.

Пример посложнее: запись и в stdout, и в файл ./fwrite-test.txt

https://i.postimg.cc/v8KvKKmQ/fwrite2.png

#include <stdio.h>

int main(){
char metaprog_array_pointer_10156130170823954432[] = {72,101,108,108,111,32,87,111,114,108,100};
unsigned long int metaprog_variable_13830126042312755200 = 1;
unsigned long int metaprog_array_size_10156130170823954432 = 11;
fwrite(metaprog_array_pointer_10156130170823954432,metaprog_variable_13830126042312755200,metaprog_array_size_10156130170823954432,stdout);
char metaprog_array_pointer_12385851444566411264[] = {46,47,102,119,114,105,116,101,45,116,101,115,116,46,116,120,116,0};
char metaprog_array_pointer_16510743873862514688[] = {119,43,0};
fwrite(metaprog_array_pointer_10156130170823954432,metaprog_variable_13830126042312755200,metaprog_array_size_10156130170823954432,fopen(metaprog_array_pointer_12385851444566411264,metaprog_array_pointer_16510743873862514688));

}

В данном примере используется функция fwrite, а не printf. То есть, символ «0» не влияет на запись массива в файл или stdout. Сколько символов писать функция и так знает из длины массива.

Заявки

Принимаю заявки на новые фичи. Пишите в комментариях. Уже приняты заявки:

1. Пример с простым HTTP-сервером.

2. Пример с сортировкой Хоара (quicksort).

3. Простой в пользовании функционал работы со строками (больная тема для Си и С++).

4. Полностью графический функционал работы с регулярными выражениями, без вовлечения PCRE.

Сейчас нужно научить Metaprog «компилировать» блок-схемы прямо в Си и скармливать этот код gcc, получая бинарники. После чего перенести сам Metaprog на Си, чтоб перестать нуждаться в пропиетарном LabVIEW и выложить результаты в опенсорс. И получить за это донат, хотя желательно уже сейчас (для ускорения работы). Bitcoin:1AYoK2TScSpD5bhf67mv9AxHDJ2RidRvjD

Ответ на: комментарий от vladimir_vist

(конструкторы)/деструкторы

malloc/realloc/free?

умные указатели

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

https://i.postimg.cc/63dMhrQW/image.png

виртуальные методы

Тут лучше ввести в системе типов две несложные вещи.

1. Категории типов. Например, беззнаковое 8-битное (байт, byte, char) относится к знаковым, знаковые - к целым, целые - к числовым. Система примитивных типов почти полностью повторяет Си, но поверх них еще ложатся, так сказать, категории типов, такие, как знаковое, беззнаковое (разными цветами кстати), целое, дробное, число. И складывать, например, можно все из числовых типов.

https://i.postimg.cc/0Qqfrz0L/image.png

2. Полиморфизм функций, в случае необходимости. И структуры ветвления, задаваемые типом данных. Эта тема пока в разработке.

metaprog ()
Ответ на: комментарий от iluha16

мне лень с тобой спорить

Ахах, я просто сказал что аргументов у тебя нету, ты на эмоциях все пишешь. Какие споры еще, эх...

напишешь что нибудь больше hello worldа

О, показывай свои проекты. Посмотрим что пишет илита этот мира.

vladimir_vist ()
Ответ на: комментарий от metaprog

malloc/realloc/free?

Их легко пропустить, забыть, еще их нужно писать самому, но зачем? Ведь это можно автоматизировать, тебе не лень?

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

vladimir_vist ()
Ответ на: комментарий от iluha16

Что бы человек выполнял рутину (некоторую) ему нужно думать.

вот и до программирования добрались дибилы с мышками.

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

vladimir_vist ()
Ответ на: комментарий от metaprog

Описка. Исправляю.

беззнаковое 8-битное (байт, byte, char) относится к БЕЗзнаковым, БЕЗзнаковые - к целым...

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

С графическим подходом описки вообще перестают быть проблемой.

metaprog ()
Ответ на: комментарий от vladimir_vist

Что такое fast типы?

П. С.: названия типов, как и любые тектовые подписи, будут не только лишь на украинском. Их можно будет переводить на любой UTF-8 язык, и даже вводить свои собственные корпоративные диалекты.

metaprog ()
Ответ на: комментарий от metaprog

ну с префиксом fast, они в stdint.h, есть например fast_int16_t, на x86 он превратиться в int32_t так как это будет самый быстрый тип вмещающий в себя int16_t на этой архитектуре.

vladimir_vist ()
Ответ на: комментарий от vladimir_vist

Хороший вопрос. «Самый быстрый» тип - это отвечающий разрядности архитектуры? Или не всегда так?

metaprog ()
Ответ на: комментарий от metaprog

«Самый быстрый» тип - это отвечающий разрядности архитектуры?

Ну в x86 так...:

/* Signed.  */
typedef signed char             int_fast8_t;
#if __WORDSIZE == 64
typedef long int                int_fast16_t;
typedef long int                int_fast32_t;
typedef long int                int_fast64_t;
#else
typedef int                     int_fast16_t;
typedef int                     int_fast32_t;
__extension__
typedef long long int           int_fast64_t;
#endif
Но я думаю может быть и не так)

vladimir_vist ()
Ответ на: комментарий от vladimir_vist

Сейчас допиливаю функционал работы с подфункциями, сделанными в самом метапроге. После этого можно будет начинать делать, например, библиотеку для работы со строками. Там будет сложение (объединение) и разделение строк, поиск регулярного выражения по ним и так далее. Часть операций будет сопровождаться malloc/realloc/free, но это будет внутри соответствующих функций, так что каждый раз вручную париться с этим не надо будет.

metaprog ()
Ответ на: комментарий от vladimir_vist

PCRE? Учитывать этот ужас? Я сейчас метапрог пилю на Labview и меня дико возмущает факт, что даже там, в ГРАФИЧЕСКОЙ среде, кое-где в функциях работы со строками встречается необходимость знать и учитывать синтаксис PCRE. Не дай боже поставить в строке +, \, ?, [, ] и еще какие-то символы - начнутся непонятные баги.

Знать и учитывать. Синтаксис. В графической среде. Нет, в Метапроге этому не место!

metaprog ()
Ответ на: комментарий от metaprog

Ну так нужно просто сделать возможность составлять регулярки схемами, но под капотом будет PCRE, там же оптимизации, все такое. Да и возможность вставить регулярку под PCRE не помешает.

vladimir_vist ()
Ответ на: комментарий от vladimir_vist

Лучше уж своя графическая система регулярных выражений под Метапрогом. Ключевое преимущество графического подхода при работе с текстами - отсутствие управляющих символов. Даже такие символы как \'«{}[] для компилятора всего лишь будут байтами. Целый класс багов будет исключен одним махом.

metaprog ()
Ответ на: комментарий от vladimir_vist

П. С.: а что там за чудо-оптимизации в работе с PCRE? Простому смертному этот уровень не подвластен?

metaprog ()
Ответ на: комментарий от metaprog

А вот допустим такая программа, пользователь вводит строку, и регулярку, тоже строкой. Программа компилирует регулярку и применяет к строке, пользователю выводиться результат. Как такое реализовать можно будет?

// пример псевдокодом
char *str, *reg;

scanf("Введите регулярку!", reg);
scanf("Введите строку!", str);
puts(regexp_go(reg, str));

vladimir_vist ()
Ответ на: комментарий от metaprog

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

vladimir_vist ()
Ответ на: комментарий от vladimir_vist

Покажу пример когда будут готовы функции работы со строками. Пока скажу лишь, что scanf и printf я недолюбливаю именно за сложности с «регулярными выражениями». Предпочитаю fwrite/fread - там даже можно указать число байтов на запись/чтение, не требуется «0» в конце строки. А само «регулярное выражение», скорее всего, будет уже читаться и сравниваться с нужной строкой в цикле do... while.

metaprog ()
Ответ на: комментарий от metaprog

Это будет медленно, лучше PCRE взять же, ты быстрее напишешь модуль, и будут возможности лучше!

vladimir_vist ()
Ответ на: комментарий от iluha16

Model-based подход очень даже имеет смысл в областях, в которых не требуется ЯП общего назначения и все задачи можно свести в рамки ограниченных моделей. Формальная модель позволяет формальное доказательство свойств моделируемой системы. Это принципиально иной уровень инженерии по сравнению с быдлокодингом на ЯП общего назначения, с недотестированием и надеждой на «авось не упадет».

Например, Симулинк, или те же упомянутые стандартизованные ЯП из области промышленной автоматизации. Это уже есть давно, это работает, и все блага современной цивилизации вы получаете благодаря существованию подобных моделей и соотв. ДСЛ. Отрицать этот факт или бороться с ним похоже на желание летать на приклеенных к рукам крыльях вместо современных самолетов.

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

seiken ★★★★★ ()

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

так получилось, что я пишу «кисий язык». у меня кстати бомбит от С++ хотя я его поддерживал. Язык - это значит что у тебя есть парсер, затем некая херь, которая генерит «что-то».

Так вот, уже на этой отметке ты можешь что-то показать?

anonymous ()
Ответ на: комментарий от seiken

Другое дело, что у ТС идея вовсе не в создании более удобной формальной модели. Он хочет синтаксис Сшки представить в виде схем, тупо один-в-один, не меняя при этом семантику.

Это просто так выглядит, на самом деле Сишка это как ассемблер для его схем.

vladimir_vist ()
Ответ на: комментарий от anonymous

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

vladimir_vist ()
Ответ на: комментарий от metaprog

Вы собрались писать ядро на метапроге? Потому что практически все аргументы Торвальдса относятся к разработке ядра.

seiken ★★★★★ ()

На чем можно программировать графически, а не в тексте?

Я каждый день программирую в графическом языке и за деньги.

AUX ★★ ()
Ответ на: комментарий от vladimir_vist

Зубрить синтаксис PCRE? Увольте.

Ничто не помешает вставить в Метапрог функционал PCRE, но пусть это сделает кто-нибудь другой после релиза. И если это случится - Метапрог будет показывать специальные предупреждения, что поведение этой функции зависит не только от графической диаграммы, но и от подаваемой строки с PCRE. Чтоб потом люди не удивлялись непредсказуемому поведению программы.

metaprog ()
Ответ на: комментарий от anonymous

Пока что код Метапрога на Labview, открывать который смысла мало, так как большинство присутствующих едва ли станут платить за пропиетарщину или пиратить. Релиз вместе с исходниками будет после полного переноса кода с Labview на диаграммы Метапрога.

metaprog ()
Ответ на: комментарий от metaprog

Зачем зубрить, посмотри функционал, реализуй, вот ниже regexp который нужен для валидации email, ты его согласен переделать на схемах? А многие другие? PCRE это очень важно!

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(

vladimir_vist ()
Ответ на: комментарий от vladimir_vist

Это реально рабочий пример рабочего кода???!!! Да даже автоматически генерируемый Метапрогом сишный код, которые некоторые назвали абракадаброй, прост и понятен в сравнении с этим (хотя и предназначен для понимания компилятором, а не человеком). Такие вещи надо делать исключительно в графических схемах!

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

metaprog ()
Ответ на: комментарий от metaprog

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

Очень хорошая идея.

vladimir_vist ()
Ответ на: комментарий от seiken

Model-based подход очень даже имеет смысл в областях, в которых не требуется ЯП общего назначения и все задачи можно свести в рамки ограниченных моделей. Формальная модель позволяет формальное доказательство свойств моделируемой системы. Это принципиально иной уровень инженерии по сравнению с быдлокодингом на ЯП общего назначения, с недотестированием и надеждой на «авось не упадет»... Другое дело, что у ТС идея вовсе не в создании более удобной формальной модели. Он хочет синтаксис Сшки представить в виде схем, тупо один-в-один, не меняя при этом семантику.

Си (и любой другой язык программирования) это тоже ограниченная модель с фиксированным набором правил. Которые можно и нужно формализировать в графике вместо текстовых выражений. Это и удобство создания кода, и чтения (графических диаграмм вместо текстов), и изменения чужого кода.

Кстати, насчет того, что Си для меня лишь как ассемблер, Владимир прав.

metaprog ()
Ответ на: комментарий от seiken

Метапрог будет универсальным, как Си, и ядра операционных систем на нем можно и нужно будет делать. Когда Метапрог хорошо себя покажет на уровне прикладных программ, на нем можно будет вести даже разработку ядра Линукс.

Критика С++ Линусом касается не только ядра. Git тоже сделан полностью на Си, хоть и является прикладной программой. Развернутый мейл с матюками в адрес С++ был по теме Git, а не ядра.

metaprog ()
Ответ на: комментарий от seiken

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

iluha16 ()
Ответ на: комментарий от iluha16

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

vladimir_vist ()
Ответ на: комментарий от vladimir_vist

Кстати, спасибо за идею. Можно будет делать клавиатурные комбинации для каждой нужной функции.

metaprog ()
Ответ на: комментарий от metaprog

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

vladimir_vist ()
Ответ на: комментарий от vladimir_vist

Каждый сможет дополнять Метапрог сам для своих нужд.

metaprog ()
Ответ на: комментарий от metaprog

Функции юзаются разные, их много, нет смысл набивать их на клавиши, это как на кнопки мыши набить А и Б, лучше особые действия!

vladimir_vist ()
Ответ на: комментарий от metaprog

Владимир

Диаграммы должны иметь отличный дизайн.
Без этого - «удачи не ведать».

Немножко провокационный вопрос.

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

anonymous ()
Ответ на: комментарий от vladimir_vist

Я не так сформулировал мысль. Хорошо что не код текстовый пишу, а всего лишь комментарии)))

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

metaprog ()
Ответ на: комментарий от anonymous

Какой GUI, libraries, ... будет использован для создания диаграмм?

Скорее всего, только Xlib. Все что поверх него - тяжелая и черезмерно усложненная фигня.

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

Собственный бинарный формат. Никакого текстового xml с соответствующим оверхедом с парсерами.

metaprog ()
Ответ на: комментарий от vladimir_vist

Да и Win, Mac поддерживать тоже надо. Лучше поверх SDL2 сделать тогда уж.

vladimir_vist ()
Закрыто добавление комментариев для недавно зарегистрированных пользователей (со score < 50)