LINUX.ORG.RU

Убийца ли C язык C3?

 , ,


3

8

В честь сегодняшнего пре-релиза (0.2.4).

C3 (GitHub) - очередной «убийца» C на базе LLVM. Потихоньку разрабатывается шведским программистом (одна штука).

Ключевые особенности:

  • компилятор написан на C
  • поддержка LLVM 12-15 (насколько мне известно, ни один из конкурентов этого не может (привет, Odin, Zig и т.д и т.п.))
  • полная C-ABI совместимость
  • модули - нет хидерам!
  • дженерики
  • макросы, но не как в C
  • слайсы
  • контракты
  • compile time and runtime reflection (плохопереводимая игра слов)
  • SIMD «из коробки»
  • и многое другое!

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

macro int factorial($n)
{
        $if ($n == 0):
                return 1;
        $else:
                return $n * factorial($n - 1);
        $endif;
}

extern fn void printf(char *fmt, ...);

fn void main()
{
        int x = factorial(12);
        printf("12! = %d\n", x);
}
★★★★★

Последнее исправление: dataman (всего исправлений: 1)
Ответ на: комментарий от fluorite

Ты ещё предложи приоритеты операций для выражений через грамматику оформлять.

Если они влияют на грамматику, то да. Вот типы влияют. Поэтому ты выше слился на переменные.

Ты же понимаешь, правильно? Вот расскажи - зачем и почему. Аргументируй.

Нет. Это ты должен рассказывать. Ты сказал, что можно добавить контекст. Тебе сказали, что это не будет контексто-свободной грамматикой. Далее ты там ещё 10 раз слился, оскорблял меня.

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

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

Ты же понимаешь, что грамматика - это только про парсинг. И после парсинга надо ещё поприседать, чтобы сгенерировать какой-нибудь байткод (llvm-ir или свой) или машкод? И все твои потуги про «контекст» тупо нерелевантны после построения ast и проходах по нему?

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

Ты мне показал первую ссылку из гугла? Это не цпп, а огрызок. Тесты там мусор. Это ещё какое-то жава-поделие, которое так просто не запустить. Так же это явно не ll1.

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

Достойная аргументация. Ты мне лучше расскажи чем генерируемый парсер отличается от написанного руками. Почему там лучше диагностики?

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

Зачем ты мне свой llvm-ir рассказываешь? Ты собирал калейдоскоп на лабе и теперь везде его суёшь? Или думаешь, что если повторишь llvm/машкод 10 раз - за знающего сойдёшь? Это не так.

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

Как и какие-то рассуждения про ast/проходы. Пастя мне базворды ты не добавляешь себе компетентности.

В общем, я утомился. Ты слишком много сливаешься и мало чего сообщаешь, кроме оскорблений и вкидывания левых базвордов.

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

Ты собирал калейдоскоп на лабе

Естессно. Ещё крафтингинтерпретерс читал. Ну ещё пару компиляторов в конторе писал.

Тебе уже сказали

Нет, кроме тебя никто ничего не говорил.

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

Да, дорогой. Дело во мне, а не в тебе. :)

В общем, я утомился.

Засчитан.

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

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

Что такое ll1-граматика и вообще контексто-свободная грамматика. Там во всяких википедиях в целом в области всё сложно. Поэтому вся эта теория годна только лабы бацать. В реальностях пацаны тупо пишут тот самый рекурсивный спуск и знать не знают о какой-либо грамматике. Так же мыслит и данный персонаж. О чём я уже сказал.

ll1-граматика должна мочь заселектить правило используя то самое «посмотреть вперёд», о котором рассказывал данный персонаж. Она ничего не знает кроме как о «посмотреть» и то о том в каком положении сейчас находится.

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

Соответственно, если мы при селекте используем контекст, то это уже не ll1. О чём было сказано выше.

Очевидно, что сама по себе грамматика и прочие академические костыли - это мусор. И в реальности там будут контексты. Только толку от эта рассуждений в данном контексте нет.

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

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

С чего ты взял, что грамматика c3 контекстно-свободная?

Где ответ на это? На то откуда ты взял c3?

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

Срочно нужна формализация этого ввиде ll1-грамматики. Как это должно выглядеть.

Ну ты и дебилушка. Вот в пользовательском коде объявляется переменная foo. В какой-то пользовательской функции в неё записывают значение, а в какой-то читают. Покажи, как без использования чего-то вроде std::unordered_map<std::string, llvm::Value*> сгенерировать машкод?

Ответ за это, а так же причём тут переменные, llvm, машкод и прочая чушь.

Убийца ли C язык C3? (комментарий) - на это тоже ответ.

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

грамматику, которая селктит правила исходя из знания тип это или не тип. Как вы это запишите?

enum class Type { Int, Bool } type;
struct Var {
    Type type;
    std::string name;
};

// ident :== [a-zA-Z]+ ;
std::string parseIdentifier() {
    return look();
};

// intType ::= [0-9]+ ;
// boolType ::= 'true' | 'false' ;
// type ::= intType | boolType ;
Type parseType() {
    auto token = look();
    if (token == "true" | token == "false") return Type::Bool;
    else return Type::Int;
}

// var ::= type identifier ; 
Var parseVar() {
    Var v;
    v.type = parseType();
    next(1);
    v.name = parseIdentifier();
    next(1);
    return v;
}
fluorite ★★★★★
()
Ответ на: комментарий от right_security

Срочно нужна формализация этого ввиде ll1-грамматики.

«Следующий проход» - это обход ast. Я изначально это и имел ввиду. Парсер оставляем LL(1), а приседания делаем после.

причём тут переменные, llvm, машкод

Ты же сказал, что таблица символов это чушь из википедии. Пока не объяснишь что это такое по-твоему, объяснять не буду.

на это тоже ответ.

банально потому что их так удобнее писать

// let a : int ;
// var ::= letKeyword identifier : type ;?
Var parseVar() {
    Token t = look();
    // и вот с генератором ты тут так не сделаешь
    if (t == "leet") {
        out("Maybe you mean 'let'?");
    }
}
fluorite ★★★★★
()
Последнее исправление: fluorite (всего исправлений: 1)
Ответ на: комментарий от fluorite

Что это? Тут нет никакой грамматики.

// intType ::= [0-9]+ ;
// boolType ::= 'true' | 'false' ;
// type ::= intType | boolType ;

Ну, это не типы. Это типы литералов.

// var ::= type identifier ; 

Это тот самый мусор, lit id - это не имеет смысла. Какие-то огрызки лабы.

Нужно на уровне грамматики(ll1) как-то определять является ли идентификатор типом, либо нет.

Данная портянка никакого отношения к этому не имеет. Речь не идёт о том «как в лапше в контексте что-то пробросить», а то как это формализовать в ll1-грамматику.

Поэтому ненужно пастить с лабы то как это делал. Проблема не в этом. Проблема в том, что была ll1-грамматика. Ты расширил её программной лапшой. В результате получилась ll1-грамматика+(условно)инплейс-грамматика из лапши. Если эта грамматика из лапши не обладает ll1-свойствами, то результирующая грамматика не является ll1, очевидно.

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

«Следующий проход» - это обход ast. Я изначально это и имел ввиду. Парсер оставляем LL(1), а приседания делаем после.

Ты не можешь это делать после. У тебя будет не рабочим разбор, никаким ll1 твой парсер быть не может.

Ты же сказал, что таблица символов это чушь из википедии. Пока не объяснишь что это такое по-твоему, объяснять не буду.

Где я такое сказал? Пруфы.

банально потому что их так удобнее писать

Это не ответ. Удобнее почему.

// и вот с генератором ты тут так не сделаешь

С чего вдруг? То, что генераторы/грамматики мусор это я знаю, но у тебя не об этом спрашивали.

Ты утверждал, что там плохие сообщения. Это враньё. Если твой парсер такой же контексто-независимый, то сообщения будут такими же. Удобнее - это общие свойство кода относительно мусорных формальных способов записи.

Как это делается - делаешь leet-терминал err.

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

Нужно на уровне грамматики(ll1) как-то определять является ли идентификатор типом, либо нет.

Что-то я уже запутался. Твой поинт в чём? Что грамматикой LL(1) невозможно описать отличие типов языка от идентификаторов языка?

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

Где я такое сказал? Пруфы.

«Символы и прочая чушь из википедии»

В целом до царя не дотягиваешь, прости.

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

В инклюдах нет своего неймспейса

Разумеется. #include — это тупо включение одной портянки текста в другую портянку текста.

в цпп модули ненужны

Вот-вот, несколько десятилетий эту мантру слышим.

Сравнение этого с какими-то иными языками всегда подмена понятий.

Да, в то время, как в иных языках мы чётко задаём, что и откуда мы импортируем, в крестах мы просто плодим энное количество файлов с неразрешёнными зависимостями, а потом линкер начинает их разрешать. Пофиг на скорость сборки, пофиг на затейливые ошибки, которые могут вылезать в неожиданных местах, пофиг на то, что живительный ребилдол приходится принимать намного чаще. Зато не как в иных языках.

И если что, я не против инклудов и препроцессора вообще. Так-то это мощный инструмент для нетривиальных случаев. Но имитировать им модульность — такое себе. Это даже не микроскопом по гвоздям, это, скорее, кувалдой по обойным гвоздикам.

почему ты за «Не жили богато, нечего и начинать», а ссылаешься на этот «подход» в контексте недостатков

Потому, что выделенное ключевое слово для функции/метода сразу даёт понять, что это функция, не заставляя человека искать по косвенным признакам. Да, по большому счёту все давно привыкли, помогает оформление кода, функции в одну строку ни один здравомыслящий кодер не пишет. И всё равно это более «мутная» запись.

Да, это недостаток, но это такой недостаток, жить с которым, в принципе, можно. Особенно если с такого синтаксиса начинал.

hobbit ★★★★★
()
Последнее исправление: hobbit (всего исправлений: 3)
Ответ на: комментарий от fluorite

Что-то я уже запутался. Твой поинт в чём? Что грамматикой LL(1) невозможно описать отличие типов языка от идентификаторов языка?

Ты утверждал, что добавление в парсинг контекста оставляет его ll1, о чём тебе сообщили, что нет.

Далее ты начал сливаться на то, что «ну там далее тоже будут таблицы» и прочее невежество/забалтывание. Тебе сказали, что те таблицы к разбору языка отношения не имеют.

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

«Символы и прочая чушь из википедии»

Во-первых так и. Во-вторых там не написано, что это чушь. Опять же, персонаж пытается в подмену контексте.

Т.е. «символы» были сказаны в контексте базвордов и его понимания. Персонаж пытается подменить базворд/описание явление на само явление.

Со всем остальных он слился, как обычно.

right_security
()

А тем временем к ключам компилятора был добавлен ключик --nolibc.

Можно начинать приключения с syscalls. :)

dataman ★★★★★
() автор топика
Ответ на: комментарий от hobbit

Разумеется. #include — это тупо включение одной портянки текста в другую портянку текста.

Не в этом дело.

Вот-вот, несколько десятилетий эту мантру слышим.

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

Да, в то время, как в иных языках мы чётко задаём

Да, потому что иные языки примитивные. Они не могут в инклюды.

что и откуда мы импортируем

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

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

В цпп у инклюдов другое назначение. Другие языки - это окаменелости относительно С++.

в крестах мы просто плодим энное количество файлов с неразрешёнными зависимостями, а потом линкер начинает их разрешать.

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

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

Пофиг на скорость сборки

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

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

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

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

Потому, что выделенное ключевое слово для функции/метода сразу даёт понять, что это функция, не заставляя человека искать по косвенным признакам.

О, ну у тебя совсем, кстати, протухшие лозунги. Это не работает. Забудь про это. С такого уровня аргументацией тебя все более-менее умные адепты паскалятской грамматики засмеют.

Да, по большому счёту все давно привыкли, помогает оформление кода, функции в одну строку ни один здравомыслящий кодер не пишет. И всё равно это более «мутная» запись.

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

Как раз таки fn - это мусор для человека. Человек так не мыслит. Поэтому данный лозунг уже давно выкинули.

Какое-то оформление туда же. Что, куда, зачем. Покажи примеры.

Да, это недостаток, но это такой недостаток, жить с которым, в принципе, можно. Особенно если с такого синтаксиса начинал.

Каждый человек с такого начал. Это синтаксис для богатых. А вот паскалятинка она как раз для бедных. Кто-то не осилил написать парсер, а далее вбросил «это удобно» и побежали рассказывать куллстори.

До сих пор вон повторяете. Но ещё раз. От этого аргумента отказались уже давно. Выкинь его.

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

В целом до царя не дотягиваешь, прости.

Зато ты пытаешься дотянуть, «дебилушку» и «потуги» в разговор принёс именно ты. А царь внезапно вырос и не стал на них «симметрично отвечать».

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

Я подробней напишу почему аргумент от «понятнее» не работает.

  1. человеку привычней именно без fn. Потому что все языки на которых человек пишет/муслит - там нигде нет fn. Утверждать, что fn нужен/удобнее - это утверждать несостоятельность нативных языков. И в принципе человеческого развития.

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

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

В целом это получилось и паскалятину начали насильно внедрять везде. Она была похожа на мусорный бейсик в какой-то степени + маздайка + давление административное.

После в этот начал так же явно продвигаться маздайкой/всякими вендорами дерьма. Они так же давали откаты школам/вузам.

90 - это был апогей, в том числе нулевые. Но в это время сишка вышла из андеграуда и снесла. Несмотря на всё пропаганду паскалятина была уничтожена.

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

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

  1. Но всё совсем плохо стало, когда появились массово скриптовые языки, локальные функции. Функция должна быть выражением. Все стало понятно, что никакие fn там нахрен не упали и выглядит это слишком позорно.

Поэтому, когда в каждом языке есть x => x/|x| x - ещё тысячи примеров - рассуждения о том, что человеку нужно/поноянт fn. Что функции не могут быть записаны в строку. Это всё доказало свою нелепость на практики.

Поэтому среди умных адептов паскалятины данный аргумент был упрознён. Как позорный и про него пытаются забыть. А тем, кто его использует - тот просто забыл лозунги обновить с 90/00.

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

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

Мы тут вообще-то важную тему обсуждаем, контекст и LL(1) парсеры. А без профессиональных терминов и барахтанья в луже тут никак, сам понимать должен.

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

Ты утверждал, что добавление в парсинг контекста оставляет его ll1, о чём тебе сообщили, что нет.

Я утверждал, что «контекст» можно восстановить после парсинга, оставив грамматику контекстно-свободной и обойдясь одним lookahead при разборе, что равносильно ll1.

fluorite ★★★★★
()
Последнее исправление: fluorite (всего исправлений: 1)
Ответ на: комментарий от hobbit

В общем, поэтому я тебе помогу сделать твои доводы состоятельным.

  1. в цпп нельзя сделать модули. Там есть полиморфизм. Если ты их хочешь - тебе ненужен цпп. Даже в си с классами очень сложно сделать модули.

  2. ты привык к паскаль-стилю/тебе так понятнее. Поэтому тебе просто нужно выбрать такой язык. Никаких доводов за fn нет. Либо ссылаться на простоту реализации/языка. Как это делает какой-нибудь го.

И если что, я не против инклудов и препроцессора вообще. Так-то это мощный инструмент для нетривиальных случаев. Но имитировать им модульность — такое себе. Это даже не микроскопом по гвоздям, это, скорее, кувалдой по обойным гвоздикам.

Это да, но нужно понимать, что в цпп инклюди не потому что инклюды.

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

Все остальные свойства инклюдов должны остаться. От них напрямую зависит С++. С тем, что pp мусор никто не спорит.

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

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

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

Вот С++ - это апей человеческого развития, лучшие из лучших его пилят. Там есть то, чего нет и чего ещё 20 лет не осилят остальные. Но люди почему-то утверждают, что там не осилли модули. Модули, которые мусор и которые есть везде. Любой школьник на лабе делает эти модули.

Это всё пропагандиские штапы призванные дискредитировать цпп и посеять в обществе невежество. Их нужно глушить и не уподобляться.

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

Я утверждал, что «контекст» можно восстановить после парсинга,

Второй раз забирать/делать параллельный разбор? Уровень оправданий поражает воображение.

оставив грамматику контекстно-свободной

Нет. Это невозможно. Если грамматика не даёт корректный результат - это не грамматика. Это её огрызок. И парсер будет не парсером, а огрызком.

С таким уровнем манёвров можно что угодно свести к чему угодно. Берём парсер скобочек, а далее «ну остальное мы добьём после». Это так не работает.

Для тех кто не понял уровня манёрвов данного персонажа. Вот есть у нас у сишки какое-нибудь id * id - мы не знаем что это var decl, либо op*.

Данный персонаж нам предлагает ввести «маня-результат», грамматика нам не будет давать то, что это за конструкция. Будет давать маня-конструкцию, которую мы потом уже должны будет допаршивать где-то там.

Т.е. нам нужно сделать 2 парсера, что на самом деле в общим делает парсер не контексто-свободным. И всё это данный персонаж придумать, чтобы оправдать свою чушь о том что «лл1 хватит всем».

Дак вот, вторая стадия парсинга это не парсинг. Он пытается в своих манёрвах называть это чем угодно, только не парсингом. Но это парсинг.

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

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

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

Да или нет? Вопрос ведь простой. Имеет прямое отношение к делу. За проверку типов парсер отвечает или нет?

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

Кстати, там он далее пытается маняврировать. Пытаясь цепляться хоть за что-то.

Допустим с той же семантикой. Семантика это в целом слишком общее понятие. Противопоставление её грамматики - туда же.

Что он пытается сделать. Он пытается сообщить, что в наше кулл-языке грамматикой будет маня-сущность, т.е. x * y - это маня-сущность, а вот что это - декларация переменной, либо умножение/оператор* - это уже семантика.

На жонглировании понятиями можно что угодно куда угодно записать. Ненужно ловиться на это.

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

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

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

Имеет прямое отношение к делу.

Не имеет. Ты что цитировал? Показывай там это дело.

За проверку типов парсер отвечает или нет?

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

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

Не второй разбор, а проход по дереву разбора

Какому древу, если древо то нет.

Удивительно то как плывёт данный персонаж. Ему привели пример. Что он сделал? Опять слился. Показывай мне «древо разбора» для a * b.

В целом любой гений манёвра ловится на конкретике.

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

Показывай мне «древо разбора» для a * b:

ну допустим, у меня не сишка и нет указателей, а что-то простое:

         Ident 'a'
BinOp  Op '*'
         Ident 'b'
fluorite ★★★★★
()
Ответ на: комментарий от right_security
clang -Xclang -ast-dump main.c

TranslationUnitDecl 0x2199f98 <<invalid sloc>> <invalid sloc>
|-TypedefDecl 0x219a858 <<invalid sloc>> <invalid sloc> implicit __int128_t '__int128'
| `-BuiltinType 0x219a530 '__int128'
|-TypedefDecl 0x219a8c8 <<invalid sloc>> <invalid sloc> implicit __uint128_t 'unsigned __int128'
| `-BuiltinType 0x219a550 'unsigned __int128'
|-TypedefDecl 0x219abd0 <<invalid sloc>> <invalid sloc> implicit __NSConstantString 'struct __NSConstantString_tag'
| `-RecordType 0x219a9a0 'struct __NSConstantString_tag'
|   `-Record 0x219a920 '__NSConstantString_tag'
|-TypedefDecl 0x219ac78 <<invalid sloc>> <invalid sloc> implicit __builtin_ms_va_list 'char *'
| `-PointerType 0x219ac30 'char *'
|   `-BuiltinType 0x219a030 'char'
|-TypedefDecl 0x21d9830 <<invalid sloc>> <invalid sloc> implicit __builtin_va_list 'struct __va_list_tag [1]'
| `-ConstantArrayType 0x219af10 'struct __va_list_tag [1]' 1 
|   `-RecordType 0x219ad50 'struct __va_list_tag'
|     `-Record 0x219acd0 '__va_list_tag'
`-FunctionDecl 0x21d98e8 <main.c:1:1, line:5:1> line:1:5 main 'int ()'
  `-CompoundStmt 0x21d9ba0 <col:12, line:5:1>
    |-DeclStmt 0x21d9a50 <line:2:3, col:8>
    | `-VarDecl 0x21d99e8 <col:3, col:7> col:7 used a 'int'
    |-DeclStmt 0x21d9ae8 <line:3:3, col:8>
    | `-VarDecl 0x21d9a80 <col:3, col:7> col:7 used b 'int'
    `-ReturnStmt 0x21d9b90 <line:4:3, col:14>
      `-BinaryOperator 0x21d9b70 <col:10, col:14> 'int' '*'
        |-ImplicitCastExpr 0x21d9b40 <col:10> 'int' <LValueToRValue>
        | `-DeclRefExpr 0x21d9b00 <col:10> 'int' lvalue Var 0x21d99e8 'a' 'int'
        `-ImplicitCastExpr 0x21d9b58 <col:14> 'int' <LValueToRValue>
          `-DeclRefExpr 0x21d9b20 <col:14> 'int' lvalue Var 0x21d9a80 'b' 'int'

$ cat main.c
int main() {
  int a;
  int b;
  return  a * b;
}

fluorite ★★★★★
()
Последнее исправление: fluorite (всего исправлений: 1)
Ответ на: комментарий от fluorite

Не, я то знаю у тебя не сишка. Мог бы ты сделать сишку(не копипастой) - ты бы мне такую чушь не писал.

А так да, ты превзошёл сам себя. В контексте «как сделать X» самое позорное что ты мог родить - это «у меня нет X». Особенно учитывая то как ты рассказывал о том как это X сделать.

А когда тебе дали пример - ты засыпался. Удивительные эксперты.

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

Так же, ты мне объясни. Вот зачем ты это пастишь? К чему? Ты думаешь, что рандомная паста херни из интернета в чьих-то глазах добавить тебе веса?

Что ты мне этим показал? Вернее показал то понятно что - невежество. Что хотел показать?

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

Дерево тебе показал. Можешь там увидеть VarDecl a 'int' и понять, что никакой int в грамматику можно не совать. Парсер будет LL(1). Типы проставим пройдя по дереву.

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

Причём тут int? Какое отношение твоя паста имеет к теме? Тебе выше дали задачу. Показывай её решение, а не сливайся на «у меня нет», пасту какой-то чуши и «инты».

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

Вместо int можешь написать mymodule::supertype::type::subtype. Моё изначальное утверждение - парсер можно оставить LL(1) и определение типов делать потом. От тебя всё ещё жду обяснения, что за таблицы символов и зачем они в компиляторах.

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

Моё изначальное утверждение - парсер можно оставить LL(1) и определение типов делать потом.

Тебе выше дали задачу. id * id в сишке. Показывай оставление парсера ll1 и определение типов потом.

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

Бла-бла-бла, какая-то бредятина.

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

  1. Про компактность хорошо сказано. А выразительности что-то нету.
  2. Зачем два действия совмещать в одном? Это всегда не удобно.
  3. Остальное пропустил, какая-то личная отсебятина.

Как итог:

array[some]; // действие 1
some -= 1;   // действие 2

Компактно, выразительно, понятно.

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

Совсем поломался. Ответов нет - одни слёзы.

Про компактность хорошо сказано. А выразительности что-то нету.

Как это нету, если есть. Показывай у себя.

Зачем два действия совмещать в одном? Это всегда не удобно.

Аргументация. Кстати, а почему ты совмещаешь два действия в array[some]? Почему два действия в -=?

Компактно

В 2 раза больше кода.

выразительно

Мусор валяющийся непонятно где.

понятно

В целом аргументация типичная. Не осилил. Так и пиши, зачем всё остальное?

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

Кстати, а почему ты совмещаешь два действия в array[some]?

Да неужели? Очень интересно.

Почему два действия в -=?

Увеличить переменную на один – одно действие.

Мусор валяющийся непонятно где.

Ну так уберитесь. А с кодом что не так?

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

Да неужели? Очень интересно.

На самом деле три. Обращение к переменным + оператор.

Увеличить переменную на один – одно действие.

Да. Это составной оператор, такой же как ++. Только тут ты опять засыпался. Это не увеличить на один. Это прибавить+приравнять x

Ну так уберитесь. А с кодом что не так?

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

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

В целом рассуждения данного персонажа в принципе стоят ноль. Он изначально сделал подлог. Там пацан упомянул это, но не стал ловить. Я тоже пощадил, чтобы он не слился раньше времени.

Т.е. x -= 1 в принципе не влияет на то где это использовать, arr[x -= 1] - это так же работает.

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

Судя по всему он пытался спастит какой-то лозунг на тему i-- нельзя записать в строчку, но толку с него? Это просто ограничение i += 1 - он не может вернуть предыдущие значение. Инкремент попросту мощнее, потому как имеет оба варианта.

Написать и то и то можно в строчку, как уже говорилось. Зачем писать в 2 строчке персонаж объяснить так и не осилил, кроме каких-то жалких «твоя чушь - твоя неправ»,

right_security
()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.