32-битный компилятор Делавар
Содержание
Здравствуйте, уважаемый посетитель!
Предлагаю вашему вниманию дальнейшее развитие компилятора Делавар. Одной из особенностей данного компилятора является то, что можно писать программы на разных языках. Имеется в виду возможность использования национальных ключевых слов и имен переменных. Программы на данный момент можно писать на русском и английском языках, алфавит которых закодирован в ASCII или совместимых с ней 8-битных кодировках.
Предыдущая 16-битная версия транслятора создавала на выходе файл на языке ассемблер для плоского 16-битного кода архитектуры i8086. Который в свою очередь подавался на вход ассемблера для генерации бинарного файла с расширением com, исполняемого под операционной средой DOS или Windows.
Данная версия транслятора создает код для ассемблера NASM. Очевидное его преимущество заключается в том, что этот ассемблер позволяет создавать объектные и исполняемые файлы гораздо большего числа форматов. Кроме того, сам транслятор может быть скомпилирован под любой ОС, поддерживающей библиотеку С. Параметры компилятора Делавар позволяют задать возможность выходного формата для 32-битных ОС Windows и Linux.
Прежде чем познакомиться с 32-битной версией компилятора, посмотрите описание, касающееся синтаксиса языка Делавар для 16-битной версии.
Параметры командной строки
Для задания выходного формата используется ключ -f. По-прежнему поддерживается формат COM, использующийся по умолчанию. Для него этот ключ можно не указывать. Данный ключ со значением 'pe' задает выходной PE-формат для платформы Win32, значения 'elf' и 'aout' позволяют задать соответственно 32-битный формат ELF и A.OUT для платформы Linux. Командная строка для компилятора описывается следующим образом:
dc32 [-f fmt] filename.d [-o outfilename.asm], где fmt - значения выходных форматов (pe, elf, aout), filename.d - файл исходного кода на языке Delavar, outfilename.asm - необязательное имя выходного файла. Если outfilename.asm не задан, используется filename.asm
Для создания объектного или исполняемого кода используется ассемблер NASM с аналогичными ключами:
nasm [-f fmt] filename.asm [-o outfilename], где fmt - значения выходных форматов (win32, elf, aout), filename.asm - файл исходного кода на языке ассемблер, outfilename - имя выходного файла.
Если выходной формат не COM, то для сборки исполняемого файла можно использовать любой подходящий компоновщик. В составе компилятора используется компоновщик ld.
Нововведения в языке. Типы
Встроенные (базовые) типы данных остались прежними: bool, int, char, byte, word и string, также появились новые.
У типа string появился конструктор, который принимает целое число (константу) в байтах в качестве параметра для выделения буфера памяти под строку. Пример: string str = string(128). Кроме того, стало возможным обращаться к символу в строке посредством индекса, например: char ch = str[0]. В строковых литералах возможен ввод символов с использованием знака косой черты. Например: "abc\n", где \n - означает перевод строки. Возможен ввод следующих символов: \t - горизонтальная табуляция, \r - возврат каретки, \a - звонок, \" - двойная кавычка, \\ - косая черта. Также можно вставить символ в шестнадцатиричном формате. Пример:
string s = "insert tab\x9line\x0A;feed".
Добавлен пустой тип void. Появились вещественные типы float и double. Однако, есть некоторые ограничения. Например, вещественную константу можно присвоить переменной (или передать в качестве параметра функции) только типа float.
Теперь, приравнять тип с большей размерностью к типу с меньшей размерностью просто так нельзя. Необходимо использовать явное приведение. Например: int a = 5 byte b = (byte) a. Неявное приведение вещественных типов к целым типам также запрещено. Типы bool, char и byte по-прежнему имеют размерность 8 бит, int, word и float - 32 бита, double - 64 бита. Длина идентификаторов в языке увеличена до 128 символов.
Нововведения в языке также связаны с желанием отказаться от использования в языке явных указателей. В связи с этим введено понятие значимых и ссылочных типов. К значимым типам относятся все базовые типы, а также типы, объявленные с помощью ключевого слова type. Память под объекты значимых типов выделяется сразу после объявления. При объявлении ссылочных типов, создается ссылка на объект. Объект ссылочного типа создается при вызове конструктора объекта.
Если встроенные типы являются значимыми, то массивы базовых типов можно объявить и как значимые, и как ссылочные. Введение значимых массивов связано с тем, что пока не реализован механизм передачи многомерных ссылочных массивов в качестве параметра функции (метода). Поэтому, при необходимости передачи многомерного массива в функцию, используйте массивы значимого типа.
Объявление ссылочного массива выглядит следующим образом:
<class_name>[[,]...] varname [ = <class_name>[v1[, v2]...] ].
Так, например, для объявления одномерного массива целых чисел ссылочного типа потребуется следующий код:
int[] arr - будет создана ссылка на одномерный массив целых чисел;
int[] arr = int[5] - будет также выделена память для хранения пяти элементов массива.
int[,] arr = int[5,6] - объявление двумерного массива целых чисел и выделение памяти для ссылки на массив и 30 элементов массива.
Возможно также выделение памяти под массив с одновременной его инициализацией:
int[] arr = { 0, 1, 2 }
string[] sarr = { "one", "two", "three" }
Объявление двумерного массива целых чисел 2х3 с инициализацией:
int[,] arr = { {0, 1, 2}, {4, 5, 6} }
Обратиться к элементу массива можно, указав индекс в квадратных скобках:
int a = arr[0]
Объявление массива значимого типа имеет несколько иной синтаксис:
<type_name>[v1[, v2]...] varname.
Например:
int[3] arr - объявление одномерного массива целых чисел значимого типа
int[2,3] arr = { {0, 1, 2}, {4, 5, 6} }
- объявление двумерного массива с инициализацией
foo[5] fooName - объявление массива значимого типа, состоящего из пяти элементов, где foo некоторый тип, объявленный с помощью ключевого слова type.
Ссылочные типы объявляются с помощью ключевого слова class. Они описываются аналогично значимым типам:
class Name
{
[Здесь следует перечень полей пользовательских и базовых типов]
[конструктор(ы)]
[метод(ы)]
[деструктор]
}
Пример:
class dot
{
int x, y
dot()
{
x = 0
y = 0
}
dot(int x, int y)
{
this.x = x
this.y = y
}
void SetX(int x)
{
this.x = x
}
}
Так как компилятор на текущий момент является однопроходным, методы составного типа должны быть определены до их вызова (это же касается и глобальных функций, для которых, однако, возможна предварительная декларация). На данный момент, все поля и методы пользовательских (составных) типов являются открытыми (public). Для обращения к полям внутри класса можно использовать ключевое слово this (но не обязательно), которое является ссылкой на экземпляр класса.
Объявить переменную ссылочного типа можно следующим образом:
dot d, при этом выделяется память для хранения ссылки.
dot c = dot() - с помощью вызова конструктора класса осуществляется создание экземпляра класса, на который сылается переменная с. Память под такой объект выделяется в стеке. Поэтому нужно учесть, что при завершении работы функции или метода, где вызывается конструктор ссылочного типа, уничтожается и сам объект. В версии 0.61 компилятора Делавар появилась возможность использовать оператор new, позволяющий создать экземпляр класса в динамической памяти. В этом случае, освободить выделенную память необходимо с помощью оператора delete.
Массив ссылок (не сами объекты) на структуры типа dot объявляется аналогично ссылочным массивам базовых типов:
dot[] darr = dot[5]
Для создания элемента массива класса dot используйте вызов конструктора:
darr[0] = dot()
Теперь можно обращаться к полям и методам экземпляра класса.
Вместо ключевого слова class можно использовать конструкцию pointer type.
Введен новый базовый тип object. Предполагается, что любой пользовательский тип, определяемый с помощью ключевого слова class, наследуется от данного типа. Это удобно при использовании приведений типов. Т.е., любой ссылочный тип может быть присвоен (или приведен к) типу object:
object o = c, где с - экземпляр типа dot.
Ссылке на объект или массив, а также типу object можно присвоить фиксированный адрес, используя явные приведения:
object o = (object)(word) expr, где expr - выражение, приводимое к беззнаковому целому.
Например, ссылку на объект можно инициализировать следующим образом: dot d = (object)(word) 0. Следует отметить, что константы целого типа, большие -128 и меньшие 256 имеют размерность байта. В версии компилятора 0.56 появилась предопределенная константа типа object по имени NULL. Она предназначена для инициализации ссылочных переменных, а также для сравнения таких переменных со специальным нулевым значением. Поэтому вышеуказанную инициализацию правильнее сделать так: dot d = (dot) NULL.
Аналогичная инициализация ссылки на массив может выглядеть следующим образом: dot[] dArr = (dot[]) NULL.
В данной версии компилятора отсутствует инициализация составных типов (наподобие dot d = {1, 0}). Для этого используйте конструкторы. Для значимых составных типов в версии 0.59 реализован вызов конструктора по умолчанию (без параметров) в момент объявления переменной.
Появилась возможность задавать перечень констант с помощью ключевого слова enum. Для определения перечня используется следующий синтаксис:
enum Name
{
Value1[=Number],
...,
ValueN[=Number]
}, где Number - беззнаковое целое число
Если конкретные значения элементам перечисления не заданы, то значения им присваиваются автоматически, начиная с нуля, с инкрементом 1.
Пример:
enum Color
{
Red,
Green = 5,
Blue
}
Использование:
Color clr = Color.Red
Размерность такой константы составляет машинное слово. Перечисление возможно преобразовать к целому типу путем явного приведения:
int b = (int) clr
В языке также появилось ключевое слово delegate, которое позволяет объявить новый тип переменной - ссылку на функцию. На данный момент имеется ограничение: кандидатом в делегаты может быть только глобальная функция. Объявляется делегат следующим образом:
delegate <decl_function>, где decl_function - прототип функции.
Пример использования:
int printf(string, ...)
delegate int MyProc(int a, int b);
int Summa(int a, int b)
{
return a + b
}
void Start()
{
MyProc Proc = MyProc(Summa);
printf("%d\n", Proc(5, 5));
}
В функции Start создается переменная Proc типа делегат MyProc, далее вызывается конструктор делегата, который принимает в качестве параметра для инициализации переменной Proc подходящую функцию Summa. Естественно, что сигнатура функции должна совпадать с сигнатурой прототипа, объявленного в делегате..
Из ограничений для типов перечисление и делегат нужно отметить отсутствие реализации массивов данных типов.
Нововведения в языке. Наследование
В версии компилятора 0.59 введена возможность простого наследования классов и типов, т.е. один класс (тип) может иметь один класс(тип)-предок. На данный момент, реализовано это следующим образом: ссылочный тип может унаследовать только ссылочный тип, а значимый тип - только значимый тип.
Для указания класса-предка необходимо после имени производного класса ввести через двоеточие имя базового класса. В качестве примера построим небольшую иерархию классов:
class Figure
{
string name;
Figure ()
{
name = "Figure";
}
virtual void ToString ()
{
printf ( "my name is '%s'\n", name );
}
virtual ~Figure ()
{
printf ( "call destructor '%s'\n", name );
}
}
class Dot : Figure
{
int x, y;
Dot ()
{
name = "Dot";
x = 0;
y = 0;
}
}
Здесь класс Dot наследует класс Figure и все его свойства, таким образом из производного класса можно обращаться к поля и методам наследуемого класса. Если в производном классе объявляется поле или метод с одноименным именем в базовом классе, то такое поле или метод базового класса будут перекрыты. В этом случае, компилятор будет использовать одноименные поля и методы производного класса. Для обращения к перекрытым полям и методам базового класса используется ключевое слово base. Рассмотрим следующий пример:
class employee
{
string etype;
string name;
employee ()
{
etype = "employee";
name = (string) NULL;
}
void ToString ()
{
printf ( "I'm %s %s\n", etype, name );
}
}
class manager : employee
{
int bonus;
manager ()
{
employee ();
etype = "manager";
bonus = 0;
}
void ToString ()
{
base.ToString ();
printf ( "My bonus: %d\n", bonus );
}
}
Здесь метод ToString () базового класса Employee перекрыт одноименным методом из производного класса Manager. Метод ToString () производного класса использует функционал перекрытого метода базового класса, обращаясь к нему с помощью ключевого слова base.
В версии 0.62 компилятора Делавар появилась возможность использовать виртуальные методы в пользовательских типах. Для объявления виртуального метода предназначено ключевое слово virtual, указанное в начале определения метода, как это сделано для метода ToString класса Figure. Объявить виртуальным можно также деструктор (см. класс Figure). Также стало возможным приведение производного класса к базовому классу. Доработан вызов конструктора и деструктора по умолчанию при создании и соответственно удалении экземпляра пользовательского типа: вызываются конструкторы и деструкторы всех базовых классов, если имеются.
Примеры программ с использованием наследования находятся в каталоге DC32\EX\INHERIT.
Нововведения в языке. Инструкции и операции
В языке имеются следующие управляющих конструкции:
if(cond) { statements } [else { statements }],
for(init_expr; cond_expr; step_expr) { statements },
while(cond) { statements },
do { statements } while(cond)
switch(int_expr) { case n1: statements ... default: statements }
По сравнению с 16-битной версией компилятора добавлена инструкция do..while и switch. Также в теле цикла можно использовать операторы break и continue.
Есть отличие в задании условия cond: результирующим значением выражения условия должно быть обязательно булево выражение. Например:
int a = 3
if(a != 0)
b = 5
В инструкции switch выражение int_expr может быть следующих типов: char, byte, word, int или enum.
Для числовых типов добавлены битовые операции (&, |, ^, ~, &=, |=, ^=), операции сдвига (<<, >>, <<=, >>=).
Появилась инструкция sizeof(type), которая возвращает размер типа в байтах. В качестве параметра принимает имя типа. Пример: word sizeInt = sizeof(int).
Начиная с версии 0.52 компилятора, появилось ключевое слово extern, которое позволяет объявить глобальную переменную, определенную во внешнем модуле (библиотеке). Используется следующий синтаксис: extern type_name name, где type_name - имя типа, name - имя переменной. Например, extern int foo.
В версии 0.58 компилятора Делавар появилось ключевое слово synonym, которое можно использовать в двух случаях:
- для создания синонима типа (другого имени типа),
- для создания ссылки на переменную (другого имени переменной).
Для объявления синонима типа используется следующий синтаксис: synonym new_type_name type_name. Например, synonym UINT word. Возможно объявление синонимов как базовых, так и пользовательских типов. Объявления синонимов типа возможны только в глобальной области видимости модуля. После объявления синонима типа, возможно использование нового имени типа для объяления переменных.
Для объявления ссылки на переменную используется аналогичный синтаксис: synonym new_var_name var_name. Например, synonym b a, где а - имя переменной. После объявления синонима имени переменной возможно обращение к ней по имени b. Объявление ссылки на переменную возможно в области видимости исходной переменной, или во вложенных областях видимости относительно этой переменной.
В версии 0.61 компилятора Делавар появилась возможность использования глобальных операторов new и delete для создания и удаления ссылочных типов и их массивов в динамической памяти. При создании составного ссылочного типа с помощью оператора new вызывается конструктор объекта с заданными параметрами (если они указаны). Перед удалением такого объекта с помощью оператора delete - происходит вызов деструктора (если он имеется). Примеры использования операторов new и delete имеются в папке C:\DC32\EX\INHERIT. Для значимых составных типов и их массивов реализован вызов конструктора по умолчанию (без параметров) в момент объявления переменной, также вызов деструктора при их уничтожении (выходе из области видимости).
Нововведения в языке. Функции
Ключевое слово function больше не используется для объявления функции. Исчезло также ключевое слово declaraton. Для декларации функции используется следующий синтаксис:
ret_type [modif] function_name([param_list])
Например:
string __stdcall GetName(int id)
По умолчанию используется конвенция вызова функции, принятая для языка Си: __cdecl. Возможно использование модификатора __stdcall, принятого для вызова функций Win32 API. Параметры функции разделяются запятыми.
Возвращаемые значения и параметры функции на данный момент не могут быть многомерными массивами ссылочного типа (не реализовано); возвращаемые значения функции не могут быть также значимыми составныи типами или массивами. Параметры базовых типов передаются по значению, пользовательские типы и массивы - по ссылке. Возможна передача параметров базового типа по ссылке при использовании ключевого слова ref. Передать параметр с использованием этого ключевого слова возможно также и для ссылочных типов.
Если задан прототип функции, и отсутствует тело функции в файле исходного кода, то такая функция считается определенной во внешней библиотеке (модуле). Например:
// Функция printf определена во внешней библиотеке
int printf(string, ...)
int Sum(int a, int b)
{
return a + b
}
void Start()
{
printf("%d", Sum(1, 2))
}
Троеточие в параметрах прототипа функции printf, как и положено означает, наличие переменного числа параметров, первый из которых, в данном случае, обязателен. Однако, в языке возможность определения функций с переменным числом параметров не реализована.
Также стало возможным использование полиморфных функций и методов:
void foo(string text, bool f)
{
}
void foo(string text)
{
foo(text, true)
}
У функции Start (точка входа в программу) появилась возможность получать параметры командной строки (за исключением формата COM). Синтаксис стандартен:
void Start(int argc, string[] argv)
{
}
Многомодульные проекты
В версии компилятора 0.54 появились ключевые слова import и module. Указываются инструкции в начале модуля. Сначала должны следовать инструкции import, затем module.
Ключевое слово import предназначено для импорта описаний перечислений, глобальных переменных и прототипов функций, определенных в сторонних библиотеках. Для глобальных переменных не забывайте использовать ключевое слово extern. Данные описания должны находиться в файлах с расширением *.i и располагаться с каталоге DC32\IMP. На данный момент в указанном каталоге уже имеются описания для стандартной библиотеки С (файл std.i), GTK (gtk.i), SDL (sdl.i), Open GL (gl.i), математических функций (math.i) и некоторых других, достаточные для компиляции имеющихся примеров. Недостающие описания можно добавить в имеющиеся или создать собственные файлы импорта. Пример использования: import std, gtk, sdl. После ключевого слова import следует список импортируемых файлов описаний, разделенных запятой, без расширения.
Ключевое слово module используется для подключения информации об описаниях пользовательских типов, глобальных функций, перечислений или переменных, размещенных в других файлах исходного кода проекта (файлы с расширением *.d). Таким образом, появляется возможность многомодульной разработки программ. Предполагается, что файлы исходного кода будут находиться в каталоге проекта. Также как и для инструкции import, перечень подключаемых файлов указывается через запятую, без расширений. Например: module src1, src2, src3. Если указанный модуль не будет найден в каталоге проекта, его поиск также будет произведен в каталоге DC32\OBJ. Каталог DC32\OBJ предназначен для хранения используемого в разных проектах одного и того же исходного кода (библиотеки), и соответствующих ему откомпилированных объектных файлов. Описание библиотеки подключается с помощью инструкции module, а соответствующий объектный файл указывается компоновщику при сборке проекта. Пример такой собственной объектной библиотеки имеется в каталоге DC32\OBJ и называется ienum.
В версии компилятора 0.57 появилась возможность инициализации в месте объявления глобальных переменных, определенных в модулях проекта, отличных от главного (в котором определена функция Start). Простые примеры многомодульных проектов хранятся в папке DC32\EX\MODULES. Более сложный пример находится в папке DC32\EX\GTK\IDE.
Создание DLL
Общая информация. В опциях компилятора используйте ключ -m для отмены декорирования имен функций при компиляции библиотеки. На данный момент имеется ограничение: начальная инициализация глобальных переменных, определенных в модулях исходного кода, составляющих DLL, не реализована.
Для ОС Windows. В версии компилятора 0.54 появилась возможность создания динамически загружаемых библиотек (DLL). В качестве точки входа используйте функцию WinAPI DllMain. В опциях компоновщика ld для этого пользуйтесь ключом -e. Для инициализации библиотеки используйте какую-нибудь функцию в момент наступления события DLL_PROCESS_ATTACH, например.
С помощью файла экспорта (с расширением *.def) определите экспортируемые функции. Формат этого файла довольно прост: LIBRARY "имя_библиотеки_с_расширением" EXPORT список_имен_экспортируемых_функций. Имя каждой функции должно начинаться с новой строки. Также можно указать адрес размещения библиотеки BASE=0xDDDDDDDD, где 0xDDDDDDDD - шестнадцатиричный адрес. Пример создания DLL имеется в папке C:\DC32\EX\MODULES\OOPDLL и C:\DC32\EX\GTK\TVIEWDLL\DLL, а также в C:\DC32\EX\WIN32\DLLTEST. Там же хранятся примеры динамической компоновки библиотеки.
Для ОС Linux. Возможность создания DLL появилась в версии компилятора 0.58. При необходимости, для инициализации библиотеки используйте предопределенную функцию _finit(), при завершении работы библиотеки - функцию _fini(). Пример создания DLL имеется в папке /DC32/EX/MODULES/TESTDLL и /DC32/EX/MODULES/TESTDYNDLL. Ограничение: на данный момент не реализован экспорт глобальных переменных в разделяемой библиотеке.
Компиляция примеров
Для компиляции и запуска программ, написанных на языке Делавар, используются несложные пакетные файлы.
Компиляция в среде Windows. Сам компилятор и исходные тесты примеров на языке Делавар находятся в файле DC32.zip. Скачайте архив и распакуйте его содержимое. Все пути в пакетных файлах начинаются с C:\DC32. Именно поэтому желательно распаковать все на диск С:. Иначе вам придется менять пути во всех файлах, где они используются.
Для сборки примеров с поддержкой библиотеки GTK используется вариант этой библиотеки для Win32, расположенной в папке C:\DC32\GTK. Для подключения библиотеки добавьте путь C:\DC32\GTK\BIN к переменной окружения PATH или скопируйте содержимое этой папки в системную папку \WINDOWS\SYSTEM32. Тоже самое сделайте для библиотек PDCURSES, SDL, SQLITE и GLUT. Соответствующие файлы библиотек находятся в папках C:\DC32\PDCURSES\BIN, C:\DC32\SDL\BIN, C:\DC32\SQLITE\BIN и C:\DC32\FREEGLUT\BIN. Библиотеки Open GL имеются в составе ОС Windows, но на всякий случай в папке C:\DC32\FREEGLUT\BIN имеются их копии.
Для включения локализации GTK-приложений используйте первый вариант ( добавьте пути к переменной PATH ).
Пользователям Windows XP SP2 и ниже необходимо установить пакет Microsoft Visual C++ 2008 Redistributable Package (x86) для нормальной работы компилятора.
Компиляция в среде Ubuntu. Компилятор с примерами поставляется в виде deb-пакета и архива tar. На данный момент компилятор собран в 32-разрядной версии ОС Ubuntu 12.04. Работа компилятора проверена также в версии Ubuntu 10.04. Если для установки выбран deb-пакет, то автоматическая установка/удаление осуществляется средствами операционной системы.
Если для установки выбран архив tar - распакуйте архив с компилятором в любую папку. Далее необходимо запустить install.sh для копирования файлов программы в каталог /usr/local. Данный скрипт требует административных прав, поэтому в процессе копирования файлов необходимо будет ввести соответствующий пароль. Перед использованием компилятора убедитесь, что установлены следующие пакеты: nasm, binutils, libc6, libgtk-2.0-dev, libgtksourceview2.0-dev, libxml2-dev, libsdl1.2-dev, libgl1-mesa-dev, libglu1-mesa-dev,
freeglut3-dev, libsqlite3-dev, libncurses5-dev. Для запуска и компиляция примеров перейдите в каталог /usr/local/DC32. Для удаления установленных файлов программы используйте скрипт uninstall.sh.
Общая информация. В каталоге DC32 расположен исполняемый файл компилятора dc32, файлы ресурсов dc32.res, dc32.en.res, dc32.cp866.res, dc32.cp1251.res. Заменяя содержимое файла dc32.res содержимым файлов dc32.*.res с соответствующей кодировкой, можно компилировать программы, написанные с использованием выбранной кодировки.
В папке DC32\EX находятся примеры программ на языке Делавар. В папке EX\COM - примеры, написанные для компиляции в 16-битный COM-формат DOS\Windows-консоли. В папке EX\WIN32 - для 32-разрядной ОС Windows c использованием Win32 API. В папке EX\GTK - для 32-разрядных ОС Windows и Linux c использованием библиотеки GTK. В папке EX\GL имеются примеры с использованием библиотеки Open GL и FreeGlut, а в папке EX\SDL - графической библиотеки SDL. В папке EX\CURSES имеются примеры с использованием библиотеки NCURSES. В Windows-версии используется библиотека PDCURSES. В папке EX\CONS - программы, написанные для Linux\Windows-консоли. В папке EX\RU - программы, написанные с использованием русского синтаксиса.
Для компиляции, сборки и запуска каждого примера перейдите в соответствующий подкаталог папки EX, запустите файл run. Для запуска примера из папки EX\CONS необходимо запустить файл run с параметром. В качестве параметра используйте имя файла исходного кода компилятора Делавар (файл с расширением *.d). Если Вы работаете с FAR, то создайте ассоциацию на файл run для удобного запуска примеров на компиляцию.
Для пакетного запуска примеров программ на языке Делавар используйте файлы run_cons и run_ex, находящиеся в каталоге \DC32.
В папке EX\GTK\IDE содержится пример IDE, которая имеет редактор с подсветкой синтаксиса для языка Делавар (англоязычной и русскоязычной версий) и позволяет создать проект, произвести сборку и запуск примера. Файлы проекта имеют расширение dlv. В некоторых папках примеров они уже созданы. Вам остается их просто открыть, используя меню Project-Open. Для сборки и запуска примера используйте меню Build-Execute или кнопку Execute.
Для компоновки объектных файлов, полученных с помощью ассемблера NASM, используется компоновщик ld. Для ОС Windows данный компоновшик расположен в папке \DC32\MINGW\BIN, его можно найти также в пакете MinGW. Скриншоты некоторых примеров программ, написанных на языке Делавар, можно посмотреть здесь .
Дальнейшее развитие
Естественно, еще многое хотелось бы сделать. В первую очередь, доделать то, что выше объявлено как нереализованное. Из интересных задач - это реализция наследования, сборщик мусора, поддержка юникода, использование пространств имен, перегрузка операторов и т.д. и т.п.
Хотелось бы переписать генератор кода для создания объектного файла с секцией отладочной информации DWARF для отладчика GDB. Интерес также представляет создание генератора кода для выходного формата MS CIL.
Контакты
Ваши предложения или пожелания, а также в случае обнаружения ошибок в работе компилятора, пишите на почту или оставляйте сообщения в гостевой книге.
Загрузить
 | Для Windows |
 | Для 32-битной Ubuntu |
Зеркала
Зеркала сайта имеются по следующим адресам:
- www.dc32.ru
- dc06.narod.ru
- dc32.16mb.com
Как запустить IDE Делавар?
В среде Windows. IDE Делавар использует библиотеку GTK, расположенную в папке C:\DC32\GTK. Для подключения библиотеки добавьте путь C:\DC32\GTK\BIN к переменной окружения PATH или скопируйте содержимое этой папки в системную папку \WINDOWS\SYSTEM32. Далее перейдите в каталог C:\DC32\EX\GTK\IDE. Запустите файл g-dv-ide.exe.
Для включения русского интерфейса используйте первый вариант ( добавьте пути к переменной PATH ).
В среде Ubuntu.После установки deb-пакета, перейдите в каталог /usr/local/DC32/EX/GTK/IDE. Запустите файл g-dv-ide.
Более подробно смотрите раздел Компиляция примеров.
Обмен баннерами
Присылайте на адрес электронной почты предложения об обмене баннерами. Исходный код баннера компилятора Делавар расположен ниже:
