AT91SAM7 + интерпретатор С



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

Предыстория.

Сам проект изначально задумывался как очередная вариация на тему «умный дом». Проект делался just for fun, а посему не судите строго.
Итак, изначально было собрано устройство на базе AT91SAM7S512 с определенным «обвесом» таким как GSM модуль, JPEG видео камера, SD карта памяти, читалка для RFID карт и многое другое. Дополнительные датчики и исполнительные устройства можно навешивать через 485 интерфейс. Одним словом – стандартный «велосипед» по мотивам «умного дома».
Наступил этап написания софта для работы со всей этой периферией. Первым делом была реализована программная поддержка всех перечисленных периферийных устройств – получился некий уровень абстракции от железа. Следующий этап – реализация самой логики работы устройства, например: сработал такой-то датчик – необходимо отравить SMS сообщение на такой-то номер, или наоборот – пришло SMS сообщение с определенным текстом – нужно что-то включить или выключить.
Первой идеей было всю эту логику захардкодить, а кое-какие параметры настройки вынести в конфигурационный файл на SD карту. Но при таком подходе терялась гибкость, для изменения функциональности необходимо собирать новую прошивку. Появилась идея – а что если использовать интерпретатор какого-то простого языка? Тогда пользователь (а я ориентировался на продвинутого пользователя) мог бы написать некий скрипт описывающий логику работы устройства, записать его на SD карту и воткнуть в девайс. Красота… Одна универсальная прошивка которая интерпретирует скрипт и обеспечивает взаимодействие скрипта с периферией.

Решение.

Изначально я хотел найти очень легковесный интерпретатор javascript и портировать его на свою платформу. Потратив несколько дней, я нашел отличный open source проект PICOC. PICOC – это интерпретатор языка С и минимальными требованиями по ресурсам (размер исходного кода интерпретатора около 4000 строк). На этом проекте я и остановил свой выбор.
Портирование PICOC под свою платформу проблем не вызвало – все платформозависимые функции в PICOC вынесены в отдельный файл и для минимальной функциональности достаточно реализовать всего пару-тройку простых функций.
Первым делом я запустил интерпретатор в интерактивном режиме – он интерпретировал команды вводимые с консоли. Вводишь что-то типа printf(“Hello”) — он отвечает в консоль Hello. При этом у меня сразу возникла ассоциация с ZX Spectrum и я чуть не пустил скупую мужичью слезу.
После того как я набаловался с итеративным режимом я реализовал выполнение скрипов с SD карты, чем девайс и занимается по сей день 24 часа в сутки.

Резюме.

Плюсы PICOC:
— бесплатность и открытость проекта;
— минимальные, как для полноценного интерпретатора, требования к ресурсам (в первую очередь к памяти);
— кошерный С а не какой-то там javascript или BASIC;
— легко портировать на любую платформу, достаточно просто реализуется вызов нативного кода из скрипта, все это неплохо документировано на сайте проекта.

Минусы:
— Весь скрипт грузится в ОЗУ. Хотя как иначе? Я решил что «64кБ хватит всем». За всех не уверен, но для моих целей пока хватает.
— Откровенно говоря — проект сыроват. В процессе работы было выявлено несколько глюков связанных с некорректной интерпретаций сложных конструкций. Выявленные глюки были занесены в баг-треккер на сайте проекта и исправлены автором за несколько часов, но неприятный осадок остался.

Но, в любом случае результатом я доволен, я на выходе получил очень гибкое решение, можно даже сказать некую универсальную платформу.
С удовольствием отвечу на любые вопросы в комментариях.
  • +2
  • 07 октября 2011, 14:46
  • e_mc2

Комментарии (87)

RSS свернуть / развернуть
интерпретирует текст или промежуточный байт-код?
какой мин.объем ОЗУ?
0
Интерпретируется текст, в этом вся прелесть. Касательно ОЗУ — однозначно сказать тяжело. Интерпретатор имеет внутреннюю реализацию кучи (heap). Место под кучу резервируется сразу, размер задается через #define HEAP_SIZE … Сколько места резервировать зависит от размера скипта, так как он целиком грузится в память. Также нужно учитывать, что переменные, созданные внутри скрипта тоже «кушают» память из кучи. Для моих задач (скипт порядка 500 срок кода) хватает 16кБ.
0
Интерпретируется текст
то есть мягко говоря небыстро, и память жрет нехило. Интересно сравнить с eLua.
0
eLua – безусловно более серьезное решение, но мне оно показалась слишком сложным. По поводу скорости – конечно не фонтан, вот такой пустой цикл «for(int i = 0; i < 10000; i++);» выполняется за секунду. Но все равно, для определенных задач такой производительности хватает.
0
Интересный проект. Вот только как со скоростью выполнения скриптов?
Как по мне, так лучше реализовать некий API для модулей и подгрузка с карты типа как в соседней теме «STM32 и дзен».
0
По поводу скорости – отписался выше. А касательно статьи «STM32 и дзен» — именно эта замечательная статья сподвигла меня рассказать о своих наработках. Я тоже думал о создании оверлеев но оверлеи нужно компилировать. А здесь – достал карточку из девайса, вставил в комп, отредактировал скипт в любом текстовом редакторе и готово. Хотя, конечно, я отдаю себе отчет в том, что рядовой пользователь скрипт править не будет, а для «продвинутого» пользователя скомпилировать оверлей не проблема.
0
Хотелось бы, чтобы кто-нибудь объяснил, зачем нужна скорость в приложениях для управления процессами типа «Умный дом», «Химический эксперимент», «Газовый котел» и прочее????
+1
  • avatar
  • mzw
  • 07 октября 2011, 16:14
  • ↓
Ведь вся работа с датчиками и исполнительными устройствами ведется на уровне их драйверов и API, а интерпретатор отвечает только за логику.
0
Совершенно верно, в моем случае это именно так и реализовано. Скрипт взаимодействует с реальными устройствами через API, сама поддержка устройств захаркоджена в прошивке. Српит только описывает высокоуровненую логику «умного дома», требования к производительности там невысокие (мы не техпроцессом на предприятии управляем :)), задержки в доли секунды вполне приемлемы.
0
Мне бы вот хотелось, чтобы оно не хотело 16кб ОЗУ под текст скрипта :)
0
А подо что ты бы его использовал?
0
Еще не знаю, но мне не нравится что под него нужен старший кортекс) Вполне мог бы из флеша интерпретировать.
Ну и опять же, скрипты на С — это как ломик вместо оружия, только для окончивших MIT.
0
В принципе, это устройство в чем-то аналогично модулю Fractal (только там Бейсик — я о них писал).
И если его также заставить писать скрипт во флэш, то и интерпретировать он сможет оттуда — принципиальных проблем нет.
0
В идеале хотелось выполнять скипт прямо из файла. Для повышения производительности можно кешировать фрагменты скипта в памяти. Но в данная реализации интерпретатора требует загрузку скрипта в ОЗУ целиком.
А поп поводу скриптинга на С – мне эта «фича» наоборот понравилась :). Хотя я сам первый раз сталкиваюсь с интерпретатором С.
0
Ну вообще это больше мнение из геймдева. Примерный смысл — дизайнер/маппер/сценарист и С несовместимы, а скрипты пишут именно они. Поэтому юзают чего попроще, не требующее вывихивания мозгов. Васик не зря популярен. И луа.
В ПЛК та же история, тока их кодят люди с уже вывихнутыми мозгами — инженеры. Поэтому там такие забавные языки, как LD.
0
Но-но, у кого это тут вывихнутые мозги :) А по кумполу?
На самом деле МЭКовских языков несколько и они не такие страшные, текстовое описание там тоже есть.
Между прочим многие автоматчики (те самые, кто на LAD'е программируют) не прочь утащить домой эти решения, но уж больно они дороги и, пожалуй, слишком заумны. Зато какие там штуки классные есть, уже всё готовое. К примеру, ibaPDA анализатор. Эту прогу цепляешь к сетке и она тебе хоть вечность аккуратно пишет красивые логи по всем сигналам. Расположит как тебе надо, нарежет на файлы как надо и пр. пр.
0
Но-но, у кого это тут вывихнутые мозги :) А по кумполу?
У всех специалистов, независимо от профиля (от профиля зависит направление и степень вывиха). Разве не очевидно?
На самом деле МЭКовских языков несколько и они не такие страшные, текстовое описание там тоже есть.
Они не страшные, они не привычные. Ориентированы на людей с другим мышлением, нежели мышление программистов на императивных языках.
0
Я после знакомства с МЭКовскими языками сделал для себя три деления по разнородности (степени вывихнутости):
1) обычные императивные;
2) МЭК'овские, я не знаю как точно это описать, скажем так событийно управляемые конструкции;
3) языки экспертных систем и ИИ (где действуют специальные математические правила срабатывания фактов по правилам), например, CLIPS.

Честно говоря, не знаю куда здесь LISP отнести. При изучении каждого из этих языков у меня было словно какое-то прозрение (вывих очередной, в ваших терминах). Никогда бы не подумал, что такое бывает.
0
Согласно вики LISP функциональный/мультипарадигменный.
0
скрипты на С — это как ломик вместо оружия, только для окончивших MIT.
Он media.giantbomb.com/uploads/0/6131/190973-gordon1_large.jpg смотрит на тебя как на…
0
Гм, я про него и говорил) Довольно известна шутка про «ломик — только для героев игр, окончивших MIT!»
0
Ух ты! Интерпретатор C!

А JIT не получится сделать?
0
  • avatar
  • _YS_
  • 07 октября 2011, 21:45
  • ↓
На AT91SAM7… — сильно сомневаюсь :). А в теории – почему бы нет?
0
Прикольно, меня радует.
А как сделан интерфейс к нативному коду из интерпретируемого? Набор готовых функций? Например, вызов функции SendSMS() из скрипта передаёт управление функции в прошивке, выполняющей отправку сообщения? А обратная связь есть, например нажатие кнопки вызывает какую-то функцию в скрипте? Хотя это наверное и не нужно, проще из скрипта кнопку опрашивать периодически.
0
  • avatar
  • ACE
  • 07 октября 2011, 22:38
  • ↓
Есть довольно универсальный интерфейс доступа к нативному коду. Можно определять свои функции, которые реализуются в нативном коде. Как взаимодействует скрипт и нативные функции описано здесь. Все довольно просто. Жаль, но в нативный код нельзя передать указатель скриптовую на функцию (callback) — приходиться выкручиваться.
0
Ребята, вы радуете день ото дня! сначала дзеном. затем PicoC
Осталось только придумать что бы всем хватало не 64кб, а всего 2кб.
0
  • avatar
  • letni
  • 09 октября 2011, 23:45
  • ↓
Я думаю PicoC можно заставить работать с кодом во флеше, а не озу. Врядли он код на лету колбасит. Возможно, мона даже заставить выполнять код из внешней флешки или карточки. Правда, еще медленнее.
0
Честно говоря да, pgm_read никто не отменял. Дело в другом если Heap организовывается динамически, а так оно и есть то флеш уже отпадает. (это я с намеком на AVR) Разве-что в виде Bootloader -а который принимает скрипты (очень милая идея!).
Озу — хорошо, ну только с камнями у которых есть поддержка внешнего ОЗУ (Mega8515..)
Вот MMC-шка это годная идея!

В общем осталось только заняться.
0
Кстати, если можно, выложи где-нибудь свою обвязку для Arm-ов
0
  • avatar
  • letni
  • 09 октября 2011, 23:47
  • ↓
Что именно вы подразумеваете под «обвязкой»? Платформозависимые функции? Если да – то они зависят не от архитектуры процессора а от реализации девайса(например работа с консолью для интерактивного режима, работа с файлами для подгрузки #include). Их можно реализовать просто заглушки.
Вот их список:

/* get a line of interactive input */
char * PlatformGetLine(char *Buf, int MaxLen, const char *Prompt);
/* write a character to the console */
void PlatformPutc(unsigned char OutCh, union OutputStreamInfo *Stream);
/* read a character */
int PlatformGetCharacter();
/* exit the program */
void PicocPlatformScanFile(const char *FileName);
void PlatformExit(int ExitVal);
void PlatformLibraryInit(void);
void PlatformCleanup(void); 
0
Интересно можно ли сделать скрипт, который сможет сам написать скрипт для решения задачи и затем исполнить его.
0
Сейчас эта статья в блоге «Умный дом» и IMHO, это не очень подходящий раздел. Здесь от «умного дома» только фраза «я делал это для умного дома». Просто в другом разделе эту безусловно интересную статью было бы легче найти для того, кто реально будет искать интерпретатор или идеи для адаптивного управления.
0
Наткнулся на это обсуждение, а ведь у меня есть свой вариант интерпретатора Си-подобного языка. Скачал указанный интерпреатор, что бы сравнить со своим творением. Надо сказать действительно Си, конечно упрощенный но все же. Мое творение помоему даже поменьше, но сложнее. Полной совместимости с Си нет, т.к. у скриптового языка несколько другие задачи. Попробую описать то что в Си есть, а в скрипте не нужно.

— Типы данных. В Си программист задумывается как данные лежат в физической памяти. Для этого есть long, int, short, char, с плавающей точкой float, double и т.д. В интерпретируемом языке сколько переменная занимает в памяти не важно, важно только, что бы ее размера хватало для решаемых задач. По этому у меня только 4 базовых типа: void, int, float, char, которые занимают 0, 8, 8, 2 байт соответственно.

— Всякие конструкции типа
#define MAX_SIZE 255
имеют смысл при компиляции, что это константа, которую можно сохранять в непосредственном операнде ассемблерной командыв. В интерпретируемом языке ни чем не хуже будет, если написать так:
int MAX_SIZE = 255;
Так же и макросы с параметрами не имеют смысла, т.к. можно вызвать функцию.

— Нет смысла ограничивать размер параметров, передаваемых в функцию. Т.е. если в коде сказано, передать в функцию массив размером гиг, то зачем это искусственно запрещать? Все зависит от программиста, ни кто не мешет явно передать указатель.

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

— Автоматическая очистка памяти, если на нее ни кто не указывает.
— Методы в структурах
— Перегрузка функций
— Перегрузка операторов
— Наследование

В общем не знаю, нужно ли кому-нить… Екзешник + шни файл выложил сюда
cloud.mail.ru/public/MNCs/Lme55F612

Надо написать док, но немного понять как работает можно скажем так:

Subdir(«c:\\program files»)

Реализация этой функции в init.agc

Исходники пока не охота класть на всеобщее обозрение, может потом. Если кого-то заинтересует, пишите… Сам движок кросплатформенный, не использует даже crt библиотек. От платформы зависят только функции ввода-вывода, которые оформлены в отдельном файле.
0
Интерпретатор без исходников эмбеддерам неинтересен…
+1
Выложить то исходники не сложно… Если кому-то интересно. Вообще изначально писал исследовательскую программку для аудиосжатия (надо было коэф. подбирать и т.п.) начальство то так то сяк хотело, вот решил встроенный скрипт сделать. Сделал. Потом уже решил вместо cmd.exe использовать, написал соотв. функции ввода-вывода и т.д. Последние лет 6 периодически что-то добавляю-исправляю. Надо бы описание написать, как по синтаксису так и по написанию бинарных функций, иначе малопонятно будет. На данный момент не хочу выкладывать на всеобщее обозрение. Если нужно, пошлю, с конкретными рекомендациями под конкретную задачу
0
Посмотреть — интересно (в сырках, разумеется). Но для реального применения лично я выбрал бы опенсорсный вариант.
0
Конечно охота, чтоб пользовался не только я один. В сайтописании я 0, вообще не разбираюсь, по сему сделать сайт, на него все положить весьма проблематично. Мне ближе Асм. Ну вот исходники:

cloud.mail.ru/public/KtiA/TJNq5PUeu

файл test.agc — это для моего тестирования, оно зависит от конкретных каталогов, т.е. для проверки не изменилось ли что, копирую вывод, потом сравниваю с прошлым вариантом с помощью какой-нить windiff.

Каталог Portable — это попытка не зависеть от Винды. Хоть там проект Студии, эти исходники хорошо компилятся и gcc.

Файл ExternalFuncs.cpp определяет внешние бинарные функции. В нем содержатся их определения для скрипта и массив указателей на соответствующие реальные функции. Так же в этом файле реализованы всякие sin, atoi и т.п.

SysDependFuncs.cpp содержит функции, реализация которых под конкретную систему, в данном варианте под Винду. Можно было бы использовать всякие fread/fwrite, но для их использования нужно много кг вообще ненужного crt-кода. Ну а чтение содержания каталога я даже не знаю как нормально сделать.

Ассемблерные файлы нужны так же, для независимости от crt. Для их компиляции нужно соотв. образом настроить студию. в 64 битном виде используется JWasm. Этот компилятор позволяет писать без меток. Масм это позволяет только для 32 битного кода.

Немного про синтаксис. Нет оператора switch и вообще меток. Соответственно нет goto. Зато break и continue могут использоваться с параметром. Т.е. если нужно выпрыгнуть из тройного цикла — нужно написать break 3.
Выделение памяти только «на стеке», если сравнивать с Си. Если нужно создать скажем список, то нужно чтоб на объект кто-то указывал. Последний будет жить даже после ухода из его области видимости и будет доступен по указателю. Очистка памяти осуществляется автоматически, нужно только обнулить указатели. Указатели указывают на тип. Не важно это массив или одиночный экземпляр типа. Указателям можно присваивать значения и сравнивать на равно-не равно, арифметики нет. Это гарантирует, что указатель либо указывает на что-то реальное, либо равен NULL. Новые типы определяются как struct, идеи Страуструпа превращения аксиоматичного языка в нечто многословное мне непонятны. Конструкторов и деструкторов нет, не потому что лень или сложно делать, я просто не знаю как. По этому для инициализации объекта нужно в нем создать Init() и явно вызывать. Операторы перегружаются только функциями, не методами. В принципе можно создать и метод — оператор, только он не будет вызываться. Ссылок нет. Они вводят только путаницу в код, помоему не сложно явно передавать указатель.

Можно еще много сказать, и вообще написать док… Но это надо заморочиться
+1
А какого типа интерпретатор? Работает непосредственно по исходному тексту?
Ссылок нет. Они вводят только путаницу в код, помоему не сложно явно передавать указатель.
Забавное решение. Обычно в скриптовых языках нет как раз указателей, только ссылки.
0
Да, выполняет непосредственно текст. Скажем при определении переменной в список заносится структура, в которой сохранен тип, значение и указатель на место в коде на имя. Думал делать какую-то предкомпиляцию, например комментарии выкинуть. Но это не приведет к существенному ускорению, по этому забил на эту идею.
На счет указателей — это самый универсальный способ организации структур типа ассоциативных списков. В скриптовых языках вроде подобные вещи в готовом виде, но этож не универсально. Наверное сказывается мой опыт дровописания.
0
А что мешает делать эти структуры на ссылках? Это практически те же указатели.
0
Ссылка на ссылку это как?
Не инициализированная ссылка это как? Как организовать односвязный список?
Как создать двусвязный список на ссылках? Как скажем убрать из него элемент?
При передаче параметров ссылка — это указатель, перед которым стоит звездочка. Мне непонятно, зачем себя запутывать, а не называть вещи своими именами и не писать явно эту звездочку.
0
Насчет С — не скажу (в нем, впрочем, ссылок и нет, ЕМНИП). Если же смотреть по другим языкам, то насчет ссылки на ссылку с полпинка не скажу, неинициализированная ссылка — так же, как и неинициализированный указатель — nil (или иные названия примерно того же), списки любой связности реализуются ровно так же, как на указателях.
а не называть вещи своими именами и не писать явно эту звездочку
Ровно для того, чтобы не писать эту звездочку.
P.S. Насчет ссылки на ссылку. Этот вопрос обычно решается тем, что ссылки на ссылки не нужны — решаемые ими задачи можно решить не хуже другими средствами.
0
ссылки на ссылки не нужны
Ну вот распространенный и помоему удобный способ обработки ошибок:
ErrorCode func(SomeStruct **a)
{
    ...
}
SomeStruct *a;
if (func(&a))
{
    Обрабатываем ошибку
}
А тут имеем указатель на созданный функцией func объект

Обработка ошибок с помощью исключений, если еще добавить криворукость и слабую компетентность многих приводит к очень глючному коду. Явно обрабатывать ошибки может геморойней, но надежнее.
0
Здесь, опять же, вопрос в том, какой язык используем. Скажем, в дельфи это может выглядеть так:
function Foo(var A: TSomeClass): TErrorCode; //класс - ссылочный тип, в случае структур при переписывании 1 в 1 будет ссылка на указатель на структуру
...
var A: TSomeClass;
if Foo(A) <> ErrorOK then
  //обрабатываем ошибку

А в луа вообще нельзя передать аргумент в функцию не по значению — так сделано специально. Зато можно написать так:
function Foo() ... end
local error, a = Foo()
if error then
  //обработка ошибки
end
//работаем с a


Что до исключений — криворуко можно и коды возврата обрабатывать, а у исключений свои плюсы. Но и минусы есть, да — во-первых, исключение может улететь далеко от места возникновения (но это в определенных случаях тоже плюс), а во-вторых, обработка исключений от каждой операции отдельно будет довольно многословна.
А при передаче параметров в функцию по ссылке часто путаешься, что ты меняешь, параметр в стеке, специально созданный для вызова функции, или какой-то внешний.
Вообще-то, это строго определено в объявлении функции, не зная его ты все равно не можешь функцией пользоваться. Актуально разве что при чтении незнакомого кода, когда неясно, что строчка Foo(a) сделает с аргументом. Но, во-первых, там так и так может быть что угодно (особенно в С с его макросами), а во-вторых, кодонавигаторы позволяют быстро посмотреть объявление Foo.
0
Ну вот распространенный и помоему удобный способ обработки ошибок:
Такой метод, кстати, принят в COM. Иногда несколько раздражает, что для любого возвращаемого методом значения надо передавать переменную под него. Даже если это элементарно возвращаемый тип (т.е. ложащийся в ЕАХ) и метод в принципе не может дать сбой.
0
Насчет С — не скажу (в нем, впрочем, ссылок и нет, ЕМНИП)
int a;
int &b = a;
Здесь b — это указатель на a, только при использовании b будет подставляться *b. А при передаче параметров в функцию по ссылке часто путаешься, что ты меняешь, параметр в стеке, специально созданный для вызова функции, или какой-то внешний. В общем от ссылок только путаница, и все ради того, чтоб не писать звездочку.
0
Насчет С — не скажу (в нем, впрочем, ссылок и нет, ЕМНИП)
int a;
int &b = a;
Это не C, это C++. В С ссылок нет, по крайней мере в тех версиях, с которыми я знаком (и насколько я помню — но, по крайней мере TCC на приведенный код плюется).
+1
Я не настоящий сварщик, но

int a;
int &b = a;

Здесь b — это указатель на a

Это С++ и b это ссылка на 'a' а не указатель на 'a'.
0
Где-то около этого, емнип, еще есть понятие «алиас». Но не помню точно даже относится ли это к С++.
0
Фиг с ним со Страуструпом. Объектно-ориентированы не языки, а стили программирования. Можно и на асме писать объектно-ориентировано, будет просто чуть больше писанины. Надо передавать в явном виде this, может методам какой-нить суффикс-префикс приписывать. Можно это обернуть в макросы, которые в Масме намного более развитые, чем в Си(++).

Я в своем интерпретаторе старался сделать логично, т.е. что написано, то и делать. Например:
int array[1000000000];
func(array);
Тут прямо как сказано, будет создана копия этого массива, засунута в аналог стека, вызвана функция. Если же надо обработать тот же массив, не копируя его, то надо явно писать:
func(&array)
0
Если же надо обработать тот же массив, не копируя его, то надо явно писать
Я считаю, что это должно писаться со стороны функции, а не каждый раз при вызове (тем более что функция, рассчитанная на получение указателя все равно не будет работать с переданным по значению аргументом — то есть, мы дважды указываем, что аргумент передается по адресу, хотя можно было обойтись одним указанием).

Например:
int array[1000000000];
func(array);
Странный пример. Насколько я знаю С (да и С++) — массив там в принципе является указателем и по значению передан быть не может.
0
транный пример. Насколько я знаю С (да и С++) — массив там в принципе является указателем
Не является. Указатель — это некоторая переменная, которая может менять значения, а массив — некоторый пронумерованный набор данных, лежащий в фиксированном месте памяти. То что указателем можно пользоваться как массивом (типа ptr[n]) — это костыль для удобства. Логичнее было бы писать в таких случаях (*ptr)[n]. Но тут намного больше писанины, не одна звездочка, по этому такой костыль я и у себя сделал.
0
Это не костыль, это особенность языка С — массивы и указатели там одно и то же. Фактически, нотация массива — это не более чем синтаксический сахар для адресной арифметики. В С++ все, как обычно, несколько сложнее.

А что там у тебя в языке — не знаю. Ты не привел документации кроме как «немного отличается от си».
0
Ну, я так считаю, если для какого-нить удобства надо усложнять логику, добавлять if'ы, то это костыль для удобства… Скажем так:
int array[100];
int *ptr = array;
sizeof(array) != sizeof(ptr)
0
Признаться, я не понимаю, о чем ты говоришь.
0
:)) Я говорю то что указатели и массивы — это разные вещи. Что ими удобно пользоваться с помощью похожего синтаксиса, не говорит о том, что это тоже самое. Это я четко осознал когда как раз реализовывал указатели. В принципе просто: Если у тебя указатель, а после него '[]', то вызываешь относительно него оператор '*', а затем продолжаешь. В Си адрес массива ни где не хранится, просто по этому адресу лежит массив. А указатель это именно адрес, который где-то лежит
0
Я говорю то что указатели и массивы — это разные вещи
Смотря где. В С — одно и то же. В семантике языка. В скомпилированном коде может быть иначе, но там уже не С, а машинный код х86. Ну или иного процессора.
0
Ну так я пример привел, где и в семантике разные:
sizeof(array) != sizeof(ptr)
0
Хммм. Да, действительно. Но, пожалуй, за исключением этого момента (и объявления — объявление массива с заданным размером выделяет место под данные, а не под ссылку на них) имя массива и указатель ведут себя одинаково.
Да и если размер массива неизвестен в момент компиляции — размер возвращает такой же, как для указателя.
0
Во время компиляции размер известен, вот это вызовет ошибку:
int arr[];
Вот тут размер вычислится по длине строки:
char str[] = «qwerty»;
Свобода возможна только в функции, рассчитывая таки на передачу указателя, и то только в первом индексе:
void func(int arr[][10]20[30])
У меня, кстати, реализовано так же (почти). У меня функция может возвращать массив, это нужно в основном для работы со строками.
0
Это С++ и b это ссылка на 'a' а не указатель на 'a'.
Называется ссылкой, а физически адрес памяти, или указатель. Например, 2 функции будут иметь абсолютно одинаковый ассемблерный код:
void func(int &a);
void func(int *a);
Это не C, это C++. В С ссылок нет, по крайней мере в тех версиях, с которыми я знаком
Можно было бы мне догадаться… У Страуструпа логика как у Медведева: только один переименовывает структуры в классы, другой милицию в полицию. Причем у обоих уверенность в величии этого поступка
0
Например, 2 функции будут иметь абсолютно одинаковый ассемблерный код
Но чтобы вызвать первую — требуется написать на один оператор меньше. Хотя и не уверен, насколько существенно это влияет на семантическую сложность в данном случае, но вообще, порой разобраться в хитросплетениях звездочек бывает сложно.
0
Называется ссылкой, а физически адрес памяти, или указатель.

Ну, если так рассуждать, то все переменные — это просто место в памяти, просто разные ЯП интерпретируют это по своему…

 Например, 2 функции будут иметь абсолютно одинаковый ассемблерный код:

void func(int &a);
void func(int *a);


В первом случае — мы получаем ссылку, там будет неявное взятие адреса и т. д. Во втором — мы получаем копию (через неявный вызов конструктора копирования и т. д. Если мы говорим о с++).

Может быть я ошибаюсь (давно я с С++ не пересекался)…
0
И в том и другом случае функция получает адрес, никакого копирования не происходит. Т.е. грубо говоря, при вызове выполняется примерно такой код:
lea eax,<какая-то переменная>
push eax
В 64 битном коде стек не двигается, сразу выделяется нужный объем, потом пляшется допустим от rsp, и первые 4 операнда в регистрах. Т.е. код немного другой.
Никакого копирования не производится в обоих случаях. Если писать функцию на асме, то она будет одинаковой для этих обоих сишных определений.
0
Да ладно :)

void func(int &a);
void func(int *a);
void func(int *a); — подозреваю Вы имели ввиду void func(int a) (иначе это просто разные функции)

Мой компилятор на код


class foo {
public:

	void dummy(void) {
		printf("Test\n");
	}

	foo(void) {
		printf("DefaultConstructor\n");
	};

	foo(const foo & dummy) {
		printf("Copy Constructor\n");

	};
};

void bar1(foo &bar) {
	bar.dummy();
}

void bar2(foo bar) {
	bar.dummy();
}

int main()
{
	printf("Create f\n");
	foo f;

	printf("Call by ref\n");
	bar1(f);
	printf("Call by copy\n");
	bar2(f);


	return 0;
}


говорит следкющее
Create f
DefaultConstructor
Call by ref
Test
Call by copy
Copy Constructor
Test
0
Не-не, ты не прав. Речь именно о void func(int *a). Так что правильный код будет:
class foo {
public:

        void dummy(void) {
                printf("Test\n");
        }

        foo(void) {
                printf("DefaultConstructor\n");
        };

        foo(const foo & dummy) {
                printf("Copy Constructor\n");

        };
};

void bar1(foo &bar) {
        bar.dummy();
}

void bar2(foo *bar) {
        bar->dummy();
}

int main()
{
        printf("Create f\n");
        foo f;

        printf("Call by ref\n");
        bar1(f);
        printf("Call by ptr\n");
        bar2(&f);


        return 0;
}
0
Зачем так сложно, методы… К тому же структура пустая, в студийном компиляторе 32 бита sizeof(foo) == 4 байтам, т.е. это указатель на структуру с указателем на массив адресов методов, больше ничего, это можно и через стек передать. Кстати, по крайней мере студийный компилятор старается даже довольно большие структуры совать в стек… Не знаю как должно быть по стандарту языка.
0
Зачем так сложно, методы… К тому же структура пустая, в студийном компиляторе 32 бита sizeof(foo) == 4 байтам, т.е. это указатель на структуру

Важно то, что bar2() получит копию объекта через неявный возов конструктора копирования.
0
Может быть я ошибаюсь (давно я с С++ не пересекался)…
Во втором варианте указатель же передается, а ты описываешь вариант void func(int a).
0
Во втором варианте указатель же передается

Эм, ну ок, я по этому и написал, «подозреваю Вы имели ввиду void func(int a) (иначе это просто разные функции)”

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

Но это все лирика, однозначно коллега AlexeyG проделал колоссальностью работу, написав интерпретатор языка.

А мы тут скатились в обсуждение С++ :)
0
А ссылка разве не может быть неинициализирована?
проделал колоссальностью работу, написав интерпретатор языка.
Осталось понять, с какой стороны к сыркам подступиться)
0
А ссылка разве не может быть неинициализирована?
В С++ — нельзя создать ссылку без инициализации.
Нельзя просто написать

int &b;
0
Каталог Portable — это попытка не зависеть от Винды. Хоть там проект Студии, эти исходники хорошо компилятся и gcc.
Чет у меня оно хоть и компилится, но не работает. Точнее, жрет проц и ничего не выводит.
0
А мной скомпиленный екзешник работает надеюсь? Надо разбираться, где именно проц жрется? Компилила студия или gcc?
0
А мной скомпиленный екзешник работает надеюсь?
Не запускал.
Надо разбираться, где именно проц жрется?
Дебажить мне на данный момент лень. Позже посмотрю, быть может.
Компилила студия или gcc?
Code::Blocks + TDM-GCC 5.1.0.
Стоит также заметить, что компилилась химерка, содержащая Main1.cpp и SysDependFuncs.cpp (а не SysDependFuncs1.cpp — она отказалась компилироваться, не найдя чего-то в системных хедерах). Также вместо .asm файлов (gas отказался их ассемблировать) я использовал дефайновый вариант из ExtRoutines.h.
0
SysDependFuncs.cpp (а не SysDependFuncs1.cpp — она отказалась компилироваться, не найдя чего-то в системных хедерах).
Ну тогда все объяснимо наверное, у меня тоже так не работает, щас попробовал. Вообще там функция майн разная, пом винду например я текущий каталог узнаю, чтоб как в cmd.exe распечатать, а как это кросплатформенно сделать. Ассемблерные функции (если компилить под 32) под Масм (ml.exe, в комплекте со студией)
0
А какие файлы компилились — линковались? Я использовал mingw, вроде как gcc под Винду. Батник такой:
gcc -x c++ -Wwrite-strings -Wno-multichar Portable\Main1.cpp Portable\SysDependFuncs1.cpp Script\Allocator.cpp Script\Base.cpp Script\Errors.cpp Script\Expression.cpp Script\ExternalFuncs.cpp Script\Lists.cpp Script\NumStringCvt.cpp Script\Operators.cpp Script\TextFuncs.cpp Script\Variable.cpp

Каких хедеров не хватает? Может какой-нить dirext? Это нужно для чтения каталогов
pause
0
SysDependFuncs1.cppЖ291 pfi->Attributes = pendlist->ent.d_type == DT_DIR ? 16 : 0;

Отсутствует поле d_type.
Последнее из-за того, что консольный вывод в SysDependFuncs.cpp осуществляется через виндовский хендл, который надо бы получить в функции майн, чего разумеется в Main1.cpp не делается
Да, логично. Собрал нормальный вариант — из Main.cpp и SysDependFuncs.cpp, на первый взгляд работает. Выхлоп test.agc:
>agbatch test.agc
char[]
char
9
0
123456789
4
435
123---32
int
123ewq123ewq
Comp files:
12345678 : 0
1234567@ : 8
123456@@ : 7
12345@@@ : 6
1234@@@@ : 5
123@@@@@ : 4
12@@@@@@ : 3
1@@@@@@@ : 2
R=h=p=S=28.2743338823081
 V=56.5486677646162
 m=282.743338823081
0
0->>3
0->>2
0->>1
1->3
1->2
1->1
0->>3
0->>2
0->>1
1->3
1->2
1->1
0->>3
0->>2
0->>1
1->3
1->2
1->1
Строка для присваивания
 , 11 , 12
 , 21 , 22
 , 911 , 912
 , 921 , 922
 , 931 , 932
Jan | Feb | Mar | Apr | May | Jun | Jul | Aug | Sep | Oct | Nov | Dec |
func *v
func *v[]
func v
func *v[]
123
123.0
string rettxt()
poi
poi
zxcv vcxz
12345654321
12345654321zxcv vcxz123456543211234565432112345654321
Это типа строка
Это типа строка12345654321
акортс апит отЭ
zxcv vcxz12345654321
Errors N = 17
err data 0(1) : Error #25: Symbol 'x' redefinition
err data 1(1) : Error #25: Symbol 'xx' redefinition
err data 2(1) : Error #25: Symbol 'yy' redefinition
err data 3(1) : Error #13: Unknown type 'ytr'
err data 4(1) : Error #24: Nested instance 'o'
err data 5(1) : Error #15: Illegal symbol '@'
err data 6(1) : Error #1: Invalid expression
err data 8(1) : Error #40: Type of 'NULL' is not exactly known
err data 9(1) : Error #26: Undefined symbol 'BuildFileList'
err data 10(1) : Error #40: Type of 'kk' is not exactly known
err data 11(1) : Error #38: Volatile dimension of 'kk'
err data 12(1) : Error #23: Incorrect size of array
err data 13(1) : Error #29: Wrong return type
err data 14(1) : Error #38: Volatile dimension of 'fff'
err data 15(1) : Error #40: Type of 'dd' is not exactly known
err data 16(1) : Error #32: Too large object 'hjk'
9870987 9870987
0 qwert
1 sfdxjtxj
2 kkjknbbyvytcvyvcou
3 gjjhghjhj
4 ,mmmnnvghv
0 qwert
0 qwert
1 sfdxjtxj
1 sfdxjtxj
2 kkjknbbyvytcvyvcou
2 kkjknbbyvytcvyvcou
3 gjjhghjhj
3 gjjhghjhj
4 ,mmmnnvghv
4 ,mmmnnvghv
123-456
start - asdfghjkl;'zxcvbm,.
asdfghjkl;'zxcvbm,.
sdfghjkl;'zxcvbm,.
dfghjkl;'zxcvbm,.
fghjkl;'zxcvbm,.
ghjkl;'zxcvbm,.
hjkl;'zxcvbm,.
jkl;'zxcvbm,.
kl;'zxcvbm,.
l;'zxcvbm,.
;'zxcvbm,.
'zxcvbm,.
zxcvbm,.
xcvbm,.
cvbm,.
vbm,.
bm,.
m,.
,.
.
asdfghjkl;'zxcvbm,.
sdfghjkl;'zxcvbm,.
dfghjkl;'zxcvbm,.
fghjkl;'zxcvbm,.
ghjkl;'zxcvbm,.
hjkl;'zxcvbm,.
jkl;'zxcvbm,.
kl;'zxcvbm,.
l;'zxcvbm,.
;'zxcvbm,.
'zxcvbm,.
zxcvbm,.
xcvbm,.
cvbm,.
vbm,.
bm,.
m,.
,.
.
7
6
 A-0Ы0-A
-9223372036854775808
9223372036854775807
-9223372036854775807
00000
32
0
1239567800
0:02:03.956
1238567800
0:02:03.856
1237567800
0:02:03.756
1236567800
0:02:03.656
1235567800
0:02:03.556

Memory: 623804
00123
01230
12300
123000
1230000
mnbv
11
22.0
22.0
mnbv
312
wFormatTag 0
nChannels 0
nSamplesPerSec 0
nAvgBytesPerSec 0
nBlockAlign 0
wBitsPerSample 0
init.agc(402) : Error #39: Pointer not initialized
0
Отлично:) Только весь этот набор циферок вряд ли кроме меня о чем-то скажет. Лучше в консоли набрать что-то типа
cout << 2*2
А потом посмотреть на реализацию << в init.agc
0
Ты можешь взять этот набор цифирек и сравнить с образовым. Хотя по хорошему — тест надо писать более понятно и анализируемо.
0
Нормально работает, я вообще рассчитывал на работу с файлами, у меня специальный каталог для этого, его не меняю. Этот тест к нему обращается. Вылетел после того, как пытался записать данные по нулевому указателю, а указатель нулевой т.к. не считался файл, т.к. его нету
0
Тест лучше все же переписать так, чтобы он не зависел от подобных вещей. И еще — чтобы не требовалось выискивать по всему диску, куда оно насрало файликами вида «123».
Впрочем, это если публиковать сабж. Также для публикации желательно документацию. По видимому, язык у тебя отнюдь не С и не С++, а довольно аццкая их помесь.
0
Ну за мусор прошу прощения:) Вообще я же не хотел сразу исходники давать, из-за подобного. А язык очень сиподобный, можно большие куски кода просто копи-пастить и все работает. Единственное, не стал делать некоторые сишные нелогичности, ну или просто мне не нравящиеся моменты (тут уже вопрос вкуса и цвета)
У тебя значит собралось в полноценном варианте (ну с crt может разве что). Можешь набрать что-нить типа
Subdir(«c:\\program files»)
или для каталога поменьше (иначе будет долго тарахтеть винтом)
Duplicates("… ")
0
Проц вроде не грузится, но не печатает. Последнее из-за того, что консольный вывод в SysDependFuncs.cpp осуществляется через виндовский хендл, который надо бы получить в функции майн, чего разумеется в Main1.cpp не делается
0
Проц оно жрало, когда я запустил «agbatch test.agc». И не только проц жрало, но и память весьма энергично текла.
0
Тут могу только предполагать. У меня все принятое с консоли запоминается (мало ли, может там что-то определилось). Если чтение проскакивает, скажем по какой-то ошибке, то все равно сохранится небольшая структурка, описывающая эту пусть и пустую но строку, добавится в список…
0
Мне очень приятно, что возник интерес к велосипеду. Еще раз прошу прощения за мусор, ну не подумал, что моим тестовым файлом и будут тестить. Сам движок я с тех пор почти не менял (только по мелочам), но класть боюсь (как и раньше боялся). Хочу предложить краткий док по этой фигне. Хоть и лень было писать, но понимаю, что надо.
cloud.mail.ru/public/HBwP/U1dAZutWS
0
Только зарегистрированные и авторизованные пользователи могут оставлять комментарии.