0
да ну, не сложнее, чем регистры МК на си напрямую долбить, без библиотек.

Сложнее. Любой современный ЯП позволит вам декомпозировать задачи, позволит вам писать читабельный и самодокументируемый код, отлаживать его по частям, писать ютнит-тесты. Код LINQ запроса можно разбить на части, отлаживать по отдельности, пройтись по нему в пошаговом режиме отладки. А регэкспыы – чистая магия (нет средств для декларирования своих целей в рамках синтаксиса, нет средств нормальной отладки)
  • avatar
  • e_mc2
  • 03 апреля 2015, 01:02
0
Я бы посоветовал с регулярными выражениями подружиться, тогда удаление комментария до конца строки займет 1 команду

У вас есть проблема. Вы решили использовать регулярные выражения чтобы её решить. Теперь у вас две проблемы :)

Регулярные выражения не читабельны. Это отличный пример write only кода. Вот вы можете понять/декодировать/найти ошибку/отладить следующую регулярку?:

^(((0[1-9]|[12]\d|3[01])\.(0[13578]|1[02])\.((19|[2-9]\d)\d{2}))|((0[1-9]|[12]\d|30)\.(0[13456789]|1[012])\.((19|[2-9]\d)\d{2}))|((0[1-9]|1\d|2[0-8])\.02\.((19|[2-9]\d)\d{2}))|(29\.02\.((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))))$
  • avatar
  • e_mc2
  • 02 апреля 2015, 23:47
+1
Даже обработки комментариев нормальной не умеет (5 строчек кода на Си!).

На самом деле почти всю функциональность по обработке JS как у автора (с корректным удалением однострочных комментариев) на С# можно реализовать вообще одной строкой (одним выражением).
Что-то типа
string input = "buz();    //comment\n   \t  foo();\n      \t  bar();";
string result = input.Split('\n').Select(s => s.Split(new string[] { "//" }, StringSplitOptions.None).First().Trim()).Where(s => s.Length > 0).Aggregate((a, s) => a + " " + s);
Console.WriteLine("Result: " + result);

Result: buz(); foo(); bar();


(на самом деле так делать не нужно, длинные LINQ тяжело читать плюс лучше использовать StringBuild)
Просто автор, видимо, не захотел заморачиваться с обработкой комментариев

Зато подавай фреймворк 3.5

А чем вас версия фреймворка не устраивает (тяжело сейчас найти машину с виндой без установленного 3.5) Нет, ну можно, ради спортивного интереса, переписать код под 1.0, можно даже написать аналогичной код на чистом ASM. Но зачем?
  • avatar
  • e_mc2
  • 02 апреля 2015, 22:06
+3
Для большей эффективности джваскрипт можно предварительно прогнать через гугловый компилятор (он умеет делать более продвинутые оптимизации, типа замены имен локальных переменных и т. д.)
  • avatar
  • e_mc2
  • 02 апреля 2015, 15:26
0
Поверьте, не все так просто. Есть действительно «котируемые» в отрасли сертификаты, и их стоит упомянуть в резюме (как правило, получение таких сертификатов стоит денег). Но не нужно формировать резюме по принципу «больше бумаги — чище зад». Ели человек претендует, например, на должность «ведущий разработчик С++», а в резюме он акцентирует внимание на том, что он «прошел 3-х недельный курс С++ для новичков в ООО Рога и Копыта » — то это скорее работает в минус.
  • avatar
  • e_mc2
  • 31 марта 2015, 20:50
0
Да, согласен, что-то я протупил…
  • avatar
  • e_mc2
  • 27 марта 2015, 17:12
0
Он не полностью вычислил адрес на этапе компиляции остался один add в рантайме, хотя мог бы и от него избавиться, т. к. оба операнда константы.
  • avatar
  • e_mc2
  • 27 марта 2015, 16:46
0
Набросал тестовый пример (по мотивам того, что в посте)

#define SRAM_BB_BASE          ((unsigned)0x22000000) /*!< SRAM base address in the bit-band region */
#define SRAM_BASE             ((unsigned)0x20000000) /*!< SRAM base address in the alias region */

#define MAILBOX   0x20004000

#if 0
#define BITBAND_SRAM(a,b) ((SRAM_BB_BASE + (a-SRAM_BASE)*32 + (b*4))) 

#else
inline unsigned BITBAND_SRAM(unsigned a, unsigned b) {
	return ((SRAM_BB_BASE + (a-SRAM_BASE)*32 + (b*4)));
}
#endif

unsigned foo(void) {
	return  *((unsigned *) BITBAND_SRAM(MAILBOX,0));
}

arm-elf-gcc.exe -mcpu=arm7tdmi -O -Wall -c test.c

В обоих случаях (что с макросом, что с инлайн) результат одинаков (притом одинаково недооптимизированный :)
00000010 <foo>:
  10:   e3a03422        mov     r3, #570425344  ; 0x22000000
  14:   e2833702        add     r3, r3, #524288 ; 0x80000
  18:   e5930000        ldr     r0, [r3]
  1c:   e12fff1e        bx      lr
  • avatar
  • e_mc2
  • 27 марта 2015, 15:32
0
Однако, в стандарте напрямую сказано, что #define a 4 + 5 должен быть заменён на 9.

Может я ошибаюсь, но я не поманю такого (в каком именно разделе стандарта это указанно?)

В качестве теста прогоним код
#define a 4 + 5
int foo(void) {
	return a;
}

через препроцесор
arm-elf-gcc.exe -E test.c

получаем после препроцессора
# 1 "test.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "test.c"

int foo(void) {
 return 4 + 5;
}
Замены на 9 препроцессор не сделал, дальше компиляция и дерево выражений …
  • avatar
  • e_mc2
  • 27 марта 2015, 14:46
+1
Инлайн функция будет всегда в рантайме.

Нет, вы ошибаетесь.
Вот пример

inline foo(int value) {
	return value + 10;
}

int bar(void) {
        return foo(1);   
}

Результат
00000008 <bar>:
   8:   e3a0000b        mov     r0, #11 ; 0xb
   c:   e12fff1e        bx      lr

как видно функция возвращает посчитанную на стадии компиляции константу

Это работает по другому. Нельзя говорить что «макрос считается в компилтайме», там происходит следующее – происходит подстановка макроса (как и подстановка инлайн функции) дальше для полученного выражения (в примере выше это 1 + 10) компилятор строит expression tree. Он умеет упрощать expression tree, он видит, что в двух узлах дерева константы и упрощает дерево заменив их суммой. То бишь «считается в компилтайме» на стадии работы с деревом выражений, к этому моменту и макрос и иналайн функция будут внедрены в код, мы получим одинаковое деревья выражений и одинаковый результат (хотя там есть некие моменты, но можно их упустить)

Это замена макросов
Я говорю что constexpr и макрос – это 2 разные вещи, для разных целей, нельзя их сравнивать опираясь на частные случаи. Например, с помочью макросов можно конкатенировать токены (##) и т. д. в то время как у constexpr своя задача…
  • avatar
  • e_mc2
  • 27 марта 2015, 14:16
0
То есть, вы зачастую можете использовать constexpr-функциии вместо макросов (как в данном примере), но не это основная идея constexpr
  • avatar
  • e_mc2
  • 26 марта 2015, 22:04
0
Нет, это не замена макросам (ближе к замене макросов — это инлайн функции), это другой очень мощный механизм, который говорит компилятору, что значение функции может (и должно при определенных условиях) быть вычислено на этапе компиляции.
  • avatar
  • e_mc2
  • 26 марта 2015, 21:56
0
Если компилятор не сможет вычислить значение на этапе компиляции – значение будет вычислено в runtime (если мы говорим о constexpr-функциях)
  • avatar
  • e_mc2
  • 26 марта 2015, 21:43
+1
Я конечно разделяю вашу идею с использованием constexpr, это действительно мощное средство. Но боюсь для многих вариант «бросайте все и переходите на С++11» это слишком радикально :) Еcли речь идет только о контроле типов на этапе компиляции – достаточно заменить макрос на инлайн функцию. Плюс не нужно будет париться с другими проблемами макросов (типа оборачивания в do {} while(0))
  • avatar
  • e_mc2
  • 26 марта 2015, 21:05
0
Хотя да, язык макросов тьюринг-полный
Разве? Я знаю что шаблоны С++ являются тьюринг-полными, а макросы С от этого очень далеки.
  • avatar
  • e_mc2
  • 26 марта 2015, 14:59
+1
правда в данном случае горе-оптимизаторы, не видящие подвоха
Коллега Vga правильно написал.

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

uint16_t a = 1;
uint16_t b = 1;


Компилятор гарантирует лишь то, что четко детерминировано в стандарте С (советую с ним ознакомиться).
  • avatar
  • e_mc2
  • 19 марта 2015, 23:58
0
что это «чистая» функция
Верне, в данном случае, что функция не обладает побочными эффектами (ибо «чистоста» подразумевает, дополнительно, что функция детерминирована)
  • avatar
  • e_mc2
  • 19 марта 2015, 12:16
0
вызов функций он вообще не имеет права менять.
Нет, это миф. Может, я же приводи пример
int I = foo() + bar();

Компилятор действует по общим правилам (побочные эффекты, точки следования). Он считает, что функция имеет побочные эффекты кроме случаев, когда он может убедиться в том, что это «чистая» функция.
В Вашем примере с инлайн функциями он может убедиться, что побочных эффектов нет и дальше делать все что угодно.
  • avatar
  • e_mc2
  • 19 марта 2015, 12:08
0
а через uart заливать никак?

Можно. Вот инструкция (можно не городить такой программатор, просто вручную переводить BOOT0 и BOOT1 в нужнее состояния, а потом вернуть назад, вижу на плате даже есть джемпера на соответствующийх выводах)
  • avatar
  • e_mc2
  • 17 марта 2015, 16:53
0
А так не проще?

Проше. Это «классика». (но я бы рекомендовал учесть замечания Mihail)

Но такой подход (ИМХО) уступает всем вариантам, предложенным выше: нет атомарности как у bit-band, нет читабельности и проверки на этапе компиляции как у структур с битовыми полями …
  • avatar
  • e_mc2
  • 13 марта 2015, 23:22