Директивы компилятора на целевом языке

Вы управляете тем, как код генерируется из моделей, в основном, путем написания или изменения скриптов, которые применяют директивы TLC и встроенные функции. Используйте следующие разделы в качестве основной ссылки на синтаксис и формат конструкций целевого языка, а также MATLAB® tlc сама команда.

Директива целевого языка должна быть первым непустым символом на линию и начинаться с % символ. Линии, начинающиеся с %% являются комментариями TLC и не передаются в выходной поток. Линии, начинающиеся с /* являются комментариями C и передаются в выходной поток.

Синтаксис

Файл целевого языка состоит из ряда операторов любой формы:

  • [text | %<expression>]* 

    Буквенный текст передается в выходной поток без изменений, и выражения заключаются в %< > оцениваются перед записью в выход (отменяется %< >).

  • %keyword [argument1, argument2, ...]

    The %keyword представляет одну из директив Target Language Compiler, и [argument1, argument2, ...] представляет выражения, которые определяют требуемые параметры. Для примера, заявление

    %assign sysNumber = sysIdx + 1

    использует %assign директива для определения или изменения значения sysNumber параметр.

Директивы

Остальная часть этого раздела показывает полный набор директивы Target Language Compiler и подробно описывает каждую директиву.

%% text

Однострочный комментарий, где text - это комментарий.

/% text%/

Один (или многострочный) комментарий, где text - это комментарий.

%matlab

Вызывает функцию MATLAB, которая не возвращает результат. Для примера, %matlab disp(2.718).

%<expr>

Оцениваемые выражения на целевом языке. Для примера, если у вас есть переменная TLC, которая была создана через %assign varName = "foo", затем %<varName> расширился бы до foo. Выражения могут также быть вызовами функций, как в %<FcnName(param1,param2)>. При линиях директивы выражения TLC не должны помещаться в %<> синтаксис. Это приводит к двойной оценке. Для примера, %if %<x> == 3 обрабатывается путем создания скрытой переменной для вычисляемого значения переменной x. The %if затем оператор оценивает эту скрытую переменную и сравнивает ее с 3. Эффективным способом выполнить эту операцию является запись %if x == 3. В обозначении MATLAB это было бы равно записи, если бы eval('x') == 3 в отличие от, если x = 3. Исключение из этого во время %assign для управления форматом, как в

 %assign str = "value is: %<var>"

Примечание: Вложенные выражения оценки (например %<foo(%<expr>)> ) не поддерживаются.

Нет штрафа за скорость для вычислений внутри строк, таких как

%assign x = "%<expr>"

Избегайте вычислений вне строк, таких как следующий пример.

%assign x = %<expr>

%, если expr
% elseif expr
%else
%endif

Условное включение, где постоянное выражение expr необходимо вычислить целое число. Например, следующий код проверяет, является ли параметр, k, имеет числовое значение 0.0 путем выполнения функции библиотеки TLC для проверки на равенство.

%if ISEQUAL(k, 0.0)
  <text and directives to be processed if k is 0.0>
%endif

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

%if ISEQUAL(idx, "my_idx%<i>"), где idx и i являются обеими строками.

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

% switch expr
  % case expr
  %break
  %default
  %break
%endswitch

The %switch директива подобна языку C switch оператор. Выражение expr должен быть типа, который можно сравнить для равенства с помощью == operator. Если на %break не включается после %case оператор, затем оно попадет к следующему оператору.

%with
%endwith

%with recordName является оператором проверки. Используйте его, чтобы перенести именованную запись в текущие возможности, чтобы остаться до совпадения %endwith встречается (%with директивы могут быть вложены по желанию).

Обратите внимание, что с левой стороны %assign операторы, содержащиеся в %with / %endwith блок, ссылки на поля записей должны быть полными (см. Присвоение значений полям записей), как в следующем примере.

%with CompiledModel
	 %assign oldName = name
	 %assign CompiledModel.name = "newname"
 	%endwith

% setcommandswitch string

Изменяет значение ключа командной строки, как задано строкой аргумента. Поддерживаются только следующие коммутаторы:

v, m, p, O, d, r, I, a

В следующем примере уровень подробностей устанавливается равным 1.

%setcommandswitch "-v1"

См. также Аргументы в командной строке.

% assert expr

Проверяет значение логического выражения. Если выражение вычисляется как false, TLC выдает сообщение об ошибке, трассировку стека и выход; в противном случае выполнение продолжается нормально. Чтобы включить оценку утверждений вне окружения генератора кода, используйте опцию командной строки -da. При построении из генератора кода этот флаг игнорируется, так как он заменяется флажком Enable TLC assertion в TLC process разделе панели Code Generation > Debug. Для управления обработкой утверждений из Командного окна MATLAB используйте

set_param(model, 'TLCAssertion', 'on|off')

установить этот флаг на или off. Default is Off. Чтобы увидеть текущую настройку, используйте

get_param(model, 'TLCAssertion')

%error
%warning
%trace
%exit

Директивы по регулированию потока:

% error tokens

The tokens развернуты и отображены.

% предупреждающих tokens

The tokens развернуты и отображены.

% trace tokens

The tokens развернуты и отображаются только при опции подробного выхода в командной строке -v или -v1 задан.

% выход tokens

The tokens развертываются, отображаются и выходы TLC.

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

%exit Error Message

Если вы добавляете код assert (то есть код, который никогда не должен быть достигнут), используйте

%setcommandswitch "-v1" %% force TLC stack trace 
%exit Assert message

%assign

Создает идентификаторы (переменные). Общая форма

%assign [::]variable = expression 

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

Если вам нужно форматировать переменную, скажем, в строке, основанной на других переменных TLC, то вы должны выполнить двойную оценку, как в

%assign nameInfo = "The name of this is %<Name>"

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

%assign nameInfo = "The name of this is " + Name

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

%createrecord

Создает записи в памяти. Эта команда принимает список одной или нескольких спецификаций записи (например { foo 27 }). Каждая спецификация записи содержит список нуля или нескольких пар "имя-значение" (например foo 27), которые становятся представителями создаваемой записи. Сами значения могут быть спецификациями записи, как показано на следующем рисунке.

%createrecord NEW_RECORD { foo 1 ; SUB_RECORD {foo 2} }
%assign x = NEW_RECORD.foo                  /* x = 1 */
%assign y = NEW_RECORD.SUB_RECORD.foo       /* y = 2 */

Если более одной спецификации записи следуют за заданным именем записи, то набор спецификаций записи представляет собой массив записей.

%createrecord RECORD_ARRAY { foo 1 } ...
							        { foo 2 } ...
							        { bar 3 } 
%assign x = RECORD_ARRAY[1].foo             /* x = 2 */
%assign y = RECORD_ARRAY[2].bar             /* y = 3 */

Обратите внимание, что можно создавать и индекс массивы подзаписей путем определения %createrecord с одинаковыми подзаписями, следующим образом:

%createrecord RECORD_ARRAY { SUB_RECORD { foo 1 } ... 
                             SUB_RECORD { foo 2 } ... 
                             SUB_RECORD { foo 3 } }
%assign x = RECORD_ARRAY.SUB_RECORD[1].foo  /* x = 2 */
%assign y = RECORD_ARRAY.SUB_RECORD[2].foo  /* y = 3 */

Если оператор разрешения возможностей (::) является первой лексемой после %createrecord лексема, запись создается в глобальных возможностях.

Примечание

Не следует создавать массив записей при помощи %createrecord в цикле.

%addtorecord

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

%addtorecord OLD_RECORD foo 1

Если добавляемое новое поле является записью, то %addtorecord делает псевдоним этой записи вместо глубокого копия.Чтобы сделать глубокую копию, используйте %copyrecord.

%createrecord NEW_RECORD { foo 1 }
%addtorecord OLD_RECORD NEW_RECORD_ALIAS NEW_RECORD

%mergerecord

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

%mergerecord OLD_RECORD NEW_RECORD

Если в объединяемых записях существуют повторяющиеся поля, поля исходной записи не перезаписываются.

%copyrecord

Создает глубокую копию существующей записи. Он создает новую запись подобно %createrecord кроме того, компоненты записи глубоко копируются из существующей записи. Псевдонимы заменяются копиями.

%copyrecord NEW_RECORD OLD_RECORD

%realformat

Задает формат действительных переменных. Для форматирования в экспоненциальном обозначении с 16 цифрами точности используйте

%realformat "EXPONENTIAL"

Для форматирования без потери точности и минимального количества символов используйте

%realformat "CONCISE"

При встраивании S-функций формат устанавливается на concise. Можно переключиться на exponential, но должен переключиться назад на concise когда сделано.

%language

Это должно появиться перед первым GENERATE или GENERATE_TYPE вызов функции. Это задает имя языка как строку, которая генерируется как на %language "C". Как правило, это добавляется к целевому системному файлу.

Единственное допустимое значение C что позволяет поддерживать C и C++ генерация кода, заданная параметром конфигурации TargetLang(для получения дополнительной информации см. «Язык»).

%implements

Помещается в .tlc файл для определенного типа записи, при отображении через %generatefile. Синтаксис следующий %implements "Type" "Language". При введении S-функции в C или C++ это должна быть первая некоммерческая линия в файле, как в

%implements "s_function_name" "C"

Следующие некоммерческие линии будут %function директивы, определяющие функциональность S-функции.

Смотрите %language и GENERATE описание функции для получения дополнительной информации.

%generatefile

Обеспечивает отображение между записями Type и функции, содержащиеся в файле. Каждая запись может иметь функции с одним и тем же именем, но различное содержимое, сопоставленное с ней (то есть полиморфизм). Обычно это используется для отображения Block запись Type на .tlc файл, который реализует функциональность блока, как в

%generatefile "Sin" "sin_wave.tlc"

%filescope

Ограничивает возможности переменных файлом, в котором они определены. A %filescope директива в любом месте файла объявляет, что переменные в файле видны только в этом файле. Обратите внимание, что это ограничение также относится к файлам, вставленным через %include директива, в файл, содержащий %filescope директива.

Вы не должны использовать %filescope директива в функциях или GENERATE функций.

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

%include

Использование %include "file.tlc"чтобы вставить указанный целевой файл в текущую точку.

The %include директивы ведут себя так, как будто они находятся в глобальном контексте. Для примера,

%addincludepath "./sub1"
%addincludepath "./sub2"

в .tlc Файл позволяет неявно ссылаться на любую подпапку:

%include "file_in_sub1.tlc"
%include "file_in_sub2.tlc"

Используйте косые черты для имен папок, так как они работают в обоих UNIX® и систем ПК. Однако, если вы используете обратные косые черты в именах папок ПК, не забудьте их избежать, например "C:\\mytlc". Кроме того, вы можете выразить имя папки PC как литерал с помощью спецификатора L формата, как в L"C:\mytlc".

%addincludepath

Использование %addincludepath "folder" чтобы добавить дополнительные пути для поиска. Несколько %addincludepath могут появиться директивы. Компилятор оценивает несколько %addincludepath директивы снизу вверх.

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

%addincludepath "./sub1"
%addincludepath "./sub2"

в .tlc Файл позволяет неявно ссылаться на любую подпапку:

%include "file_in_sub1.tlc"
%include "file_in_sub2.tlc"

Используйте косые черты для имен папок, так как они работают как в UNIX, так и в PC системах. Однако, если вы используете обратные косые черты в именах папок ПК, не забудьте их избежать, например "C:\\mytlc". Кроме того, вы можете выразить имя папки PC как литерал с помощью спецификатора L формата, как в L"C:\mytlc".

%roll
%endroll

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

Этот пример %roll директива предназначена для операции усиления, y=u*k:

%function Outputs(block, system) Output
  /* %<Type> Block: %<Name> */
  %assign rollVars = ["U", "Y", "P"]
  %roll sigIdx = RollRegions, lcv = RollThreshold, block,... 
        "Roller", rollVars
    %assign y = LibBlockOutputSignal(0, "", lcv, sigIdx)
    %assign u = LibBlockInputSignal(0, "", lcv, sigIdx)
    %assign k = LibBlockParameter(Gain, "", lcv, sigIdx)
      %<y> = %<u> * %<k>;
  %endroll
%endfunction

The %roll директива подобна %foreach, за исключением того, что он итерирует идентификатор (sigIdx в этом примере) по областям крена. Области крена вычисляются путем просмотра входных сигналов и генерирования областей, где входы смежны. Для блоков переменная RollRegions автоматически вычисляется и помещается в Block запись. Примером вектора областей крена является [0:19, 20:39], где существуют две смежные области значений сигналов, проходящих через блок. Первый из них 0:19 а второе - 20:39. Каждая область крена либо помещается в тело цикла (например, язык C for оператор) или встроенный, в зависимости от того, меньше ли длина области, чем порог крена.

Каждый раз через %roll цикл, sigIdx является целым числом для начала текущей области крена или смещением относительно полной ширины блока, когда текущая область крена меньше порога крена. Глобальная переменная TLC RollThreshold - общее значение всей модели, используемое, чтобы решить, когда поместить заданную область крена в цикл. Когда принято решение поместить заданную область в цикл, переменная управления циклом является допустимым идентификатором (например, "i"); в противном случае это "".

The block параметр является текущим блоком, который прокатывается. The "Roller" параметр задает имя для внутреннего GENERATE_TYPE вызовы, выполняемые %roll. Значение по умолчанию %roll обработчик "Roller", который отвечает за настройку блока по умолчанию цикла прокатных конструкций (например, C for цикл).

The rollVars (крен) передаются в "Roller" функции для создания структур крена. Заданные переменные цикла относительно блока

"U"

Входы в блок. Предполагается, что вы используете LibBlockInputSignal(portIdx, "", lcv, sigIdx) для доступа к каждому входу, где portIdx начинается с 0 для первого входного порта.

"u i"

Подобно "U", за исключением только определенного входа, i. The "u" должен быть строчным или будет интерпретирован как "U" выше.

"Y"

Выходные выходы блока. Предполагается, что вы используете LibBlockOutputSignal(portIdx, "", lcv, sigIdx) для доступа к каждому выходу, где portIdx начинается с 0 для первого выходного порта.

"y i"

Подобно "Y", за исключением определенного выхода, i. The "y" должен быть строчным или будет интерпретирован как "Y" выше.

"P"

Параметры блока. Это предполагает, что вы используете LibBlockParameter(name, "", lcv, sigIdx) для доступа к ним.

"< парам >/ name"

Подобно "P", за исключением конкретного name.

rwork

The RWork векторы блока. Это предполагает, что вы используете LibBlockRWork(name, "", lcv, sigIdx) для доступа к ним.

"< rwork >/ name"

Подобно RWork, за исключением определенного name.

dwork

The DWork векторы блока. Это предполагает, что вы используете LibBlockDWork(name, "", lcv, sigIdx) для доступа к ним.

"< dwork >/ name"

Подобно DWork, за исключением определенного name.

iwork

The IWork векторы блока. Это предполагает, что вы используете LibBlockIWork(name, "", lcv, sigIdx) для доступа к ним.

"< iwork >/ name"

Подобно IWork, за исключением определенного name.

pwork

The PWork векторы блока. Это предполагает, что вы используете LibBlockPWork(name, "", lcv, sigIdx) для доступа к ним.

"< свинина >/ name"

Подобно PWork, за исключением определенного name.

"Mode"

Вектор mode. Это предполагает, что вы используете LibBlockMode("",lcv,sigIdx) для доступа к нему.

"PZC"

Предыдущее состояние пересечения нулем. Это предполагает, что вы используете LibPrevZCState("",lcv, sigIdx) для доступа к нему.

Чтобы roll свой собственный вектор на основе областей крена блока, вам нужно пройти указатель на свой вектор. Предположим, что ваш вектор указан первым PWork, вызываемый name,

datatype *buf = (datatype*)%<LibBlockPWork(name,"","",0)
%roll sigIdx = RollRegions, lcv = RollThreshold, block, ...
      "Roller", rollVars
  *buf++ = whatever;
%endroll

Примечание: В приведенном выше примере sigIdx и lcv являются локальными по отношению к телу цикла.

%breakpoint

Устанавливает точку останова для отладчика TLC. См. Директива о точках останова%.

%function
%return
%endfunction

Функция, которая возвращает значение, определяется как

%function name(optional-arguments) 
    %return value 
  %endfunction

Функция void не выдает выход и не требуется возвращать значение. Он определяется как

%function name(optional-arguments) void 
  %endfunction

Функция, которая производит выходы текущего потока и не требуется для возврата значения, определяется как

%function name(optional-arguments) Output 
  %endfunction

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

%function BlockInstanceSetup(block,system) void

Вызывается для каждого образца блока в модели.

%function BlockTypeSetup(block,system) void

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

%function Enable(block,system) Output

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

%function Disable(block,system) Output

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

%function Start(block,system) Output

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

%function InitializeConditions(block,system) Output

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

%function Outputs(block,system) Output

Основная функция вашего блока. Место в MdlOutputs.

%function Update(block,system) Output

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

%function Derivatives(block,system) Output

Используйте эту функцию, если ваш блок имеет производные.

%function ZeroCrossings(block,system) Output

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

%function Terminate(block,system) Output

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

%foreach
%endforeach

Множественное включение, которое итерация из 0 на upperLimit-1 постоянное целочисленное выражение. Каждый раз через цикл, loopIdentifier, (например, x) назначается текущее значение итерации.

%foreach loopIdentifier = upperLimit 
   %break -- use this to exit the loop 
   %continue -- use this to skip the following code and  
                continue to the next iteration 
%endforeach

Примечание: The upperLimit выражение приведено к целому значению TLC. The loopIdentifier является локальным по отношению к телу цикла.

%for

Множественная директива включения с синтаксисом

%for ident1 = const-exp1, const-exp2, ident2 = const-exp3
  %body
    %break
    %continue
  %endbody
%endfor

Первый фрагмент %for директива идентична %foreach оператор. The %break и %continue директивы действуют так же, как и в %foreach директива. const-exp2 является логическим выражением, которое указывает, следует ли прокатывать цикл (см. %roll выше).

Если const-exp2 вычисляет, чтобы TRUE, ident2 присваивается значение const-exp3. В противном случае ident2 присваивается пустая строка.

Примечание: ident1 и ident2 выше являются локальными по отношению к корпусу цикла.

%openfile
%selectfile
%closefile

Они используются для управления созданными файлами. Синтаксис:

%openfile streamId="filename.ext" mode  {open for writing} 
%selectfile streamId                   {select an open file} 
%closefile streamId                     {close an open file}

Обратите внимание, что "filename.ext"необязательно. Если имя файла не задано, переменная (строковый буфер) с именем streamId создается, содержащая выходы. Аргумент mode необязателен. Если задано, это может быть "a" для добавления или "w" для письма.

Обратите внимание, что специальная строка streamIdNULL_FILE не задает выход. Специальная строка streamIdSTDOUT указывает выход на клемму.

Чтобы создать буфер текста, используйте

%openfile buffer
text to be placed in the 'buffer' variable.
%closefile buffer

Теперь buffer содержит расширенный текст, заданный между %openfile и %closefile директивы.

%generate

%generate blk fn эквивалентно GENERATE(blk, fn).

%generate blk fn type эквивалентно GENERATE(blk, fn, type).

Смотрите GENERATE и GENERATE_TYPE функции.

%undef

% undef var удаляет переменную var из возможностей. Если var является полем в записи, %undef удаляет это поле из записи. Если var является массивом записей, %undef удаляет весь массив записей.

Комментарии

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

/%
    Abstract:    Return the field with [width], if field is wide
%/

или

%endfunction %% Outputs function

Используйте %% конструкция для строчных комментариев. Символы из %% в конец линии стать комментарием.

Не-директивные линии, то есть линии, которые не имеют % как их первый непустой символ, копируются в выход буфер дословно. Для примера,

/* Initialize sysNumber */
int sysNumber = 3;

копирует обеих линии в выходной буфер.

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

Примечание

Если в функции появляется не директивная линия, она не копируется в выход буфер, если функция не является выходной функцией или вы специально выбираете выход файл с помощью %selectfile директива. Для получения дополнительной информации о функциях смотрите Функции целевого языка.

Продолжение линии

Можно использовать язык C \ символ или последовательность MATLAB ... для продолжения линии. Если директива слишком длинная, чтобы удобно помещаться в одной линии, это позволяет вам разделить директиву на несколько линии. Для примера:

%roll sigIdx = RollRegions, lcv = RollThreshold, block,\ 
      "Roller", rollVars

или

%roll sigIdx = RollRegions, lcv = RollThreshold, block,... 
      "Roller", rollVars

Примечание

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

Типы значений на целевом языке

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

Строка типа значенияПример Описание

"Boolean"

1==1

Результат сравнения или другого логического оператора. Результат будет TLC_TRUE или TLC_FALSE.

"Complex"

3.0+5.0i

64-битное комплексное число двойной точности (double на целевой машине).

"Complex32"

3.0F+5.0Fi

32-битное комплексное число с одной точностью (float на целевой машине).

"File"

%openfile x

Строковый буфер, открытый с %openfile.

"File"%openfile x = "out.c"

Файл открыт с %openfile.

"Function"

%function foo...

Определяемые пользователем функция и TLC_FALSE в противном случае.

"Gaussian"

3+5i

32-битное целочисленное мнимое число (int на целевой машине).

"Identifier"abc

Значения идентификаторов могут появляться только в model.rtw файл и не может появляться в выражениях (в контексте выражения идентификаторы интерпретируются как значения). Чтобы сравнить со значением идентификатора, используйте строку; идентификатор будет преобразован в строку.

"Matrix"

Matrix (3,2) [ [ 1, 2]; [3 , 4]; [ 5, 6] ]

Матрицы являются просто списками векторов. Отдельные элементы матрицы не должны быть совпадающими типами и могут быть любым поддерживаемым типом, кроме векторов или матриц. The Matrix (3,2) текст в примере необязателен.

"Number"

15

Целое число (int на целевой машине).

"Range"

[1:5]

Область значений целых чисел от 1 до 5 включительно.

"Real"3.14159

Число с плавающей запятой (double на целевой машине), включая экспоненциальное обозначение.

"Real32"

3.14159F

32-битное одноточное число с плавающей запятой (float на целевой машине).

"Scope"

Block { ... }

Блокируйте запись.

"Special"

FILE_EXISTS

Специальная встроенная функция, такая как FILE_EXISTS.

"String"

"Hello, World"

Символьные строки ASCII. Во всех контекстах две строки в строке объединяются, чтобы сформировать окончательное значение, как в "Hello, " "World", который объединяется в форму "Hello, World". Эти строки включают ANSI® Стандартные эвакуационные последовательности C, такие как \n, \r, \t, и т.д. Использование символов продолжения линии (т.е. \ и ...) внутри строк недопустимо.

"Subsystem"

<sub1>

Идентификатор подсистемы. В контексте расширения будьте осторожны, чтобы избежать разделителей на идентификаторе подсистемы, как в %<x == <sub\>>.

«Неподписанный»

15U

32-битное беззнаковое целое число (unsigned int на целевой машине).

"Unsigned Gaussian"

3U+5Ui

32-битное комплексное беззнаковое целое число (unsigned int на целевой машине).

"Vector"

[1, 2] or BR Vector(2) [1, 2]

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

Выражения на целевом языке

Вы можете включить выражение формы % < expression> в целевом файле. Целевой компилятор языка заменяет% < expression> с вычисленным значением замены на основе типа переменных в %<> оператор. Целочисленные выражения константы складываются и заменяются результирующим значением; строковые константы конкатенируются (например, две строки в строке "a" "b", заменяются на "ab").

%<expression>                /* Evaluates the expression.  
  * Operators include most standard C
  * operations on scalars. Array indexing
  * is required for certain parameters that 
  * are block-scoped within the .rtw file.*/

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

%<x \> 1 ? "ABC" : "123">

Операторы, которым нужен > символа, от которого нужно избежать, являются следующими:

ОператорОписаниеПример
>

больше, чем

y = %<x \> 2>;
>=

больше или равно

y = %<x \>= 3>;
>>

правый сдвиг

y = %<x \>\> 4>;

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

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

%if EXISTS(foo) && foo == 3

Если первый член выражения вычисляется как Boolean false (т.е. foo не существует), второй термин (foo == 3) не оценивается.

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

  • Boolean

  • Number

  • Unsigned

  • Real

  • Real32

  • Complex

  • Complex32

  • Gaussian

  • UnsignedGaussian

Кроме того, обратите внимание, что integral является одним из следующих:

  • Number

  • Unsigned

  • Boolean

Для получения информации об рекламных акциях, которые происходят при работе компилятора целевого языка с смешанными типами выражений, см. раздел «Рекламные акции Данных TLC».

Выражения на целевом языке

Выражение

Определение

constant

Постоянное значение параметров. Значение может быть вектором или матрицей.

variable-name

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

::variable-name

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

expr[expr]

Индекс в параметр массива. Индексы массива варьируются от 0 на N-1. Этот синтаксис используется для индекса в векторы, матрицы и повторные переменные возможности.

expr([expr[,expr]...])

Вызов функции или расширение макроса. Выражение вне круглых скобок является именем функции/макроса; выражения внутри являются аргументами в функции или макросе.

Примечание: Макросы основаны на тексте; они не могут использоваться в том же выражении, что и другие операторы.

expr . expr

Первое выражение должно иметь допустимые возможности; второе выражение является именем параметра в этих возможностях.

(expr)

Использование () для переопределения приоритета операций.

!expr

Логическое отрицание (генерирует TLC_TRUE или TLC_FALSE). Аргумент должен быть числовым или логическим.

-expr

Унарный минус отменяет выражение. Аргумент должен быть числовым.

+expr

Эффекта нет; операнд должен быть числовым.

~expr

Битовое отрицание операнда. Аргумент должен быть целым числом.

expr * expr

Умножает два выражения: операнды должны быть числовыми.

expr / expr

Разделяет два выражения: операнды должны быть числовыми.

expr % expr

Принимает целое число по модулю выражений; операнды должны быть целыми числами.

expr + expr

Работает с числовыми типами, строками, векторами, матрицами и записями следующим образом:

Числовые типы: Добавить два выражения; операнды должны быть числовыми.

Строки: Строки сцеплены.

Векторы: Если первый аргумент является вектором, а второй - скаляром, скаляр присоединяется к вектору.

Матрицы: Если первый аргумент является матрицей, а второй - вектором той же ширины столбца, что и матрица, вектор добавляется как другая строка в матрице.

Записи: Если первый аргумент является записью, второй аргумент добавляется как идентификатор параметра (с его текущим значением).

Обратите внимание, что оператор сложения является ассоциативным.

expr - expr

Вычитает два выражения: операнды должны быть числовыми.

expr << expr

Смещает слева операнд на величину, равную правому операнду; аргументы должны быть целыми числами.

expr >> expr

Правый сдвиг левого операнда на величину, равную правому операнду; аргументы должны быть целыми числами.

expr > expr

Проверяет, больше ли первое выражение, чем второе выражение; аргументы должны быть числовыми.

expr < expr

Проверяет, меньше ли первое выражение, чем второе выражение; аргументы должны быть числовыми.

expr >= expr

Проверяет, больше ли первое выражение, чем второе выражение или равно ему; аргументы должны быть числовыми.

expr <= expr

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

expr == expr

Проверяет, равны ли эти два выражения.

expr != expr

Проверяет, не равны ли эти два выражения.

expr & expr

Выполняет битовое И из двух аргументов; аргументы должны быть целыми числами.

expr ^ expr

Выполняет битовое XOR из двух аргументов; аргументы должны быть целыми числами.

expr | expr

Выполняет двоичное ИЛИ из двух аргументов; аргументы должны быть целыми числами.

expr && expr

Выполняет логическое И из двух аргументов и возвращает TLC_TRUE или TLC_FALSE. Это может использоваться в числовых или логических аргументах.

expr || expr

Выполняет логическое ИЛИ двух аргументов и возвращает TLC_TRUE или TLC_FALSE. Это может использоваться в числовых или логических аргументах.

expr ? expr : expr

Проверяет первое выражение на TLC_TRUE. Если true, возвращается первое выражение; в противном случае возвращается второе выражение.

expr , expr

Возвращает значение второго выражения.

Примечание

Реляционные операторы (<, =<, >, >=, !=, == ) может использоваться с нефинитными значениями.

Вы не должны помещать выражения в %< > eval формат, когда они появляются в директивных линиях. Это приводит к двойной оценке.

Продвижение данных TLC

Когда Target Language Compiler работает с смешанными типами выражений, он продвигает результаты к общим типам, указанным в следующей таблице.

В таблице используются следующие сокращения:

B

Булев

N

Число

U

Неподписанный

F

Real32

D

Реальный

G

Гауссовский

UG

UnsignedGaussian

C32

Complex32

C

Комплекс

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

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

Типы данных, полученные из выражений смешанного типа

 BNUFDGUGC32C
BBNUFDGUGC32C
NNNUFDGUGC32C
UUUUFDUGUGC32C
FFFFFDC32C32C32C
DDDDDDCCCC
GGGUGC32CGUGC32C
UGUGUGUGC32CUGUGC32C
C32C32C32C32C32CC32C32C32C
CCCCCCCCCC

Форматирование

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

%realformat string

Если string является "EXPONENTIAL"используется стандартное экспоненциальное обозначение с 16 цифрами точности. Если string является "CONCISE"компилятор использует внутреннюю эвристику, чтобы вывести значения в более читаемой форме с сохранением точности. The %realformat директива устанавливает формат по умолчанию для Real выход числа в выбранный стиль для оставшейся части обработки или до тех пор, пока он не встретится с другим %realformat директива.

Условное включение

Условные директивы включения:

%if constant-expression
%else
%elseif constant-expression
%endif

%switch constant-expression
%case constant-expression
%break
%default
%endswitch

%, если

The constant-expression необходимо вычислить целочисленное выражение. Он управляет включением следующих линий, пока не встретится со %else, %elseif, или %endif директива. Если на constant-expression вычисляет, чтобы 0, следующие линии директивы не включены. Если на constant-expression вычисляет целое значение, отличное от 0, следующими линиями %if директива включаются до тех пор, пока %endif, %elseif, или %else директива.

Когда компилятор встречается с %elseif директива, и никаких предварительных %if или %elseif директива была оценена как ненулевая, компилятор оценивает выражение. Если значение 0, линии, следующие за %elseif директива не включена. Если значение ненулевое, линии, следующие за %elseif директива включается до следующих %else, %elseif, или %endif директива.

The %else директива начинает включать исходный текст, если предыдущий %elseif операторы или исходные %if оператор вычисляет 0; в противном случае он препятствует включению последующих линий вплоть до следующих %endif.

The constant-expression может содержать любое выражение, заданное в выражениях на целевом языке.

% switch

The %switch оператор оценивает постоянное выражение и сравнивает его с выражениями, появляющимися на %case селекторы. Если найдено совпадение, тело %case включено; в противном случае %default включено.

%case ... %default тела течут вместе, как в C, и %break должен использоваться для выхода из оператора switch. %break выходит из ближайшего ограждающего %switch, %foreach, или %for цикл, в котором он появляется. Для примера,

%switch(type)
%case x         
	/* Matches variable x. */
	/* Note: Any valid TLC type is allowed. */
%case "Sin"
	/* Matches Sin or falls through from case x. */
   %break
	/* Exits the switch. */
%case "gain"
	/* Matches gain. */
   %break
%default
	/* Does not match x, "Sin," or "gain." */
%endswitch

В целом это более читаемая форма для %if/%elseif/%else конструкция.

Множественное включение

% foreach

Синтаксис %foreach несколько директивы включения является

%foreach identifier = constant-expression
   %break
   %continue
%endforeach

The constant-expression необходимо вычислить целочисленное выражение, которое затем определяет количество раз, чтобы выполнить foreach цикл. The identifier шаги от 0 на единицу меньше заданного числа. В пределах foreach цикл, можно использовать x, где x - идентификатор для доступа к переменной идентификатора. %break и %continue являются необязательными директивами, которые можно включить в %foreach директива:

  • Использование %break выход из ближайшего ограждающего %for, %foreach, или %switch оператор.

  • Использование %continue чтобы начать следующую итерацию цикла.

% для

Примечание

The %for директива является функциональной, но она не рекомендуется. Вместо этого используйте %roll, который обеспечивает ту же возможность более открытым способом. Генератор кода не использует %for конструировать.

Синтаксис %for несколько директивы включения является

%for ident1 = const-exp1, const-exp2, ident2 = const-exp3
  %body
    %break
    %continue
  %endbody
%endfor

Первый фрагмент %for директива идентична %foreach оператор в том, что он заставляет цикл выполняться из 0 на N-1 время по телу цикла. В нормальном случае он включает только линии между %body и %endbody, и линии между %for и %body, и игнорирует линии между %endbody и %endfor.

The %break и %continue директивы действуют так же, как и в %foreach директива.

const-exp2 является логическим выражением, которое указывает, следует ли прокатывать цикл. Если const-exp2 верно, ident2 получает значение const-exp3; в противном случае она получает нулевую строку. Когда цикл прокатывается, линии между %for и %endfor включены в выход только один раз. ident2 определяет идентификатор, который будет использоваться для проверки, был ли цикл прокатан в теле. Для примера,

%for Index = <NumNonVirtualSubsystems>3, rollvar="i"

    {
        int i;

        for (i=0; i< %<NumNonVirtualSubsystems>; i++)
        {
          %body
	x[%<rollvar>] = system_name[%<rollvar>];
          %endbody

        }
    }
%endfor

Если количество невиртуальных подсистем (NumNonVirtualSubsystems) больше или равно 3, цикл прокатывается, в результате чего код в цикле генерируется точно один раз. В этом случае Index = 0.

Если цикл не прокатывается, текст до и после тела цикла игнорируется, и тело генерируется NumNonVirtualSubsystems времени.

Этот механизм дает каждому отдельному циклу контроль над тем, следует ли его катить или нет.

% крен

Синтаксис файла %roll несколько директивы включения является

%roll ident1 = roll-vector-exp, ident2 = threshold-exp, ... 
               block-exp [, type-string [,exp-list] ]
  %break
  %continue
%endroll

Этот оператор использует roll-vector-exp для расширения тела %roll оператор несколько раз, как в %foreach оператор. Если область значений предусмотрена в roll-vector-expи эта область значений больше, чем threshold-exp выражение, цикл будет рулонным. Когда цикл катится, тело цикла расширяется один раз и идентификатор (ident2) для порогового выражения задано имя переменной управления циклом. Если ни одна область значений не превышает заданный порог качения, этот оператор идентичен %foreach оператор. Для примера,

%roll Idx = [ 1 2 3:5, 6, 7:10 ], lcv = 10, ablock
%endroll

В этом случае тело %roll оператор расширяется в 10 раз, как в %foreach оператор, поскольку нет областей, больше или равных 10. Idx счетчики от 1 до 10, и lcv установлено значение null string, "".

Когда Target Language Compiler определяет, что данный блок будет рулонным, он выполняет GENERATE_TYPE вызов функции для вывода различных частей цикла (кроме тела). Используемый тип по умолчанию Roller; можно переопределить этот тип заданной строкой. Дополнительные аргументы переданы в %roll оператор предоставляется в качестве аргументов этим специальным функциям. Вызываемая функция является одной из следующих четырех функций:

RollHeader(block, ...).  Эта функция вызывается один раз на первом участке этого вектора крена, который фактически будет вращаться. Она должна вернуть строку, которая назначена lcv в теле %roll оператор.

LoopHeader(block, StartIdx, Niterations, Nrolled, ...).  Эта функция вызывается один раз для каждого раздела, который будет вращаться перед телом %roll оператор.

LoopTrailer(block, Startidx, Niterations, Nrolled, ...).  Эта функция вызывается один раз для каждого раздела, который будет вращаться после тела %roll оператор.

RollTrailer(block, ...).  Эта функция вызывается один раз в конце %roll оператор, если любой из областей значений вызвал прокат цикла.

Эти функции должны выводить объявления конкретного языка, циклический код и так далее, как требуется для генерации кода для цикла.

Пример Roller.tlc файл имеет вид

%implements Roller "C"
%function RollHeader(block) Output
	{
		int i;
	%return ("i")
%endfunction
%function LoopHeader(block,StartIdx,Niterations,Nrolled) Output
 	for (i = %<StartIdx>; i < %<Niterations+StartIdx>; i++)
	{
%endfunction
%function LoopTrailer(block,StartIdx,Niterations,Nrolled) Output
	}
%endfunction
%function RollTrailer(block) Output
	}
%endfunction

Примечание

Библиотека функций Target Language Compiler, поставляемая с генератором кода, имеет возможность извлечь ссылки на блок ввод-вывод и другие векторы генератора кода, которые значительно упрощают тело %roll оператор. Эти функции включают LibBlockInputSignal, LibBlockOutputSignal, LibBlockParameter, LibBlockRWork, LibBlockIWork, LibBlockPWork, LibDeclareRollVars, LibBlockMatrixParameter, LibBlockParameterAddr, LibBlockContinuousState, и LibBlockDiscreteState. (См. справочные страницы Функции входного сигнала, Функции выходного сигнала, Функции параметра, и Состояния блока и Функции рабочего вектора.) Эта библиотека также включает в себя реализацию по умолчанию Roller.tlc в виде «плоского» ролика.

Расширение предыдущего примера до цикла, который вращается,

%language "C"
%assign ablock = BLOCK { Name "Hi" }
%roll Idx = [ 1:20, 21, 22, 23:25, 26:46], lcv = 10, ablock
	Block[%< lcv == "" ? Idx : lcv>] *= 3.0;
%endroll

Этот код компилятора целевого языка создает следующие выходы:

{
	int             i;
	for (i = 1; i < 21; i++)
	{
	    Block[i] *= 3.0;
	}
	Block[21] *= 3.0;
	Block[22] *= 3.0;
	Block[23] *= 3.0;
	Block[24] *= 3.0;
	Block[25] *= 3.0;
	for (i = 26; i < 47; i++)
	{
	    Block[i] *= 3.0;
	}
}

Объектно-ориентированная среда для генерации целевого кода

Компилятор целевого языка предоставляет простое объектно-ориентированное средство. Языковые директивы:

%language string
%generatefile
%implements

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

% язык

The %language директива определяет генерируемый целевой язык. В качестве проверки согласованности необходимо проверить файлы реализации, найденные для создаваемого языка. The %language директива должна появиться до первой GENERATE или GENERATE_TYPE встроенная функция. %language задает язык как строку. Для примера:

%language "C"

Блоки Simulink имеют Type параметр. Этот параметр является строкой, которая задает тип блока, например "Sin" или "Gain". Объектно-ориентированное средство использует этот тип для поиска пути к файлу, который реализует блок. По умолчанию имя файла Type блока с .tlc добавлено, например, если Type является "Sin" компилятор искал бы "Sin.tlc" вдоль пути. Вы можете переопределить это имя файла по умолчанию, используя %generatefile директива для указания имени файла, которое необходимо использовать для замены имени файла по умолчанию. Для примера,

%generatefile "Sin" "sin_wave.tlc"

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

%implements "Sin" "Pascal"

вызывает ошибку, если начальный выбор языка был C.

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

%implements "Sin" "C"

Наконец, можно реализовать несколько типов с помощью подстановочного знака (*) для поля type:

%implements * "C"

Примечание

Использование подстановочного знака (*) не рекомендуется, потому что он расслабляет проверку ошибок для %implements директива.

СГЕНЕРИРУЙТЕ и GENERATE_TYPE функции

Target Language Compiler имеет две встроенные функции, которые отправляют объектно-ориентированные вызовы, GENERATE и GENERATE_TYPE. Вы можете вызвать функцию, появляющуюся в файле реализации (из-за пределов указанного файла), только используя GENERATE и GENERATE_TYPE специальные функции.

СГЕНЕРИРУЙТЕ.   GENERATE функция принимает два или более входные параметры. Первый аргумент должен быть допустимыми возможностями, а второй - строкой, содержащей имя функции. GENERATE функция передает первый аргумент блока и любые дополнительные аргументы, заданные вызываемой функции. Возвращаемым аргументом является значение, если оно имеется, возвращаемое вызываемой функцией. Обратите внимание, что компилятор автоматически «просматривает» или добавляет первый аргумент в список возможностей, как если бы он появился на %with директивная линия. (См. Раздел «Область переменных».) Эти возможности удаляются, когда функция возвращается.

GENERATE_TYPE.   GENERATE_TYPE функция принимает три или более входные параметры. Он обрабатывает первые два аргумента аналогично GENERATE вызов функции. Третьим аргументом является тип; тип, заданный в блоке Simulink, игнорируется. Это средство используется для обработки генерации кода S-функции процессом сборки. То есть тип блока S-function, но Target Language Compiler генерирует его как конкретную S-функцию, заданную как GENERATE_TYPE. Для примера,

GENERATE_TYPE(block, "Output", "dp_read")

задает, что S-функция block имеет тип dp_read.

The block аргумент и любые дополнительные аргументы передаются вызываемой функции. Как и GENERATE встроенная функция, компилятор автоматически масштабирует первый аргумент перед GENERATE_TYPE функция вводится, а затем удаляет возможности после возврата.

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

Примечание

Это не ошибка для GENERATE и GENERATE_TYPE директивы, чтобы не найти совпадающих функций. Это должно предотвратить требование пустых спецификаций для всех аспектов генерации блочного кода. Используйте GENERATE_FUNCTION_EXISTS или GENERATE_TYPE_FUNCTION_EXISTS директивы, чтобы определить, существует ли указанная функция на самом деле.

Выход файлом

Структура выхода управления файлами конструкции

%openfile string optional-equal-string optional-mode
%closefile id
%selectfile id

% openfile

The %openfile директива открывает файл или буфер для записи; необходимая строковая переменная становится переменной типа file. Для примера,

%openfile x               /% Opens and selects x for writing. %/
%openfile out = "out.h"   /% Opens "out.h" for writing. %/

% selectfile

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

%selectfile x               /% Select file x for output. %/

% closefile

The %closefile директива закрывает указанный файл или буфер. Если закрытая сущность является текущим выбранным выходным потоком, %closefile вызывает %selectfile для повторного выбора ранее выбранного выходного потока.

Существует два возможных случая, которые %closefile необходимо обработать:

  • Если поток является файлом, связанная переменная удаляется как если бы %undef.

  • Если поток является буфером, связанная переменная получает текст, который был выведен в поток. Для примера,

    %assign x = ""                 /% Creates an empty string. %/
    %openfile x
    "hello, world"
    %closefile x		 /% x = "hello, world\n"%/

При желании можно добавить к файлу выхода или строке с помощью опционального режима, a, как в

%openfile "foo.c", "a"             %% Opens foo.c for appending.

Вход файлом

Директивы управления входным файлом:

%include string
%addincludepath string

% включают

The %include директива ищет путь к целевому файлу, заданному string и включает содержимое файла в строке в точке, где %include появляется оператор.

% addincludepath

The %addincludepath директива добавляет дополнительный путь включения для поиска при ссылках на компилятор целевого языка %include или блокировать целевые файлы. Синтаксис:

%addincludepath string

The string может быть абсолютным или явным относительным путем. Для примера, чтобы задать абсолютный путь, используйте

%addincludepath "C:\\folder1\\folder2"     (PC)
%addincludepath "/folder1/folder2"         (UNIX)

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

%addincludepath ".\\folder2"                  (PC)
%addincludepath "./folder2"                   (UNIX)

Обратите внимание, что для ПК обратные косые черты должны быть устранены (удвоены).

Когда задан явный относительный путь, папка, которая добавляется в путь поиска файлов Target Language Compiler, создается путем конкатенации местоположения целевого файла, содержащего %addincludepath директива и явный относительный путь.

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

  1. Текущая папка.

  2. Включите пути, указанные в %addincludepath директивы. Компилятор оценивает несколько %addincludepath директивы снизу вверх.

  3. Включите пути, заданные в командной строке через -I . Компилятор оценивает несколько -I опции справа налево.

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

Примечание

Компилятор не ищет путь MATLAB и не найдет файл, доступный только по этому пути. Компилятор ищет только местоположения, описанные выше.

Утверждения, ошибки, предупреждения и отладочные сообщения

Соответствующие директивы assert, error, warning и debug message:

%assert expression
%error tokens
%warning tokens
%trace tokens
%exit tokens

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

Компилятор целевого языка помещает сообщения, сгенерированные %trace на stderr если и только если вы задаете переключатель с подробным режимом (-v) к целевому языковому компилятору. Дополнительные сведения о коммутаторах см. в разделе Аргументы командной строки.

The %assert директива оценивает выражение и создает трассировку стека, если выражение вычисляется как логическое false.

Примечание

В порядке %assert директивы, которые будут оценены, Enable TLC assertion должны быть выбраны в TLC process разделе панели Code Generation > Debug. Действие по умолчанию предназначено для %assert директивы, которые не должны быть оценены.

The %exit директива сообщает об ошибке и останавливает дальнейшую компиляцию.

Встроенные функции и значения

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

Встроенные функции и значения TLC

Имя встроенной функцииРасширение

CAST(expr, expr)

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

CAST("Real", variable-name) 

Примером этого является работа со значениями параметров для S-функций. Чтобы использовать их в код C or C++, необходимо набрать их, чтобы real так что значение, такое как 1 будет отформатировано следующим 1.0 (см. также %realformat).

EXISTS(var)

Если на var идентификатор в данный момент не находится в возможностях, результат TLC_FALSE. Если идентификатор находится в возможностях, результат следующий TLC_TRUE. var может быть одним идентификатором или выражением с участием . и [] операторы.

FEVAL(matlab-command,
   TLC-expressions)

Выполняет оценку в MATLAB. Для примера,

%assign result = FEVAL("sin",3.14159)

The %matlab директива может использоваться для вызова функции MATLAB, которая не возвращает результат. Для примера,

%matlab disp(2.718)

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

FILE_EXISTS(expr)

expr должна быть строкой. Если файл по имени expr не существует на пути, результатом является TLC_FALSE. Если файл с таким именем существует в пути, результат следующий TLC_TRUE.

FORMAT(realvalue, format)

Первое выражение является Real значение в формате. Второе выражение либо EXPONENTIAL или CONCISE. Выводит Real значение в обозначенном формате, где EXPONENTIAL использует экспоненциальное обозначение с 16 цифрами точности и CONCISE выводит число в более читаемом формате с сохранением числовой точности.

FIELDNAMES(record)

Возвращает массив строк, содержащий имена полей записей, сопоставленных с записью. Поскольку он возвращает отсортированный список строк, функция O(n*log(n)).

GETFIELD(запись,
   «имя поля»
)

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

GENERATE(record,
    function-name, ...)

Выполняет вызовы функций, сопоставленные с определенным типом записи (то есть с функциями записи блоков). Для примера используйте это для выполнения функций в .tlc файлы для встроенных блоков. Не то, чтобы TLC автоматически «просматривал» или добавлял первый аргумент в список возможностей, как если бы он появился на %with директивная линия.

GENERATE_FILENAME(type)

Для заданного типа записи делает .tlc файл существует? Используйте это, чтобы увидеть, GENERATE_TYPE ли вызов будет успешным.

GENERATE_FORMATTED_VALUE
   (expr, string, expand)

Возвращает потенциально многострочную строку, которая может использоваться, чтобы объявить значение (значения) expr на текущем целевом языке. Второй аргумент является строкой, которая используется в качестве имени переменной в описательном комментарии к первой линии возврата строки. Если второй аргумент является пустой строкой, "", тогда никакой описательный комментарий не помещается в выход строку. Третий аргумент является логическим, что когда TRUE причины expr будет развернут в необработанный текст перед выводом. expand = TRUE использует гораздо больше памяти, чем по умолчанию (FALSE); установите expand = TRUE только в том случае, если текст параметра необходимо обработать по какой-либо причине перед записью на диск.

Для примера,

static const unsigned char contents[] =

%assign value = GENERATE_FORMATTED_VALUE(SFcnParamSettings.CONTENTS, "", TLC_FALSE)

;

приводит к следующему коду С:

static const unsigned char contents[] = { 0U, 1U, 2U, 3U, 4U };

GENERATE_FUNCTION_EXISTS
   (record, function-name)

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

GENERATE_TYPE
   (запись, имя функции,
   тип ,...)

Подобно GENERATE, кроме того type переопределяет Type поле записи. Используйте это при выполнении функций, сопоставленных с конкретными записями блоков s-function на основе имени S-функции (т.е. имя становится типом).

GENERATE_TYPE_FUNCTION_EXISTS
   (запись, имя функции,
   тип)

То же, что и GENERATE_FUNCTION_EXISTS кроме того, что он переопределяет Type встроенный в запись.

GET_COMMAND_SWITCH

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

v, m, p, O, d, dr, r, I, a
См. также Аргументы в командной строке.

IDNUM(expr)

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

IDNUM("ABC123") приводит к ["ABC", 123]

IMAG(expr)

Возвращает мнимую часть комплексного числа.

INT8MAX

127

INT8MIN

-128

INT16MAX

32767

INT16MIN

-32768

INT32MAX

2147483647

INT32MIN

-2147483648

INTMIN

Минимальное целое значение на хост-машине.

INTMAX

Максимальное целое значение на хост-машине.

ISALIAS(record)

Возвращает TLC_TRUE если запись является ссылкой (символьной ссылкой) на другую запись, и TLC_FALSE в противном случае.

ISEQUAL(expr1, expr2)

Где типы данных обоих выражений числовые: возвращает TLC_TRUE если первое выражение содержит то же значение, что и второе выражение; возвращает TLC_FALSE в противном случае.

Где тип данных любого выражения является нечисловым (например, строка или запись): возвращает TLC_TRUE если и только если оба выражения имеют совпадающий тип данных и содержат одно и то же значение; возвращает TLC_FALSE в противном случае.

ISEMPTY(expr)

Возвращает TLC_TRUE если выражение содержит пустую строку, вектор или запись и TLC_FALSE в противном случае.

ISFIELD(record, "fieldname")

Возвращает TLC_TRUE если имя поля связано с записью, и TLC_FALSE в противном случае.

ISINF(expr)

Возвращает TLC_TRUE если значение выражения inf, и TLC_FALSE в противном случае.

ISNAN(expr)

Возвращает TLC_TRUE если значение выражения NAN, и TLC_FALSE в противном случае.

ISFINITE(expr)

Возвращает TLC_TRUE если значение выражения не +/- inf или NAN, и TLC_FALSE в противном случае.

ISSLPRMREF(param.value)

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

%if !ISSLPRMREF(param.Value) 
  assign param.Value = CAST("Real", param.Value) 
%endif

NULL_FILE

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

NUMTLCFILES

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

OUTPUT_LINES

Возвращает количество линий, записанных в текущий выбранный файл или буфер. Не работает на STDOUT или NULL_FILE.

REAL(expr)

Возвращает действительную часть комплексного числа.

REMOVEFIELD(record, "fieldname")

Удаляет указанное поле из содержимого записи. Возвращает TLC_TRUE если поле было удалено; в противном случае возвращается TLC_FALSE.

ROLL_ITERATIONS()

Возвращает количество циклов или NULL текущих областей крена если не внутри %roll конструировать.

SETFIELD(record, "fieldname", value)

Устанавливает содержимое имени поля, связанного с записью. Возвращает TLC_TRUE если поле было добавлено; в противном случае возвращается TLC_FALSE.

SIZE(expr[,expr])

Вычисляет размер первого выражения и генерирует двухэлементный вектор-строку. Если задан второй операнд, он используется как целочисленный индекс в этот вектор-строку; в противном случае возвращается весь вектор-строка. SIZE(x) применяется к скалярным возвращениям [1 1]. SIZE(x) , примененный к возможностям, возвращает количество повторяющихся записей этого типа возможностей. Для примера, SIZE(Block) возвраты

[1,<number of blocks>]

SPRINTF(format,var,...)

Форматирует данные в переменных var (и в любых дополнительных аргументах переменной) под управлением указанной строки формата и возвращает строковую переменную, содержащую значения. Работает как библиотека C sprintf(), за исключением того, что выход является возвратом значением, а не содержится в аргументе, sprintf.

STDOUT

Предопределенный файл для stdout выход. Вы можете использовать это как аргумент для %selectfile для принудительного выхода в stdout.

STRING(expr)

Расширяет выражение в строку; символы \, \n, и " спасаются, предшествуя им с \ (обратная косая черта). Escape-последовательности ANSI переведены в строковую форму. Если %<> это в выражении, оно избегается так, что заключенная строка не подлежит дальнейшей интерпретации TLC.

STRINGOF(expr)

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

SYSNAME(expr)

Ищет специально отформатированные строки формы <x>/y и возвращает x и y как двухэлементный строковый вектор. Это используется для разрешения имен подсистем. Для примера,

%<sysname("<sub>/Gain")>

возвраты

["sub","Gain"]

В Block записи, имя блока записывается < sys/ blockname >, где sys является S# или Root. Вы можете получить полное имя пути, позвонив LibGetBlockPath(block); это будет включать новые строки и другие неприятные символы, которые вызывают трудности отображения. Чтобы получить полное имя пути, подходящее для однострочных комментариев, но не идентичное имени пути Simulink, используйте LibGetFormattedBlockPath(block).

TLCFILES

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

TLC_FALSE

Логическая константа, которая равна отрицательному вычисленному логическому выражению.

TLC_TRUE

Логическая константа, которая равна положительному вычисленному логическому выражению.

TLC_TIME

Дата и время компиляции.

TLC_VERSION

Версия и дата компилятора целевого языка.

TYPE(expr)

Оценивает expr и определяет тип результата. Результатом этой функции является строка, которая соответствует типу заданного выражения. Для получения возможных значений см. столбец Строки Value Type в таблице Target Language Value Types.

UINT8MAX

255U

UINT16MAX

65535U

UINT32MAX

4294967295U

UINTMAX

Максимальное беззнаковое целое значение на хост-машине.

WHITE_SPACE(expr)

Принимает строку и возвращает 1, если строка содержит только пустые символы ( , \t, \n, \r); возвращает 0 в противном случае.

WILL_ROLL(expr1, expr2)

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

Функция FEVAL

FEVAL встроенная функция вызывает файловые функции MATLAB и MEX-функции. Структура:

%assign result = FEVAL( matlab-function-name, rhs1, rhs2, ... 
	rhs3, ... );

Примечание

  • При использовании допускается использование только одного левого аргумента FEVAL.

  • Если оценка функции MATLAB приводит к ошибке, компилятор не завершает работу, но продолжает выполнение. Директива FEVAL возвращает пустое значение в TLC.

В этой таблице показаны преобразования, которые делаются при использовании FEVAL.

Преобразования MATLAB

Тип TLCТип MATLAB
"Boolean"Boolean (скаляр или матрица)
"Number"Double (скаляр или матрица)
"Real"Double (скаляр или матрица)
"Real32"Double (скаляр или матрица)
"Unsigned"Double (скаляр или матрица)
"String"String
"Vector"Если вектор однороден, он преобразуется в вектор MATLAB. Если вектор неоднороден, он преобразуется в массив ячеек MATLAB.
"Gaussian"Complex (скаляр или матрица)
"UnsignedGaussian"Complex (скаляр или матрица)
"Complex"Complex (скаляр или матрица)
«Complex32"Complex (скаляр или матрица)
"Identifier"String
"Subsystem"String
"Range"Расширенный вектор Doubles
"Idrange"Расширенный вектор Doubles
"Matrix"Если матрица однородна, она преобразуется в матрицу MATLAB. Если матрица неоднородна, она преобразуется в массив ячеек MATLAB. (Массивы ячеек могут быть вложенными.)
"Scope" или "Record"Структура с элементами
Scope или Record псевдонимСтрока , содержащая полное имя псевдонима
Scope или Record массивМассив ячеек структур
Другой тип, не указанный вышеПреобразование не поддерживается

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

Больше преобразований

Тип MATLABТип TLC
String String
Vector of Strings

Вектор строк

Boolean (scalar or matrix)Boolean (скаляр или матрица)
INT8, INT16, INT32
(скаляр или матрица)
Number (скаляр или матрица)
INT64Не поддерживается
UINT64Не поддерживается
Комплексные INT8,INT16,INT32
(скаляр или матрица)
Гауссов (скаляр или матрица)
UINT8, UINT16, UINT32
(скаляр или матрица)
Unsigned (скаляр или матрица)
Комплексные UINT8,UINT16,UINT32
(скаляр или матрица)
UnsignedGaussian (скаляр или матрица)
Single precisionReal32 (скаляр или матрица)
Complex single precisionComplex32 (скаляр или матрица)
Double precisionReal (скаляр или матрица)
Complex double precisionComplex (скаляр или матрица)
Sparse matrixРасширен до матрицы Doubles
Cell array of structuresМассив записей
Cell array of non-structuresВектор или матрица типов, преобразованных из типов элементов
Cell array of structures and non-structuresПреобразование не поддерживается
StructureRecord
ObjectПреобразование не поддерживается

Другие типы значений в данный момент не поддерживаются.

В качестве примера этот оператор использует FEVAL встроенная функция для вызова MATLAB, чтобы принять синус входного параметра.

%assign result = FEVAL( "sin", 3.14159 )

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

Постоянная формаТип TLC
1.0"Real"
1.0[F/f]"Real32"
1"Number"
1[U|u]"Unsigned"
1.0i"Complex"
1[Ui|ui]"UnsignedGaussian"
1i"Gaussian"
1.0[Fi|fi]"Complex32"

Примечание

Суффикс управляет типом Target Language Compiler, полученным из константы.

В этой таблице показаны константы компилятора целевого языка и их эквивалентные значения MATLAB.

Постоянные TLCЭквивалентное значение MATLAB
rtInf, Inf, inf+inf
rtMinusInf-inf
rtNan, NaN, nannan
rtInfi, Infi, infiinf*i
rtMinusInfi-inf*i
rtNaNi, NaNi, naninan*i

TLC-зарезервированные константы

Для значений двойной точности следующие заданы для бесконечного, а не числового IEEE® значения:

rtInf, inf, rtMinusInf, -inf, rtNaN, nan

Для значений с одной точностью применяются эти константы:

rtInfF, InfF, rtMinusInfF, rtNaNF, NaNF

Их соответствующие версии, когда комплексные:

rtInfi, infi, rtMinusInfi, -infi, rtNaNi (for doubles)
rtInfFi, InfFi, rtMinusInfFi, rtNaNFi, NaNFi (for singles)

Для целочисленных значений заданы следующие:

INT8MIN, INT8MAX, INT16MIN, INT16MAX, INT32MIN, INT32MAX, 
UINT8MAX, UINT16MAX, UINT32MAX, INTMAX, INTMIN, UINTMAX

Определение идентификатора

Чтобы задать или изменить идентификаторы (переменные TLC), используйте директиву

%assign [::]expression = constant-expression

Эта директива вводит новые идентификаторы (переменные) или изменяет значения существующих таковых. Левая сторона может быть квалифицированной ссылкой на переменную с помощью . и [] операторы, или это может быть один элемент массива вектора или матрицы. В случае матрицы присвоение изменяет только один элемент.

The %assign директива вставляет новые идентификаторы в локальные возможности функции, возможностей функции файла, генерирует возможности файла или в глобальные возможности. Идентификаторы, введенные в возможности функции, недоступны в вызываемых функциях и удаляются после возврата из функции. Идентификаторы, вставленные в глобальные возможности, являются постоянными. Вы можете изменить существующие идентификаторы, полностью почтив их. Постоянные выражения могут включать юридические идентификаторы из .rtw файлы. Можно использовать %undef удалить идентификаторы так же, как вы используете их для удаления макросов.

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

%function ...
...
%assign foo = 3
...
%endfunction

Обратите внимание, что foo создается, даже если глобальное foo уже существует.

Чтобы создать или изменить значения в глобальных возможностях, необходимо использовать оператор разрешения возможностей (::) для различия, как в

%function ...
%assign foo = 3
%assign ::foo = foo
...
%endfunction

Оператор разрешения возможностей заставляет компилятор присвоить значение локальной переменной foo, 3, к глобальной переменной foo.

Примечание

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

	%assign CompiledModel.name = "newname"	%% No error 

Этот пример генерирует ошибку:

%with CompiledModel
  %assign name = "newname"	   %% Error 	%endwith

Создание записей

Используйте %createrecord директива для создания новых записей в текущих возможностях. Для примера, если вы хотите создать новую запись Rec который содержит два элемента (например Name "Name" и Type "t"), использование

%createrecord Rec {  Name "Name"; Type "t" }

Добавление записей

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

%addtorecord Rec1 Rec2 {  Name "Name1"; Type "t1" }

Этот рисунок показывает результат добавления записи к существующей.

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

%assign myname = Rec1.Rec2[1].Name

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

%addtorecord Rec1 Rec2 {  Name "Name1"; Type "t1" }
%addtorecord Rec1 Rec2 {  Name "Name2"; Type "t2" }

Это создает

Добавление параметров к существующей записи

Можно использовать %assign директива для добавления нового параметра к существующей записи. Для примера,

%addtorecord Block[Idx] N 500 /% Adds N with value 500 to Block %/
%assign myn = Block[Idx].N    /% Gets the value 500 %/

добавляет новый параметр, N, в конце существующего блока с именем и текущим значением существующей переменной, как показано на этом рисунке. Оно возвращает значение блока.

Масштабирование переменных

В этом разделе рассматривается, как целевой компилятор языка разрешает ссылки на переменные (включая записи).

Scope в этом документе имеет два родственных значения. Во-первых, возможности являются атрибутом переменной, которая задает ее видимость и стойкость. Например, переменная, заданная в теле функции, видна только внутри этой функции, и она сохраняется только до тех пор, пока эта функция выполняется. Такая переменная имеет function (or local) scope. Каждая переменная TLC имеет одну (и только одну) из возможностей, описанных в Возможности.

Термин scope также относится к набору или pool переменных, которые имеют те же возможности. На заданной точке выполнения программы TLC может существовать несколько возможностей. Например, во время выполнения функции существуют возможности (пул переменных, локальных к функции). Во всех случаях существуют также глобальные возможности (пул глобальных переменных).

Чтобы разрешить ссылки на переменные, TLC поддерживает список поиска текущих возможностей и просматривает их в четко определенной последовательности. Последовательность поиска описывается в разделе «Как TLC разрешает ссылки на переменные».

Dynamic scoping относится к процессу, которым TLC создает и освобождает переменные, и к возможностям, в которых они существуют. Для примера переменные в функции возможностей существовать только во время выполнения определяющей функции.

Возможности

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

Глобальные возможности.  По умолчанию переменные TLC имеют глобальные возможности. Глобальные переменные видны и могут ссылаться на код где угодно в программе TLC. Глобальные переменные сохраняются в течение всего выполнения программы TLC. Глобальные переменные, как говорят, принадлежат global pool.

Обратите внимание, что CompiledModel запись model.rtw файл имеет глобальные возможности. Поэтому вы можете получить доступ к этой структуре из функций или файлов TLC.

Можно использовать оператор разрешения возможностей видимости (::) для явной ссылки или создания глобальных переменных из функции. См. примеры Оператора Разрешения Возможностей.

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

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

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

%assign fs1 = 1
%filescope
%assign fs2 = 3

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

Функциональные (локальные) возможности.  Переменные, заданные в теле функции, имеют возможности. То есть они видны внутри и локально определяющей функции. Для примера в следующем фрагменте кода переменная localv является локальным по отношению к функции foo. Переменная x является глобальным.

%assign x = 3

%function foo(arg)
   %assign localv = 1
   %return x + localv
%endfunction

Локальная переменная может иметь то же имя что и глобальная переменная. Чтобы обратиться в функции к локальным и глобальным переменным с одинаковыми именами, необходимо использовать оператор разрешения возможностей (::), чтобы изменить неоднозначность ссылок переменных. См. примеры Оператора Разрешения Возможностей.

Примечание

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

% с возможностями . The %with директива добавляет новые возможности, называемую %with scope, к текущему списку возможностей. Эта директива облегчает обращение к переменным с разбиением на блоки.

Структура %with директива является

%with expression
%endwith

Для примера - директива

%with CompiledModel.System[sysidx]
   ...
%endwith

добавляет CompiledModel.System[sysidx] возможности в список поиска. Эти возможности просматриваются раньше всего. Затем вы можете ссылаться на имя системы просто

Name

вместо

CompiledModel.System[sysidx].Name

Сгенерируйте возможности.  Generate scope является специальными возможностями, используемой определенными встроенными функциями, которые предназначены для поддержки генерации кода. Эти функции отправляют вызовы функции, которые сопоставлены с определенным типом записи. Эта возможность поддерживает тип полиморфизма, в котором различные типы записей связаны с функциями (аналогичными методам) с одним и тем же именем. Как правило, эта функция используется для сопоставления Block записи в функции, реализующие функциональность различных типов блоков.

Функции, которые используют, генерируют возможности включают GENERATE, GENERATE_TYPE, GENERATE_FUNCTION_EXISTS, и GENERATE_TYPE_FUNCTION_EXISTS. Смотрите GENERATE и GENERATE_TYPE функции. В этом разделе рассматривается сгенерировать возможности с помощью GENERATE встроенная функция в качестве примера.

Синтаксис файла GENERATE функция есть

GENERATE(blk,fn)

Первый аргумент (blkКому GENERATE является допустимым именем записи. Второй аргумент (fn) - имя функции, подлежащей отправке. Когда функция отправляется через GENERATE вызов, TLC автоматически добавляет blk к списку возможностей, который просматривается при разрешении переменных ссылок. Таким образом, запись (blk) видна отправленной функции как неявная %with <blk>... %endwith директива существовала в переданной функции.

В этом контексте запись с именем blk говорят, что находится в возможностях генерации.

Ниже перечислены три файла TLC, иллюстрирующие использование возможностей генерации. Файл polymorph.tlc создает две записи, представляющие два гипотетических типа блоков, MyBlock и YourBlock. Каждый тип записи имеет связанную функцию с именем aFunc. Специфичные для блоков реализации aFunc содержатся в файлах MyBlock.tlc и YourBlock.tlc.

Используя GENERATE вызовы, polymorph.tlc отправляет функцию для каждого типа блоков. Заметьте, что aFunc реализации могут относиться к полям MyBlock и YourBlock, потому что эти записи находятся в генерации возможностей.

  • В следующем списке показаны polymorph.tlc:

    %% polymorph.tlc
    
    %language "C"
    
    %%create records used as scopes within dispatched functions
    
    %createrecord MyRecord { Type "MyBlock"; data 123 }
    %createrecord YourRecord { Type "YourBlock"; theStuff 666 }
    
    %% dispatch the functions thru the GENERATE call.
    
    %% dispatch to MyBlock implementation
    %<GENERATE(MyRecord, "aFunc")> 
    
    %% dispatch to YourBlock implementation
    %<GENERATE(YourRecord, "aFunc")>
    
    %% end of polymorph.tlc
  • В следующем списке показаны MyBlock.tlc:

    %%MyBlock.tlc
    
    %implements "MyBlock" "C"
    
    %% aFunc is invoked thru a GENERATE call in polymorph.tlc.
    %% MyRecord is in generate scope in this function.
    %% Therefore, fields of MyRecord can be referenced without
    %% qualification
    
    %function aFunc(r) Output
    %selectfile STDOUT
    The value of MyRecord.data is: %<data>
    %closefile STDOUT
    %endfunction
    
    %%end of MyBlock.tlc
  • В следующем списке показаны YourBlock.tlc:

    %%YourBlock.tlc
    
    %implements "YourBlock" "C"
    
    %% aFunc is invoked thru a GENERATE call in polymorph.tlc.
    %% YourRecord is in generate scope in this function.
    %% Therefore, fields of YourRecord can be referenced without
    %% qualification
    
    %function aFunc(r) Output
    %selectfile STDOUT
    The value of YourRecord.theStuff is: %<theStuff>
    %closefile STDOUT
    %endfunction
    
    %%end of YourBlock.tlc

Вызов и выход polymorph.tlc, как показано в Командном Окне MATLAB, показаны ниже:

tlc -v polymorph.tlc

The value of MyRecord.data is: 123
The value of YourRecord.theStuff is: 666

Примечание

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

Оператор разрешения возможностей

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

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

%assign foo = 3   %% this variable has global scope
.
.
.
%function myfunc(arg)
   %assign foo = 3   %% this variable has local scope
   %assign ::foo = arg   %% this changes the global variable foo
%endfunction

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

%function sideffect(arg)
   %assign ::theglobal = arg   %% this creates a global variable
%endfunction

Как TLC разрешает ссылки на переменные

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

Глобальные возможности.  В самом простом случае Target Language Compiler разрешает ссылку переменной путем поиска в глобальном пуле (включая CompiledModel структура).

% с возможностями . Вы можете изменить список поиска и последовательность поиска с помощью %with директива. Для примера, когда вы добавляете следующую конструкцию,

%with CompiledModel.System[sysidx]
   ...
%endwith

а System[sysidx] возможности добавляется в список поиска. Сначала выполняется поиск этих возможностей, как показано на этом изображении.

Этот метод упрощает доступ к встраиваемым определениям. Использование %with конструкция (как в предыдущем примере), вы можете ссылаться на имя системы просто

Name

вместо

CompiledModel.System[sysidx].Name

Возможности.  Функция имеет свои возможности. Эти возможности добавляются к ранее описанному списку поиска, как показано на этой схеме.

Для примера в следующем фрагменте кода,

% with CompiledModel.System[sysidx]
...
   %assign a=foo(x,y)
...
%endwith
...
%function foo(a,b)
...
   assign myvar=Name
...
%endfunction
...
%<foo(1,2)>

Если Name не определен в foo, в присвоении используется значение Name из предыдущих возможностей, CompiledModel.System[SysIdx].Name.

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

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

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

Функции целевого языка

Конструкция функции целевого языка

%function identifier ( optional-arguments ) [Output | void]
%return
%endfunction

Функции на целевом языке рекурсивны и имеют собственное локальное пространство переменных. Функции на целевом языке не выдают выход, если они не являются выходными функциями или явно не используют %openfile, %selectfile, и %closefile директивы.

Функция опционально возвращает значение с %return директива. Возвращенное значение может быть типом, заданным в таблице в Target Language Value Types.

В этом примере функция, name, возвращает x если x и y равны, или возвращаются z если x и y не равны:

%function name(x,y,z) void

%if x == y
   %return x
%else
   %return z
%endif

%endfunction

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

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

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

По умолчанию функция возвращает значение и не выдает выход. Можно переопределить это поведение, задав Output и void модификаторы в линии объявления функции, как в

%function foo() Output
...
%endfunction

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

%function foo() void
...
%endfunction

Масштабирование переменных в функциях

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

Можно переопределить поведение по умолчанию при помощи %assign с оператором разрешения возможностей (::).

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

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

Вернуть

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

%function foo(s)
    %with s
        %return(name)
    %endwith
%endfunction

The %return оператор не требует значения. Можно использовать %return чтобы вернуться из функции без возврата значения.

Похожие темы

Для просмотра документации необходимо авторизоваться на сайте