$ReferenceInfo — Директива компилятора Delphi

$ReferenceInfo — Директива компилятора Delphi

От Delphi 4 к Delphi 5
Палитра компонентов.

Компоненты этой страницы (рисунок 1) обеспечивают концепцию многоуровневого доступа к данным, позволяющей существенно снизить требования к аппаратным средствам компьютера-клиента за счет размещения значительной части клиентского программного обеспечения на сервере.

Компонент ClientDataSet предназначен для непосредственного (без BDE ) доступа к данным с клиентского компьютера.

Компонент DComConnection устанавливает связь с удаленным сервером, используя средства технологии DCOM.

Компонент SocketConnection устанавливает связь с удаленным сервером, используя собственные средства Windows (так называемые сокеты).

Компонент DataSetProvider реализует удаленного (на машине сервера) поставщика наборов данных для многоуровневых клиентских приложений. В отличие от компонента Provider, ориентирован на иной, чем BDE, механизм доступа к данным.

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

Компонент WebConnection устанавливает связь с Web-сервером.

Компонент CorbaConnection устанавливает связь с удаленным сервером, используя средства технологии CORBA.

В версию Delphi 5 не включены некоторые устаревшие компоненты версии Delphi 4.

Ошибки времени выполнения.

Существуют ошибки времени выполнения (run-time errors), которые дают о себе знать исключительными ситуациями, останавливающими работу вашего приложения. Если обработка исключительной ситуации стандартная, то выдается сообщение, в котором указывается тип ошибки, а также адрес, по которому она произошла. Среда Delphi имеет средства, помогающие обнаруживать ошибки времени выполнения и устранять их. Ваше приложение в некоторых случаях может приостановиться, не прекратить работу и не зависнуть. После определения ошибки и ее исправления вы можете продолжить его, выбрав команду меню Run/Run, или прервать работу приложения командой меню Run/Program Reset. Если вы выберете команду Run, то обработкой исключительной ситуации займется среда Delphi с выдачей сообщения об ошибке.

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

Контроль ошибок времени выполнения является настраиваемым. Для его настройки необходимо открыть диалоговое окно Project Options на странице Compiler, с помощью раздела Project меню Delphi, далее команда Options.

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

Переключатель Range checking позволяет контролировать индексы массивов и строк, а также переменные интервальных типов, не выходя за границы объявленных пределов. Контроль следует включать только на время отладки.

Переключатель I/O checking позволяет включить контроль ошибок ввода-вывода. Если он включен, то чтобы узнать, была ли ошибка ввода-вывода, необходимо проверить значение переменной IOResult: (IOResult<>0). Этот переключатель следует включать только на время отладки.

Переключатель Overflow checking (Q) позволяет включить контроль переполнения целых чисел при выполнении арифметических операций. Этот переключатель включается только на время отладки.

Чаще всего ошибки времени выполнения являются симптомом логической ошибки. Смысловые или логические ошибки являются самыми трудноуловимыми. В процессе компиляции среда Delphi позволяет обнаруживать синтаксические ошибки, но также и ситуации, которые могут вызвать ошибки времени выполнения или логические ошибки. Она информирует вас об этом с помощью подсказок и предупреждений, которые выдаются на панели сообщений Редактора кода.

Диалоговое окно Project Options на странице Compiler имеет группу Messages с переключателями Show hints и Show warnings (рисунок 2) .

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

Предупреждения ( включена опция Show warning) генерируются компилятором, когда происходит обращение к неинициализированным переменным, обнаруживаются функции с пропущенным результатом, когда конструируются объекты абстрактных классов и в других ситуациях, которые могут привести к ошибкам времени выполнения.

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

Перед разработкой приложения необходимо позаботиться о том, чтобы все средства встроенного отладчика были доступны. На его работу влияют как параметры среды ( Environment Options ), так и параметры проекта (Project Options). Для настройки встроенного отладчика откройте диалоговое окно Environment Options (выбрав команду Environment Options в разделе Tools меню Delphi ) и активизируйте страницу Preferences.

Переключатели из группы Compiling and Running управляют работой отладчика.

Опция Show compiler progress позволяет показывать диалоговое окно процесса компиляции приложения.

Опция Warn on package rebuild позволяет выдавать информацию предупреждения, генерируемую компилятором.

Опция Minimize on run обеспечивает минимизацию Delphi (т.е. свертывание Delphi ) на время работы приложения. Когда приложение закрывается, Delphi восстанавливается.

Опция Hide designers on run позволяет спрятать на время отладки все неиспользуемые на этот период окна (например, окно инспектора объекта и окно формы).

Прежде чем начать использование инструментария отладчика Delphi, вы должны заставить компилятор генерировать специальную информацию, необходимую для его работы. Для конфигурирования отладчика откройте раздел Project и выберите команду Options для входа в диалоговое окно Project Options . Выберите вкладку Compiler . Откроется диалоговое окно со страницей параметров компилятора раздел Debugging (рисунок 3).

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

Опция Debug Information сообщает компилятору о необходимости генерировать информацию для отладчика. Эта информация, сохраняемая в файле с расширением . DCU, в основном состоит из таблицы, сопоставляющей номер строки вашей программы с позицией команды в полученном исполняемом модуле. Всегда оставляйте эту опцию включенной во время разработки программы, чтобы иметь возможность пользоваться отладчиком Delphi.

Опция Local Symbols сообщает компилятору о необходимости создать список переменных, используемых в вашей программе, сохранив его в файле с расширением . DCU . Список содержит имя каждой переменной и ее положение в памяти при выполнении программы. Если его содержимое доступно отладчику, то вы сможете контролировать величины, содержащиеся в переменных, и даже менять их во время работы программы. Всегда оставляйте эту опцию включенной на этапе разработки, поскольку это повышает эффективность работы с отладчиком.

Опция Reference info (Y) представляет собой эквивалент директивы Y, генерирует информацию о ссылках на объявления идентификаторов, где они используются. Эта информация необходима для работы Code browser.

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

Опция Definition only представляет собой вспомогательную опцию, доступную только при включенной опции Reference info (Y) . Она определяет генерацию информации только об определенных ссылках.

Опция Assertions ( C ) представляет собой эквивалент директивы <$C>, она управляет генерацией информации, связанной с процедурой Assert. При включении этой опции код Assert удаляется из файла, но после этого надо повторно откомпилировать модуль.

В Delphi 5 добавилась новая опция Use Debug DCUs, которая разрешает использовать отладочную версию компонентов VCL. Если она включена, среда Delphi использует, вместо пути Search path (устанавливается командой Project Options на странице Directories/Conditionals ), путь Debug DCU (устанавливается командой Tools/Debugger Options на странице General ).


Использование контрольных точек.

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

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

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


Первый способ:
в Редакторе кода произведите щелчок левой кнопкой мыши слева от выбранной строки программного кода на серой полосе области Редактора кода. Среда Delphi покажет маленький знак на сером поле диалогового окна и подсветит строку программы, например, красным цветом (рисунок 4). Это простейший способ, которым вы будете пользоваться чаще всего.


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


Третий способ:
установите курсор на строку, куда вы хотите вставить контрольную точку, и выберите раздел Run меню Delphi, далее команду Add Breakpoint, Source Breakpoint (рисунок 5) .

Используйте диалоговое окно Add Source Breakpoint для добавления контрольной точки в позицию строки в вашем исходном коде.

Опция Filename определяет имя исходного файла для контрольной точки.

Опция Line Number (номер строки) позволяет устанавливать или изменять номер строки для контрольной точки.

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

Таким образом, определяются условные контрольные точки. Некоторые ошибки происходят только в определенных обстоятельствах, создавшихся в вашей программе. Для поиска этих ошибок Delphi предусматривает условные контрольные точки, которые активируются только при выполнении определенных, заданных вами условий. Предположим, что в программе имеется ошибка, которая проявляется только во время рисования эллипса. Поместите контрольную точку на строку программы (допустим, строка текста процедуры TForml.DrawShape ) и войдите в диалоговое меню редактирования контрольных точек. В текстовое окно Condition введите DrawingTool=dtEllipse и нажмите Enter . Запустите программу и нарисуйте четырехугольник — ничего не происходит. Теперь попытайтесь нарисовать эллипс — Delphi переходит в режим отладчика. Теперь вы можете использовать средства отладчика для просмотра переменных или пошагового исполнения программы, как будет описано далее. Для продолжения работы программы просто нажмите клавишу F9.

В текстовое окно Conditions вы можете поместить почти любое выражение, допустимое в Pascal и не содержащее функций. Для активации контрольной точки значение выражения должно быть True или ненулевым.

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

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

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


Четвертый способ:
используя команду меню View, выберите команду Debug Windows, далее Breakpoints. Откроется диалоговое окно Breakpoint List (рисунок 6). Произведите щелчок правой кнопкой мыши по пустому полю диалогового окна Breakpoint List — появится всплывающее меню с командой Add. Далее раскроется список команд, в котором выберите команд у Sourse BreakPoint.

Вы можете размещать контрольные точки только на строках с действительными операторами. Среда Delphi не поставит контрольную точку на комментарий.

Установив контрольные точки, нажмите клавишу F9 или кнопку Run на линейке инструментов. Среда Delphi откомпилирует вашу программу и будет ее выполнять до контрольной точки.

Используя любой из приведенных выше методов в обратном порядке, вы можете удалять контрольные точки. Для удаления сразу всех контрольных точек выберите команду Delete All Breakpoints в оперативном меню окна Breakpoint List .

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

Если вы установили контрольные точки, но они не нужны вам все время, вы можете временно отменить их действие. Это полезно, когда контрольные точки установлены внутри цикла и программа останавливается на каждом его проходе. Для отмены контрольной точки отметьте ее в окне Breakpoint List и выберите Disable Breakpoint в оперативном меню. Контрольная точка остается в списке, но она затенена в окне редактора кода. Для восстановления контрольной точки выберите Enable Breakpoint в оперативном меню. Для отмены или восстановления сразу всех контрольных точек выберите в оперативном меню Enable All или Disable All .

Окно Breakpoint List позволяет вам быстро переходить к тому месту в программе, где расположена контрольная точка. Просто отметьте контрольную точку и выберите View Source в оперативном меню. Среда Delphi помещает курсор в начало строки, содержащей контрольную точку. Если вы хотите, чтобы редактор кода получил фокус и вы могли немедленно приступить к редактированию, выберите в оперативном меню Edit Source.

Счетчик проходов контрольных точек в диалоговом окне Breakpoint List предназначен для ускорения процесса отладки Delphi. Установленные контрольные точки включаются в работу только после числа проходов, которые вы установили.

Если установите значение Pass равным 0, то контрольная точка вызывается каждый раз, когда программа ее встречает.


Компоненты Panel, SpeedButton.

Буксируемая инструментальная линейка.

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

Для создания буксируемой инструментальной линейки в другую область экрана необходимо проделать следующее. В качестве основы для примера будем использовать программу занятия 20 ToolBar (см. КГ № 28 (320) от 31.07.01.) (рисунок 7). Кнопки SpeedButton на лицевой части имеют графическое изображение.

    1. Запустите Delphi.
    2. Сохраните файл модуля под именем Tool_. pas, а файл проекта под именем DragTool.dpr .
    3. Задайте имя для формы, используя свойство Name, введите ToolBarForm.


Поместите на форму компонент Panel, восемь кнопок SpeedButton, компонент Label. К омпоненту Panel, который используется как инструментальная линейка, необходимо установить значение свойства DragMode равным dmAutomatic для поддержания процесса буксировки. Затем добавьте метод для события OnDragOver компонента Label1, присвоив параметру Accept значение True (строка 35 – 39 ). Далее приведен программный код, который требует пояснения. Повторяющиеся значения программного кода для выравнивания текста и т.д. не приводятся, используйте занятие 20.

    1. procedure Label1DragOver(Sender, Source: TObject; X, Y: Integer;
    2. State: TDragState; var Accept: Boolean);
    3. procedure Label1DragDrop(Sender, Source: TObject; X, Y: Integer);
    4. procedure FormCreate(Sender: TObject);
    5. private
    6. public
    7. BarPos: TAlign;
    8. PanelSize: Integer;
    9. BoxOn: Boolean;
    10. function GetBarPos (X, Y: Integer): TAlign;
    11. procedure RotateSpeedbar;
    12. procedure MoveButtons (Win: TWinControl);
    13. end;
    14. var
    15. ToolBarForm: TToolBarForm;
    16. implementation
    17. uses TBoxForm;
  1. const DragSize = 20;
  2. function TToolbarForm.GetBarPos (X, Y: Integer): TAlign;
  3. begin
  4. if X ClientW > ClientHeight — DragSize then
  5. GetBarPos := alBottom
  6. else
  7. GetBarPos := alNone;
  8. end;
  9. procedure TToolbarForm.Label1DragOver(Sender, Source: TObject; X,
  10. Y: Integer; State: TDragState; var Accept: Boolean);
  11. begin
  12. Accept := True;
  13. end;
  14. procedure TToolbarForm.Label1DragDrop(Sender, Source: TObject;
  15. X, Y: Integer);
  16. var
  17. ReqPos: TAlign;
  18. begin
  19. ReqPos := GetBarPos (X + Label1.Left, Y + Label1.Top);
  20. if ReqPos = alNone then
  21. begin
  22. ToolBox.Show;
  23. Panel1.Visible := False;
  24. BoxOn := True;
  25. if BarPos in [alLeft, alRight] then
  26. RotateSpeedbar;
  27. MoveButtons (ToolBox);
  28. end
  29. else
  30. begin
  31. Panel1.Align := ReqPos;
  32. if ( (ReqPos in [alTop, alBottom]) and
  33. (BarPos in [alLeft, alRight]) ) or
  34. ( (ReqPos in [alLeft, alRight]) and
  35. (BarPos in [alTop, alBottom]) ) then
  36. RotateSpeedbar;
  37. BarPos := ReqPos;
  38. end;
  39. end;
  40. procedure TToolbarForm.MoveButtons (Win: TWinControl);
  41. var
  42. I, J: Integer;
  43. begin
  44. for I := 0 to ComponentCount — 1 do
  45. if Components [I] is TSpeedButton then
  46. TSpeedButton (Components [I]).Parent := Win;
  47. if Win = ToolBox then
  48. begin
  49. for J := 0 to Win.ControlCount — 1 do
  50. if Win.Controls [J].Left > 110 then
  51. begin
  52. Win.Controls [J].Left := Win.Controls [J].Left — 112;
  53. Win.Controls [J].Top := 30;
  54. end;
  55. end
  56. else
  57. begin
  58. for J := 0 to Win.ControlCount — 1 do
  59. if Win.Controls [J].Top = 30 then
  60. begin
  61. Win.Controls [J].Left := Win.Controls [J].Left + 112;
  62. Win.Controls [J].Top := 2;
  63. end;
  64. end
  65. end;
  66. procedure TToolbarForm.RotateSpeedbar;
  67. var
  68. I, X, Y: Integer;
  69. begin
  70. for I := 0 to Panel1.ControlCount — 1 do
  71. begin
  72. X := Panel1.Controls [I].Top;
  73. Y := Panel1.Controls [I].Left;
  74. Panel1.Controls [I].Top := Y;
  75. Panel1.Controls [I].Left := X;
  76. end;
  77. end;
  78. procedure TToolbarForm.FormCreate(Sender: TObject);
  79. begin
  80. BarPos := alTop;
  81. PanelSize := Panel1.Height;
  82. BoxOn := False;
  83. end;
  84. end.


Чтобы указать возможные положения инструментальной линейки, можно использовать тип данных TAlign, определяемый библиотекой VCL как:


TAlign = (alNone, alTop, alBottom, alLeft, alRight, alClient);

Значение alNone будет использоваться, чтобы обозначить комплект инструментальных средств (а не инструментальную линейку). Этот тип данных является возвращаемым значением функции GetBarPos, которая возвращает другой код в зависимости от значений параметров Х и У, представляющих координаты формы (строка 22 – 34 ).

В этом коде DragSize — константа, которая определена в соответствии с программой и должна быть меньше высоты (или ширины) инструментальной линейки (строка 21 ). Как только заканчивается буксировка, вы должны переместить инструментальную линейку в новое место. Начнем с простого случая. Какой же код вы должны написать, чтобы переместить инструментальную линейку из верхней части формы к ее нижней части? Вы должны только изменить значение свойства Align панели:

Вы можете просто игнорировать другие компоненты формы, потому что имеющийся компонент Label выровнен по клиентской области, т.е. он охватывает всю область формы, исключая прямоугольник, занятый инструментальной линейкой. Чтобы восстановить Panell в верхней части формы, требуется совершить обратное действие. Когда вы перемещаете инструментальную линейку в другое место, выполнится аналогичное действие с помощью возвращаемого значения функции (строки 45 – 46 ).


ReqPos := GetBarPos (X + Label1.Left, Y + Label1.Top);

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

Чтобы переместить кнопку из горизонтальной полоски в вертикальную, вы можете просто поменять ее координату Тор на координату Left. Чтобы переместить кнопки обратно в горизонтальную полоску, вы снова должны выполнить такую же, но обратную операцию. Для этого использована процедура RotateSpeedbar (строки 96 – 108 ).

Описанный метод инвертирует значения X и Y для каждого управляющего элемента полоски, просматривая ControlCount из массива Controls . Но этот код хорошо работает только для квадратных управляющих элементов. Когда вы должны вызывать этот метод? Только когда старая и новая инструментальные линейки являются соответственно вертикальной и горизонтальной, или наоборот:


If ( (ReqPos in [alTop, alBottom]) and (BarPos in [alLeft, alRight]) ) or

( (ReqPos in [alLeft, alRight]) and (BarPos in [alTop, alBottom]) ) then RotateSpeedbar;

В этой проверке с помощью оператора if переменная BarPos содержит текущее положение инструментальной линейки. С помощью этого кода теперь вы можете перемещать инструментальную линейку в каждую из четырех сторон формы. И последнее, что вы должны сделать, это преобразовать инструментальную линейку в комплект инструментальных средств. Чтобы выполнить это, необходимо добавить в проект вторую форму ToolBox и присвоить ее свойствам BorderStyle значение bsToolWindow, a свойству FormStyle — значение fsStayOnTop.

Программный код для второй формы представлен ниже:

procedure TToolBox.FormClose(Sender: TObject; var Action: TCloseAction);

if ToolbarForm.BarPos in [alLeft, alRight] then

Форма комплекта инструментальных средств является пустой, и в нее можно копировать быстрые кнопки, когда это понадобится. Если операция буксировки завершается в центральной части формы, показывается комплект инструментальных средств, скрывается инструментальная линейка, поворачиваются быстрые кнопки. Если они расположены по вертикали, то вызывается метод MoveButtons. Код также присваивает частному логическому полю ВохО n формы значение True, чтобы указать, что инструментальная линейка видима, строки ( 46 – 55 ).

Метод MoveButtons выполняет два различных действия: вначале он перемещает кнопку в TWinControl, передаваемый как параметр, а затем размещает быстрые кнопки в две строки или же перемещает их обратно в одну строки ( 67 – 95 ).

Результат работы программы показан на рисунке 8.

  1. Марко Канту. Delphi 2 для Windows 95/NT. Москва. ООО «Малип». 1997 г.
  2. Джон Матчо. Дэвид Р. Фолкнер. Delphi. Москва. БИНОМ. 1995 г.
  3. Эндрю Возневич. Delphi. Освой самостоятельно. Москва. Восточная книжная компания. 1996 г.
  4. В.В.Фаронов. Delphi5. Учебный курс. Москва. Издательство Нолидж. 2000 г.
  5. А. Я. Архангельский. Программирование в Delphi 5. Москва. ЗАО «Издательство Бином». 2000 г.


Владимир Скуратов

Включение в код отладочной информации

Перед началом отладки следует убедиться, что в приложение включена отладочная информация Delphi.

Для компиляции проекта с отладочной информацией следует выполнить команду Project/Options и в диалоговом окне Project Options выбрать вкладку Compiler (рис. 6).

Рис. 6.Вкладка Compiler диалогового окна Project Options

Включение отладочной информации регулируется следующими установками из группы Debugging:

· Debug Information — опция контролирует включение отладочной информации. При отключении этой опции вы не сможете трассировать код или ставить точки прерывания в любом модуле. Опция эквивалентна директивам компилятора $D и $DEBUGINFO

· Local Symbols — опция контролирует включение информации о локальных переменных, декларированных, например, внутри функций, процедур и раздела implementation. Вряд ли у вас возникнет необходимость в отключении этой опции, тем более что она игнорируется при выключенной предыдущей опции. Эквивалентные директивы компилятора— $L и $LOCALSYMBOLS.

· Reference info — эту опцию нельзя целиком отнести к разряду отладочных, так как ее действие направлено на браузер объектов, а не на встроенный отладчик. Если опция включена, браузер объектов сможет выводить информацию для объектов, определенных в модулях. Опция игнорируется при выключенных предыдущих двух опциях. Эквивалентные директивы компилятора — $Y и $REFERENCEINFO.

Обычно опции Debug Information и Local Symbols включаются для пошаговой трассировки приложения. Однако можно отключить отладочную информацию для некоторых модулей (просто используя соответствующую директиву в начале модуля).

Использование директивы $D- автоматически отключает опции Local Symbols и Symbol Info, так что вам не надо отключать их отдельно.

ПараметрOptimizationгруппыCode generationвлияет непосредственно на оптимизацию кода: при включенном параметре код будет сгенерирован максимально оптимальным способом с учетом как его размера, так и скорости исполнения. Это может привести к потере возможности доступа (даже на чтение) к некоторым локальным переменным, ибо из-за оптимизации кода они уже могут быть удалены из памяти в тот момент, когда программа остановилась в точке останова.

Также влияют на отладку параметры группыRuntime errors.

Не нашли то, что искали? Воспользуйтесь поиском:

Лучшие изречения: Как то на паре, один преподаватель сказал, когда лекция заканчивалась — это был конец пары: «Что-то тут концом пахнет». 8373 — | 8006 — или читать все.

188.64.174.135 © studopedia.ru Не является автором материалов, которые размещены. Но предоставляет возможность бесплатного использования. Есть нарушение авторского права? Напишите нам | Обратная связь.

Отключите adBlock!
и обновите страницу (F5)

очень нужно

Директивы Компилятора-Версии Delphi

у меня есть единица, которую я написал в Delphi 7 некоторое время назад, и только что получил удовольствие (боль) от преобразования в Delphi XE (Unicode).

устройство отлично работает после некоторых проблем, теперь я пытаюсь сделать это устройство совместимым с различными версиями Delphi, если мне когда-либо понадобится переключить IDE обратно на Delphi 7 при обновлении другого кода.

У меня есть только Delphi 7 и Delphi XE, но из того, что я собираю код, написанный на Delphi 1 в Delphi 2007, будет компилироваться, но код из Delphi 2009 и выше будет Unicode.

. Во всяком случае, в блоке я разделяю не-unicode и unicode следующим образом:

Как изменить директиву компилятора, чтобы правила применялись к нескольким версиям? Например что-то вроде:

это будет охватывать все версии Delphi, если я распространю источник или .блок УЗК.

2 ответов

интересно, Самый простой подход в этом случае-переключить поведение на UNICODE условное. Это условие определяется тогда и только тогда, когда вы используете версию Delphi в Юникоде, т. е. в Delphi 2009 и более поздних версиях. Большим преимуществом этого является то, что это будущее-вам не нужно обновлять код каждый раз, когда выходит новый Делфи. Более того, условный переключатель будет гораздо более читаемым, поскольку он будет четко выражать намерение.

Delphi документация имеет отличный темы список всех предопределенных условий. Полный список условий версии также связан оттуда.

Директивы по версиям компилятора Delphi: <$ IFDEF VER180>— 2020

Подготовка к кодированию без барьеров. Узнайте, как преодолеть проблему с версией компилятора: компиляция кода Delphi для различных версий Delphi.

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

Предположим, вы пишете свой собственный (коммерческий) пользовательский компонент. Пользователи вашего компонента могут иметь разные версии Delphi, чем у вас.

Если они попытаются перекомпилировать код компонента (ваш код) — у них могут быть проблемы! Что если вы использовали параметры по умолчанию в ваших функциях, а у пользователя Delphi 3?

Директива компилятора: $ IfDef

Директивы компилятора — это специальные синтаксические комментарии, которые мы можем использовать для управления функциями компилятора Delphi. Компилятор Delphi имеет три типа директив: переключение директив, директивы параметров а также условные директивы, Условная компиляция позволяет нам выборочно компилировать части исходного кода в зависимости от того, какие условия установлены.

Директива компилятора $ IfDef запускает секцию условной компиляции.

Синтаксис выглядит так:

DefName представляет так называемый условный символ. Delphi определяет несколько стандартных условных символов. В приведенном выше «коде», если определено DefName, код выше $ Else компилируется.

Delphi Version Symbols

Распространенным применением директивы $ IfDef является тестирование версии компилятора Delphi.

В следующем списке указаны символы, которые необходимо проверить при условной компиляции для конкретной версии компилятора Delphi:

  • УСЛОВНОЕ ОБОЗНАЧЕНИЕ — Компиляционная версия
  • VER80 — Delphi 1
  • VER90 — Delphi 2
  • VER100 — Delphi 3
  • VER120 — Delphi 4
  • VER130 — Delphi 5
  • VER140 — Delphi 6
  • VER150 — Delphi 7
  • VER160 — Delphi 8
  • VER170 — Delphi 2005
  • VER180 — Delphi 2006
  • VER180 — Delphi 2007
  • VER185 — Delphi 2007
  • VER200 — Delphi 2009
  • VER210 — Delphi 2010
  • VER220 — Delphi XE
  • VER230 — Delphi XE2
  • WIN32 — Указывает, что операционной средой является Win32 API.
  • LINUX — Указывает, что операционной средой является Linux
  • MSWindows — Указывает, что операционной средой является MS Windows / li]
  • ПРИСТАВКА — Указывает, что приложение компилируется как консольное приложение.

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

Примечание: символ VER185, например, используется для обозначения компилятора Delphi 2007 или более ранней версии.

Использование символов «VER»

Обычно (и желательно) для каждой новой версии Delphi добавлять несколько новых подпрограмм RTL к языку.

Например, функция IncludeTrailingBackslash, представленная в Delphi 5, добавляет «» в конец строки, если ее там еще нет. В проекте Delphi MP3 я использовал эту функцию, и несколько читателей пожаловались, что не могут скомпилировать проект — у них есть какая-то версия Delphi до Delphi 5.

Одним из способов решения этой проблемы является создание собственной версии этой подпрограммы — функции AddLastBackSlash.

Если проект должен быть скомпилирован на Delphi 5, вызывается IncludeTrailingBackslash. Если используются некоторые из предыдущих версий Delphi, мы моделируем функцию IncludeTrailingBackslash.

Это может выглядеть примерно так:

функция AddLastBackSlash (ул: строка) : строка; начать Результат: = IncludeTrailingBackslash (str); если Copy (str, Length (str), 1) = «» затем Результат: = ул еще Результат: = str + «»; конец;

При вызове функции AddLastBackSlash Delphi выясняет, какая часть функции должна использоваться, а другая часть просто пропускается.

Delphi 2008?

Delphi 2007 использует VER180 для обеспечения неразрывной совместимости с Delphi 2006, а затем добавляет VER185 для разработки, которая по каким-либо причинам должна быть нацелена на Delphi 2007.

Примечание. Каждый раз, когда интерфейс модуля изменяет код, использующий этот модуль, его необходимо перекомпилировать.Delphi 2007 — выпуск без прерываний, означающий, что файлы DCU из Delphi 2006 будут работать как есть.

$ReferenceInfo — Директива компилятора Delphi

3437 просмотра

3 ответа

2628 Репутация автора

я работаю над приложением с использованием Delphi 7 , и я только что наткнулся на это

автор кода поместил так много директив компилятора перед именем основного модуля.

может кто-нибудь сказать мне

  1. Какая польза от наличия Директив перед именем единицы, это делает их глобальными?
  2. И можем ли мы создавать свои собственные директивы в некоторых конкретных ситуациях?
  3. где определены директивы компилятора?

Автор: PresleyDiasИсточник Размещён: 17.01.2012 11:10

Ответы (3)

7 плюса

527596 Репутация автора

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

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

Директивы Switch являются глобальными или локальными:

  • Глобальные директивы влияют на всю компиляцию и должны появляться перед частью объявления программы или компилируемого модуля.
  • Локальные директивы влияют только на ту часть компиляции, которая простирается от директивы до следующего появления той же директивы. Они могут появиться где угодно.

Однако рассмотрим DENYPACKAGEUNIT директиву (выделено мной):

<$DENYPACKAGEUNIT ON>Директива запрещает Delphi блок , в котором он появляется из помещаются в пакет.

Если эта директива имеет охват всей единицы, то она просто должна присутствовать в единице для вступления в силу.

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

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

Похоже, что произошло в коде, который вы представляете, это то, что автор набрал, CTRL+O O и среда IDE вставила различные параметры, определенные в параметрах проекта в тот момент времени.

4 плюса

24047 Репутация автора

  1. Какая польза от наличия Директив перед именем единицы, это делает их глобальными?

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

  1. И можем ли мы создавать свои собственные директивы в некоторых конкретных ситуациях?

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

Они определены в источниках компилятора. Они задокументированы в документации компилятора, и вы уже нашли отличную ссылку (ваша вторая ссылка)

плюса

1 Репутация автора

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

$Align — директива компилятора

Posted by key under Delphi

Определяет, были ли данные выровнены или упакованы

Описание:

С $Align On (по умолчанию), сложные типы данных, такие как записи, хранят свои элементы, выровненные по 2, 4 или 8-байтовой границе, соответственно типу данных. Например, поле типа Word будет выровнено по 4-байтовой границе.

С $Align On, значением по умолчанию, вы можете перекрыть эти настройки с помощью опции packed для сложных типов данных.

Выравнивание обеспечивает оптимальную скорость доступа.

$Align Off указывает Delphi игнорировать выравнивание, и таким образом пакует данные.

Пример кода:

// Declare a packed record
TPackedRecord = Packed Record
name1 : string[4];
floater : single;
name2 : char;
int : Integer;
end;

// Set alignment off

// Declare an unpacked record
// This will get treated as if packed was on
TUnPackedRecord = Record
name1 : string[4];
floater : single;
name2 : char;
int : Integer;
end;

var
alignedRec : TAlignedRecord;
packedRec : TPackedRecord;
unPackedRec : TUnPackedRecord;

begin
ShowMessage(‘Aligned record size = ‘+IntToStr(SizeOf(alignedRec)));
ShowMessage(‘Packed record size = ‘+IntToStr(SizeOf(packedRec)));
ShowMessage(‘UnPacked record size = ‘+IntToStr(SizeOf(unPackedRec)));
end;

$ReferenceInfo — Директива компилятора Delphi

Как сделать свои собственные сообщения при компилляции

Как узнать версию компиллятора ?

Какие есть директивы компилятора?

<$I+>и <$I->— директивы контроля ввода/вывода
<$M>и <$S>— директивы, определяющие размер стека

<$M+>и <$M->— директивы информации времени выполнения о типах
<$Q+>и <$Q->— директивы проверки переполнения целочисленных операций

<$R>— директива связывания ресурсов

<$R+>и <$R->— директивы проверки диапазона

<$APPTYPE CONSOLE>— директива создания консольного приложения

1) Директивы компилятора, разрешающие или запрещающие проверку утверждений.

По умолчанию <$C+>или <$ASSERTIONS ON>
Область действия локальная

Директивы компилятора $C разрешают или запрещают проверку утверждений. Они влияют на работу процедуры Assert,используемой при отладке программ. По умолчанию действует
директива <$C+>и процедура Assert генерирует исключение EAssertionFailed , если проверяемое утверждение ложно.
Так как эти проверки используются только в процессе отладки программы, то перед ее окончательной компиляцией следует указать директиву <$C->. При этом работа процедур Assert будет блокировано и генерация исключений EassertionFailed производиться не будет.
Директивы действуют на весь файл исходного кода независимо от того, в каком месте файла они расположены.

2) Директивы компилятора, включающие и выключающие контроль файлового ввода-вывода.

По умолчанию <$I+>или <$IOCHECKS ON>
Область действия локальная

Директивы компилятора $I включают или выключают автоматический контроль результата вызова процедур ввода-вывода Object Pascal . Если действует директива <$I+>, то при возвращении процедурой ввода-вывода ненулевого значения генерируется исключение EInOutError и в его свойство errorcode заносится код ошибки. Таким образом, при действующей директиве <$I+>операции ввода-вывода располагаются в блоке try . except , имеющем обработчик исключения EInOutError . Если такого блока нет, то обработка производится методом TApplication.HandleException .
Если действует директива <$I->, то исключение не генерируется. В этом случае проверить, была ли ошибка, или ее не было, можно, обратившись к функции IOResult . Эта функция очищает ошибку и возвращает ее код, который затем можно анализировать. Типичное применение директивы <$I->и функции IOResult демонстрирует следующий пример:

AssignFile ( F,s );
Rewrite (F);

<$I+>
i:=IOResult ;
if i <> 0 then
case i of
2 : .
3 : .
end ;

В этом примере на время открытия файла отключается проверка ошибок ввода вывода, затем она опять включается, переменной i присваивается значение, возвращаемое функцией IOResult и, если это значение не равно нулю (есть ошибка), то предпринимаются какие-то действия в зависимости от кода ошибки. Подобный стиль программирования был типичен до введения в Object Pascal механизма обработки исключений. Однако сейчас, по-видимому, подобный стиль устарел и применение директив $I потеряло былое значение.

3) Директивы компилятора, определяющие размер стека

По умолчанию <$M 16384,1048576>
Область действия глобальная

Локальные переменные в процедурах и функциях размещаются в стеке приложения. При каждом вызове процедуры или функции ее локальные переменные помещаются в стек. При выходе из процедуры или функции эти локальные процедуры удаляются из стека.
Директивы компилятора $M задают параметры стека приложения: его минимальный и максимальный размеры. Приложение всегда гарантировано имеет размер стека, равный его минимальной величине. Если при запуске приложения Windows обнаруживает, что не может выделить этот минимальный объем памяти, то выдается сообщение об этой ошибке.
Если во время работы выясняется, что минимального размера стека не хватает, то размер увеличивается на 4 K, но не более, чем до установленного директивой максимального размера. Если увеличение размера стека невозможно из-за нехватки памяти или из-за достижения его максимальной величины, генерируется исключение EStackOverflow . Минимальный размер стека по умолчанию равен 16384 (16K). Этот размер может изменяться параметром minstacksize директивы <$M>или параметром number директивы <$MINSTACKSIZE>.
Максимальный размер стека по умолчанию равен 1,048,576 (1M). Этот размер может изменяться параметром maxstacksize директивы <$M>или параметром number директивы <$MAXSTACKSIZE number >. Значение минимального размера стека может задаваться целым числом в диапазоне между1024 и 2147483647. Значение максимального размера стека должно быть не менее минимального размера и не более 2147483647. Директивы задания размера стека могут включаться только в программу и не должны использоваться в библиотеках и модулях.

В Delphi 1 имеется процедура компилятора <$S>, осуществляющая переключение контроля переполнения стека. Теперь этот процесс полностью автоматизирован и директива <$S>оставлена только для обратной совместимости.

4) Директивы компилятора, включающие и выключающие генерацию информации времени выполнения о типах ( runtime type information — RTTI).

По умолчанию <$M->или <$ TYPEINFO OFF>
Область действия локальная

Директивы компилятора $M включают или выключают генерацию информации времени выполнения о типах ( runtime type information — RTTI). Если класс объявляется в состоянии <$M+>или является производным от класса объявленного в этом состоянии, то компилятор генерирует RTTI о его полях, методах и свойствах, объявленных в разделе published . В противном случае раздел published в классе не допускается. Класс TPersistent , являющийся предшественником большинства классов Delphi и все классов компонентов, объявлен в модуле Classes в состоянии <$M+>. Так что для всех классов, производных от него, заботиться о директиве <$M+>не приходится.

5) Директивы компилятора, включающие и выключающие проверку переполнения при целочисленных операциях

По умолчанию <$Q->или <$OVERFLOWCHECKS OFF>
Область действия локальная

Директивы компилятора $Q включают или выключают проверку переполнения при целочисленных операциях. Под переполнением понимается получение результата, который не может сохраняться в регистре компьютера. При включенной директиве <$Q+>проверяется переполнение при целочисленных операциях +, -, *, Abs , Sqr , Succ , Pred , Inc и Dec . После каждой из этих операций размещается код, осуществляющий соответствующую проверку. Если обнаружено переполнение, то генерируется исключение EIntOverflow . Если это исключение не может быть обработано, выполнение программы завершается.
Директивы $Q проверяют только результат арифметических операций. Обычно они используются совместно с директивами <$R>, проверяющими диапазон значений при присваивании.
Директива <$Q+>замедляет выполнение программы и увеличивает ее размер. Поэтому обычно она используется только во время отладки программы. Однако, надо отдавать себе отчет, что отключение этой директивы приведет к появлению ошибочных результатов расчета в случаях, если переполнение действительно произойдет во время выполнении программы. Причем сообщений о подобных ошибках не будет.

6) Директивы компилятора, включающие и выключающие проверку диапазона целочисленных значений и индексов

По умолчанию <$R>или <$RANGECHECKS OFF>
Область действия локальная

Директивы компилятора $R включают или выключают проверку диапазона целочисленных значений и индексов. Если включена директива <$R+>, то все индексы массивов и строк и все присваивания скалярным переменным и переменным с ограниченным диапазоном значений проверяются на соответствие значения допустимому диапазону. Если требования диапазона нарушены или присваиваемое значение слишком велико, генерируется исключение ERangeError . Если оно не может быть перехвачено, выполнение программы завершается.
Проверка диапазона длинных строк типа Long strings не производится.
Директива <$R+>замедляет работу приложения и увеличивает его размер. Поэтому она обычно используется только во время отладки.

6) Директива компилятора, связывающая с выполняемым модулем файлы ресурсов

Область действия локальная

Директива компилятора <$R>указывает файлы ресурсов (.DFM, .RES), которые должны быть включены в выполняемый модуль или в библиотеку. Указанный файл должен быть файлом ресурсов Windows . По умолчанию расширение файлов ресурсов — .RES.
В процессе компоновки компилированной программы или библиотеки файлы, указанные в директивах <$R>, копируются в выполняемый модуль. Компоновщик Delphi ищет эти файлы сначала в том каталоге, в котором расположен модуль, содержащий директиву <$R>, а затем в каталогах, указанных при выполнении команды главного меню Project | Options на странице Directories / Conditionals диалогового окна в опции Search path или в опции /R командной строки DCC32.
При генерации кода модуля, содержащего форму, Delphi автоматически включает в файл . pas директиву <$R *.DFM>, обеспечивающую компоновку файлов ресурсов форм. Эту директиву нельзя удалять из текста модуля, так как в противном случае загрузочный модуль не будет создан и генерируется исключение EResNotFound .


Все установленные в настройках опции компиляции можно вставить непосредственно в текст программы нажав клавиши Ctrl-O , O

Как сделать свои собственные сообщения при компилляции ?

destructor TumbSelectionTempTable.Destroy ;
begin
// Clear the temp tables.
<$MESSAGE Warn ' - remember to free all allocated objects'>
ClearAllOuterWorldFold ;
if FSubjectsTempTableCreated then
DropTempTable ( FTableName );

FOuterWorldsFolded.Free ;
FQuery.Free ;
inherited ;
end ;

Работает только в Дельфи 6/7

Как узнать версию компилятора?

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

В Дельфи предопределены специальные константы компиляции для этого:

Ver80 — Дельфи 1
Ver90 — Дельфи 2
Ver93 — С Buider 1
Ver100 — Дельфи 3
Ver110 — С Buider 3
Ver120 — Дельфи 4
Ver125 — С Buider 4
Ver130 — Дельфи 5
Ver140 — Дельфи 6
Ver150 — Дельфи 7

procedure TForm1.Button2Click( Sender : TObject );
const Version=

Условная компиляция в Delphi

Условная компиляция в Delphi, по сути, очень полезная и удобная возможность, которая позволяет Delphi компилировать или не компилировать код в зависимости от определенных символов условной компиляции. Говоря более простым языком (возможно и не совсем корректно), условная компиляция позволяет убрать или, наоборот, добавить часть кода исполняемого файла. Так или иначе, любой Delphi разработчик встречается с символами условной компиляции как минимум один раз за время работы над проектом.

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

Для начала, рассмотрим очень простой код, который вы можете повторить в Delphi за несколько секунд:

Теперь нажмите F9 и проверьте, что написано в отладчике в «Events»:

Разберемся с тем, что мы только что написали.

$IFDEF — это директива компилятора;

DEBUG — условное определение или символ условной компиляции. Символ обязательно должен начинаться с буквы за которой может следовать любое количество букв, цифр и знаков подчеркивания, однако использоваться будут лишь первые 255 символов.

Процедура отправляет строку в отладчик для отображения.

Завершает условную компиляцию, инициированную последней директивой <$IFxxx>(почему не <$IFDEF>— смотрим далее).

Таким образом, используя директивы и мы указали компилятору дословно следующее: если где-либо по ходу компиляции был встречено условное определение DEBUG, то надо выполнить OutputDebugString.

Где определено условное определение DEBUG? Конкретно в этом случае, символ DEBUG можно найти, если зайти в настройки проекта: Project -> Options ->Delphi Compiler :

Здесь же можно определить и свои собственные символы. Давайте, например, добавим свой символ условной компиляции TEST. Для этого открываем диалоговое окно редактирования символов условной компиляции (жмем кнопку «…» в строке «Conditional defines») и заносим наш символ в список:

Теперь изменим наш код, приведенный в начале статьи, чтобы он работал с нашим символом условной компиляции:

Теперь можете снова запустить приложения в режиме отладки и посмотреть, что в Events появится строка «TEST IS ON».

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

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

и убедиться, что символ DEBUG выключен, а в окне Events не появится строка «debug is on».

Двигаемся далее. Что делать, если нам необходимо вывести строку не когда символ включен, а именно тогда, когда он выключен? Здесь, опять же, есть варианты. Короткий вариант — воспользоваться директивой противоположной — она называется и код между и выполняется, если символ выключен:

Второй вариант — использование директивы , если в зависимости от состояния символа условной компиляции вам надо выполнять различные участки кода:

Соответственно, нет необходимости далее повторять этот же участок кода с использованием — работать будет, но прямо противоположно.

Также следует обратить внимание на то, что все условные символы оцениваются в Delphi, когда вы выполняете Build проекта. Справка Delphi рекомендует для надежности пользоваться командой Project -> Build All Projects, чтобы быть уверенным, что все символы условной компиляции определены верно.

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

Например, символ условной компиляции VER330 определен для Delphi 10.3 Rio и с его помощью можно определить какой код должен или не должен выполняться, в случае, если версия компилятора Delphi — 33. Например, воспользуемся фичей Delphi 10.3 Rio под названием Inline Variable Declaration:

Сразу может возникнуть вопрос: как сделать так, чтобы приведенный выше код сработал не только в Delphi 10.3 Rio, но и в последующих версиях?
Это можно сделать воспользовавшись, например, такой конструкцией:

Здесь мы уже воспользовались директивой с помощью которой проверили значение константы CompilerVersion, которая находится в модуле System.

Здесь же стоит обратить внимание и на окончание блока — мы использовали директиву , как того требовала Delphi до версии Delphi XE4:

  • для директивы $IFDEF должна быть определена директива $ENDIF
  • для директивы $IF должна быть определена директива $IFEND

В XE4 нам разрешили использовать для закрытия блоков <$IF>, и . Однако, если у вас возникают проблемы при использовании связки и , то вы можете использовать специальную директиву , чтобы потребовать использовать для именно <$IFEND>:

Теперь, если в коде выше использовать директиву $ENDIF, то получим сообщение об ошибке:

Директиву , кстати, можно использовать и с другими константами проекта, например, так:

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

Как я сказал выше, в Delphi есть целый набор предопределенных символов условной компиляции. Ознакомиться со всеми этими символами вы можете на этой странице справки по Delphi.

  1. Использование условной компиляции позволяет нам выполнять тот или иной код, в зависимости от того, какие константы и символы условной компиляции определены или не определены в проекте.
  2. Используя предопредленные символы условной компиляции можно указывать Delphi какой код необходимо выполнить, например, если программа собирается под Android, или, если поддерживается архитектура x64 и т.д.
  3. Директива $IF может использоваться с различными константами, в том числе и определенными самим разработчиком.

При подготовке статьи использовалась следующая информация официальной справки по Delphi:

Директивы компилятора Compiler Directives

В этом разделе описываются директивы процессора и директивы компилятора. This topic describes processor directives and compiler directives.

Директивы препроцессора Preprocessor Directives

Директива препроцессора дополняется префиксом с символом «#» и отображается в строке сама по себе. A preprocessor directive is prefixed with the # symbol and appears on a line by itself. Она интерпретируется препроцессором, который запускается перед самим компилятором. It is interpreted by the preprocessor, which runs before the compiler itself.

В следующей таблице перечислены директивы препроцессора, имеющиеся в F#. The following table lists the preprocessor directives that are available in F#.

Директива Directive Описание Description
#if символ #if symbol Поддерживает условную компиляцию. Supports conditional compilation. Код в разделе после #if включается, если символ определен. Code in the section after the #if is included if the symbol is defined. Символ также может быть инвертирован с помощью ! . The symbol can also be negated with ! .
#else Поддерживает условную компиляцию. Supports conditional compilation. Помечает раздел кода, который следует включить, если символ, используемый с предыдущей директивой #if , не определен. Marks a section of code to include if the symbol used with the previous #if is not defined.
#endif Поддерживает условную компиляцию. Supports conditional compilation. Помечает конец условного раздела кода. Marks the end of a conditional section of code.
# штрих int, # [line] int,
# штрих тип int строка, # [line] int string,
# штрих тип int буквальная строка # [line] int verbatim-string
Указывает исходную строку кода и имя файла для отладки. Indicates the original source code line and file name, for debugging. Эта возможность предназначена для средств, создающих исходный код F#. This feature is provided for tools that generate F# source code.
#nowarn варнингкоде #nowarn warningcode Отключает предупреждение или предупреждения компилятора. Disables a compiler warning or warnings. Чтобы отключить предупреждение, найдите его номер в выходных данных компилятора и заключите его в кавычки. To disable a warning, find its number from the compiler output and include it in quotation marks. Не указывайте префикс «FS». Omit the «FS» prefix. Чтобы отключить несколько номеров предупреждений в одной строке, заключите каждый номер в кавычки и отделяйте каждую строку пробелом. To disable multiple warning numbers on the same line, include each number in quotation marks, and separate each string by a space. Например: For example:

Результат отключения предупреждения применяется ко всему файлу, включая фрагменты файла, предшествующие директиве. | The effect of disabling a warning applies to the entire file, including portions of the file that precede the directive.|

Директивы условной компиляции Conditional Compilation Directives

Код, Деактивируемый одной из этих директив, недоступен в редакторе Visual Studio Code. Code that is deactivated by one of these directives appears dimmed in the Visual Studio Code Editor.

Поведение директив условной компиляции отличается от их поведения в других языках. The behavior of the conditional compilation directives is not the same as it is in other languages. Например, нельзя использовать логические выражения с символами, а true и false не имеют особого значения. For example, you cannot use Boolean expressions involving symbols, and true and false have no special meaning. Символы, используемые в директиве if , должны задаваться с помощью командной строки или в параметрах проекта; в этом языке отсутствует директива препроцессора define . Symbols that you use in the if directive must be defined by the command line or in the project settings; there is no define preprocessor directive.

В следующем коде демонстрируется применение директив #if , #else и #endif . The following code illustrates the use of the #if , #else , and #endif directives. В данном примере код содержит две версии определения function1 . In this example, the code contains two versions of the definition of function1 . Если VERSION1 определяется с помощью параметра компилятора-define, активируется код между #if директивой и #else директивой. When VERSION1 is defined by using the -define compiler option, the code between the #if directive and the #else directive is activated. В противном случае активируется код между директивами #else и #endif . Otherwise, the code between #else and #endif is activated.

В языке F# отсутствует директива препроцессора #define . There is no #define preprocessor directive in F#. Вы должны использовать параметр компилятора или параметры проекта для определения символов, используемых директивой #if . You must use the compiler option or project settings to define the symbols used by the #if directive.

Директивы условной компиляции не могут быть вложенными. Conditional compilation directives can be nested. В директивах препроцессора отступ не важен. Indentation is not significant for preprocessor directives.

Можно также инвертировать символ с помощью ! . You can also negate a symbol with ! . В этом примере значением строки является нечто, только если не выполняется отладка: In this example, a string’s value is something only when not debugging:

Директивы строк Line Directives

При сборке компилятор сообщает об ошибках в коде F #, ссылаясь на номера строк, в которых возникли ошибки. When building, the compiler reports errors in F# code by referencing line numbers on which each error occurs. Номера строк начинаются с 1 для первой строки в файле. These line numbers start at 1 for the first line in a file. Тем не менее при создании исходного кода F# из другого средства номера строк в сформированном коде обычно не представляют интереса, поскольку ошибки в сформированном коде F#, скорее всего, проистекают из другого источника. However, if you are generating F# source code from another tool, the line numbers in the generated code are generally not of interest, because the errors in the generated F# code most likely arise from another source. Директива #line позволяет разработчикам средств, формирующих исходный код F#, передавать сведения о номерах исходных строк и исходных файлах в сформированный код F#. The #line directive provides a way for authors of tools that generate F# source code to pass information about the original line numbers and source files to the generated F# code.

При использовании директивы #line необходимо заключать имена файлов в кавычки. When you use the #line directive, file names must be enclosed in quotation marks. Если в начале строки не указывается токен verbatim ( @ ), то чтобы использовать в пути символы обратной косой черты, необходимо их экранировать, указывая две обратные косые черты вместо одной. Unless the verbatim token ( @ ) appears in front of the string, you must escape backslash characters by using two backslash characters instead of one in order to use them in the path. Далее приводятся допустимые токены строк. The following are valid line tokens. В этих примерах предполагается, что исходный файл Script1 при запуске в соответствующем средстве приводит к автоматическому созданию файла кода F# и что код в месте расположения этих директив формируется из некоторых токенов в строке 25 файла Script1 . In these examples, assume that the original file Script1 results in an automatically generated F# code file when it is run through a tool, and that the code at the location of these directives is generated from some tokens at line 25 in file Script1 .

Эти токены указывают, что код F#, сформированный в этом месте, является производным от некоторых конструкций в строке 25 или рядом с ней в файле Script1 . These tokens indicate that the F# code generated at this location is derived from some constructs at or near line 25 in Script1 .

Директивы компилятора Compiler Directives

Директивы компилятора сходны с директивами препроцессора, поскольку они имеют префикс в виде знака #, но они не интерпретируются препроцессором; компилировать и действовать в соответствии с этими директивами должен компилятор. Compiler directives resemble preprocessor directives, because they are prefixed with a # sign, but instead of being interpreted by the preprocessor, they are left for the compiler to interpret and act on.

В следующей таблице перечислены директивы компилятора, доступные в языке F#. The following table lists the compiler directive that is available in F#.

$ReferenceInfo — Директива компилятора Delphi

Есть ли в Delphi 7 директива компилятору по обработке исключений, регулируемых в процессе отладки галочкой Stop on Delphi Exception?

справку по директивам компилятора почитать не ?


> справку по директивам компилятора почитать не ?

зачем читать если можно спросить и заниматься своими делами. Но у меня, честно говоря, просто не было времени выяснять. А вообще я за RTFM


> зачем читать если можно спросить и заниматься своими делами

разумный подход, черт побери.


> зачем читать если можно спросить и заниматься своими делами.

Если эту логику чуть дальше развернуть, то получится, что зачем вообще работать? На этом форуме спрошу как делать это, на другом — как другое, на третьем — третье. А сам буду на диване лежать и фапать в потолок.

Что-то я не понял о чем речь?
Какая связь между директивами компилятора и поведением отладчика?

> Ega23 (15.04.2010 00:01:04) [4]

Остался один не достаток, спрашивать надо, бот бы еще без этого.

вот вы любители пофлеймить, дай только причину )))
ладно, шучу. Мануал так и не читал, потому что нет времени пока.

Проблема в том что мне надо в процессе отладки какого то алгоритма, видеть экцепшены, а некая логика завязана на них, то есть если я включу их индикацию то я буду ловить в отладчике все исключения, и зря останавливаться на тех, которые я ловлю в секциях try except. Вернее я их все ловлю но, определённого типа исключения я ловлю в циклах, а других типов только единожды. Вот если бы как то включить одни типы, а выключить другие — было бы круто!


> Константин (17.04.10 13:10) [7]


> было бы круто!

все и так круто.. заходим в опции дельфи и там находим что-то типа
Debugger Options -> Language Exception

> Константин (17.04.2010 13:10:07) [7]

Мануал все таки читай. Времени для этого более чем достаточно, программировать пока не надо.

Илон Маск рекомендует:  Популярные вопросы по MySQL и ответы на них. FAQ MySQL, PHP
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL