Вы управляете тем, как код генерируется из моделей, в основном, путем написания или изменения скриптов, которые применяют директивы 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
развертываются, отображаются и выходы TLC.tokens
При сообщении об ошибках используйте следующую команду, если ошибка вызвана неправильным строением, которую пользователь должен исправить в модели.
%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"
, за исключением только определенного входа,
. The i
"u"
должен быть строчным или будет интерпретирован как "U"
выше.
"Y"
Выходные выходы блока. Предполагается, что вы используете LibBlockOutputSignal(portIdx, "", lcv, sigIdx)
для доступа к каждому выходу, где portIdx
начинается с 0 для первого выходного порта.
"y i
"
Подобно "Y"
, за исключением определенного выхода,
. The i
"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
Примечание
Использование \
для подавления линии каналов на выход и эллипсис ...
для указания продолжения линии. Обратите внимание, что \
и многоточие ...
не может использоваться внутри строк.
В этой таблице показаны типы значений, которые можно использовать в контексте выражений в файлах целевого языка. Выражения в компиляторе целевого языка должны использовать эти типы.
Строка типа значения | Пример | Описание |
---|---|---|
1==1 | Результат сравнения или другого логического оператора. Результат будет | |
3.0+5.0i | 64-битное комплексное число двойной точности ( | |
3.0F+5.0Fi | 32-битное комплексное число с одной точностью ( | |
%openfile x | Строковый буфер, открытый с | |
"File" | %openfile x = "out.c" | Файл открыт с |
%function foo ... | Определяемые пользователем функция и | |
3+5i | 32-битное целочисленное мнимое число ( | |
"Identifier" | abc | Значения идентификаторов могут появляться только в |
Matrix (3,2) [ [ 1, 2]; [3 , 4]; [ 5, 6] ] | Матрицы являются просто списками векторов. Отдельные элементы матрицы не должны быть совпадающими типами и могут быть любым поддерживаемым типом, кроме векторов или матриц. The | |
15 | Целое число ( | |
[1:5] | Область значений целых чисел от 1 до 5 включительно. | |
"Real" | 3.14159 | Число с плавающей запятой ( |
3.14159F | 32-битное одноточное число с плавающей запятой ( | |
Block { ... } | Блокируйте запись. | |
FILE_EXISTS | Специальная встроенная функция, такая как | |
"Hello, World" | Символьные строки ASCII. Во всех контекстах две строки в строке объединяются, чтобы сформировать окончательное значение, как в | |
<sub1> | Идентификатор подсистемы. В контексте расширения будьте осторожны, чтобы избежать разделителей на идентификаторе подсистемы, как в | |
15U | 32-битное беззнаковое целое число ( | |
3U+5Ui | 32-битное комплексное беззнаковое целое число ( | |
[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».
Выражения на целевом языке
Примечание
Реляционные операторы (<, =<, >, >=, !=, ==
) может использоваться с нефинитными значениями.
Вы не должны помещать выражения в %< >
eval
формат, когда они появляются в директивных линиях. Это приводит к двойной оценке.
Когда Target Language Compiler работает с смешанными типами выражений, он продвигает результаты к общим типам, указанным в следующей таблице.
В таблице используются следующие сокращения:
| Булев |
| Число |
| Неподписанный |
| Real32 |
| Реальный |
| Гауссовский |
| UnsignedGaussian |
| Complex32 |
| Комплекс |
В верхней строке (полужирным шрифтом) и первом столбце (полужирным шрифтом) показаны типы выражения, используемые в операции. Пересечение строки и столбца показывает полученный тип выражений.
Для примера, если операция включает логическое выражение (B
) и беззнаковое выражение (U
), результатом будет беззнаковое выражение (U
).
Типы данных, полученные из выражений смешанного типа
B | N | U | F | D | G | UG | C32 | C | |
---|---|---|---|---|---|---|---|---|---|
B | B | N | U | F | D | G | UG | C32 | C |
N | N | N | U | F | D | G | UG | C32 | C |
U | U | U | U | F | D | UG | UG | C32 | C |
F | F | F | F | F | D | C32 | C32 | C32 | C |
D | D | D | D | D | D | C | C | C | C |
G | G | G | UG | C32 | C | G | UG | C32 | C |
UG | UG | UG | UG | C32 | C | UG | UG | C32 | C |
C32 | C32 | C32 | C32 | C32 | C | C32 | C32 | C32 | C |
C | C | C | C | C | C | C | C | C | C |
По умолчанию компилятор целевого языка выводит числа с плавающей запятой в экспоненциальном обозначении с 16 цифрами точности. Чтобы переопределить значение по умолчанию, используйте директиву
Если
является 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
может содержать любое выражение, заданное в выражениях на целевом языке.
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
несколько директивы включения является
The constant-expression
необходимо вычислить целочисленное выражение, которое затем определяет количество раз, чтобы выполнить foreach
цикл. The identifier
шаги от 0
на единицу меньше заданного числа. В пределах foreach
цикл, можно использовать x
, где x
- идентификатор для доступа к переменной идентификатора. %break
и %continue
являются необязательными директивами, которые можно включить в %foreach
директива:
Использование %break
выход из ближайшего ограждающего %for
, %foreach
, или %switch
оператор.
Использование %continue
чтобы начать следующую итерацию цикла.
Примечание
The %for
директива является функциональной, но она не рекомендуется. Вместо этого используйте %roll
, который обеспечивает ту же возможность более открытым способом. Генератор кода не использует %for
конструировать.
Синтаксис %for
несколько директивы включения является
Первый фрагмент %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; } }
Компилятор целевого языка предоставляет простое объектно-ориентированное средство. Языковые директивы:
Этот механизм был разработан специально для настройки кода для блоков 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
директива.
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
директивы, чтобы определить, существует ли указанная функция на самом деле.
Структура выхода управления файлами конструкции
The %openfile
директива открывает файл или буфер для записи; необходимая строковая переменная становится переменной типа file
. Для примера,
%openfile x /% Opens and selects x for writing. %/ %openfile out = "out.h" /% Opens "out.h" for writing. %/
The %selectfile
директива выбирает файл, заданный переменной, в качестве текущего выходного потока. Выход переходит к этому файлу, пока другой файл не будет выбран с помощью %selectfile
. Для примера,
%selectfile x /% Select file x for output. %/
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.
Директивы управления входным файлом:
The %include
директива ищет путь к целевому файлу, заданному string
и включает содержимое файла в строке в точке, где %include
появляется оператор.
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
директива и явный относительный путь.
Компилятор целевого языка ищет папки в следующем порядке для целевых файлов или включать файлы:
Текущая папка.
Включите пути, указанные в %addincludepath
директивы. Компилятор оценивает несколько %addincludepath
директивы снизу вверх.
Включите пути, заданные в командной строке через -I
. Компилятор оценивает несколько -I
опции справа налево.
Как правило, %addincludepath
директивы должны быть указаны в целевом файле системы. Несколько %addincludepath
директивы добавят несколько путей к пути поиска файлов компилятора целевого языка.
Примечание
Компилятор не ищет путь MATLAB и не найдет файл, доступный только по этому пути. Компилятор ищет только местоположения, описанные выше.
Соответствующие директивы assert, error, warning и debug message:
Эти директивы приводят к ошибкам, предупреждениям или трассировкам сообщений всякий раз, когда целевой файл обнаруживает условие ошибки или требуется трассировка. Лексемы, следующие директиве на линии, становятся частью сгенерированного сообщения об ошибке или предупреждения.
Компилятор целевого языка помещает сообщения, сгенерированные %trace
на stderr
если и только если вы задаете переключатель с подробным режимом (-v
) к целевому языковому компилятору. Дополнительные сведения о коммутаторах см. в разделе Аргументы командной строки.
The %assert
директива оценивает выражение и создает трассировку стека, если выражение вычисляется как логическое false
.
Примечание
В порядке %assert
директивы, которые будут оценены, Enable TLC assertion должны быть выбраны в TLC process разделе панели Code Generation > Debug. Действие по умолчанию предназначено для %assert
директивы, которые не должны быть оценены.
The %exit
директива сообщает об ошибке и останавливает дальнейшую компиляцию.
В следующей таблице перечислены встроенные функции и значения, которые добавляются в список параметров, появляющихся в
файл. Эти функции и значения компилятора целевого языка заданы в верхнем регистре, так что они визуально отличаются от других параметров в model
.rtw
файл, и, по соглашению, из пользовательских параметров.model
.rtw
Встроенные функции и значения TLC
Имя встроенной функции | Расширение |
---|---|
Первое выражение должно быть строкой, которая соответствует одному из имен типов в таблице Типы значений целевого языка, и второе выражение будет приведено к этому типу. Типичным использованием может быть приведение переменной к реальному формату, как в CAST("Real", variable-name) Примером этого является работа со значениями параметров для S-функций. Чтобы использовать их в код C or C++, необходимо набрать их, чтобы | |
Если на | |
Выполняет оценку в MATLAB. Для примера, %assign result = FEVAL("sin",3.14159) The %matlab disp(2.718) Примечание.Если функция MATLAB возвращает более одного значения, TLC получает только первое значение. | |
| |
Первое выражение является | |
Возвращает массив строк, содержащий имена полей записей, сопоставленных с записью. Поскольку он возвращает отсортированный список строк, функция | |
Возвращает содержимое указанного имени поля, если имя поля связано с записью. Функция использует хэш-поиск, и поэтому выполняется за постоянное время. | |
Выполняет вызовы функций, сопоставленные с определенным типом записи (то есть с функциями записи блоков). Для примера используйте это для выполнения функций в | |
Для заданного типа записи делает | |
Возвращает потенциально многострочную строку, которая может использоваться, чтобы объявить значение (значения) Для примера,
приводит к следующему коду С:
| |
Определяет, существует ли данная функция блока. Первое выражение совпадает с первым аргументом | |
Подобно | |
То же, что и | |
Возвращает значения переключателей командной строки. Поддерживаются только следующие коммутаторы: v, m, p, O, d, dr, r, I, a | |
| |
Возвращает мнимую часть комплексного числа. | |
| |
| |
| |
| |
| |
| |
Минимальное целое значение на хост-машине. | |
Максимальное целое значение на хост-машине. | |
Возвращает | |
Где типы данных обоих выражений числовые: возвращает Где тип данных любого выражения является нечисловым (например, строка или запись): возвращает | |
Возвращает | |
Возвращает | |
Возвращает | |
Возвращает | |
Возвращает | |
| Возвращает логическое значение, указывающее, является ли его аргумент ссылкой на параметр Simulink или нет. Эта функция поддерживает совместное использование параметров с Simulink; использование его может сэкономить память и время во время генерации кода. Для примера, %if !ISSLPRMREF(param.Value) assign param.Value = CAST("Real", param.Value) %endif |
Предопределенный файл без выхода, который можно использовать в качестве аргумента для | |
Количество целевых файлов, используемых до настоящего времени при расширении. | |
Возвращает количество линий, записанных в текущий выбранный файл или буфер. Не работает на | |
Возвращает действительную часть комплексного числа. | |
Удаляет указанное поле из содержимого записи. Возвращает | |
Возвращает количество циклов или | |
Устанавливает содержимое имени поля, связанного с записью. Возвращает | |
Вычисляет размер первого выражения и генерирует двухэлементный вектор-строку. Если задан второй операнд, он используется как целочисленный индекс в этот вектор-строку; в противном случае возвращается весь вектор-строка. [1,<number of blocks>] | |
Форматирует данные в переменных | |
Предопределенный файл для | |
Расширяет выражение в строку; символы | |
Принимает вектор значений ASCII и возвращает строку, которая создается путем обработки каждого элемента как кода ASCII для одного символа. Используется, в основном, для строковых параметров S-функции. | |
Ищет специально отформатированные строки формы %<sysname("<sub>/Gain")> возвраты ["sub","Gain"] В | |
Возвращает вектор, содержащий имена целевых файлов, включенных до сих пор в расширение. Используются абсолютные пути. См. также | |
Логическая константа, которая равна отрицательному вычисленному логическому выражению. | |
Логическая константа, которая равна положительному вычисленному логическому выражению. | |
Дата и время компиляции. | |
Версия и дата компилятора целевого языка. | |
Оценивает | |
| |
| |
| |
Максимальное беззнаковое целое значение на хост-машине. | |
Принимает строку и возвращает 1, если строка содержит только пустые символы ( | |
Первое выражение является вектором крена, а второе - порогом крена. Эта функция возвращает |
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 precision | Real32 (скаляр или матрица) |
Complex single precision | Complex32 (скаляр или матрица) |
Double precision | Real (скаляр или матрица) |
Complex double precision | Complex (скаляр или матрица) |
Sparse matrix | Расширен до матрицы Doubles |
Cell array of structures | Массив записей |
Cell array of non-structures | Вектор или матрица типов, преобразованных из типов элементов |
Cell array of structures and non-structures | Преобразование не поддерживается |
Structure | Record |
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 , nan | nan |
rtInfi , Infi , infi | inf*i |
rtMinusInfi | -inf*i |
rtNaNi , NaNi , nani | nan*i |
Для значений двойной точности следующие заданы для бесконечного, а не числового 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
запись
файл имеет глобальные возможности. Поэтому вы можете получить доступ к этой структуре из функций или файлов TLC.model
.rtw
Можно использовать оператор разрешения возможностей видимости (::
) для явной ссылки или создания глобальных переменных из функции. См. примеры Оператора Разрешения Возможностей.
Обратите внимание, что вы можете использовать %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 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
В этом разделе рассматривается, как целевой компилятор языка ищет существующие возможности, чтобы разрешить ссылки переменных.
Глобальные возможности. В самом простом случае 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
чтобы вернуться из функции без возврата значения.