Документация

%% 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

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

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

%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 лексема, запись создается в глобальных возможностях.

%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" функции для создания структур крена. Заданные переменные цикла относительно блока

Чтобы 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 файла следующих функций, которые вызываются целевыми файлами всей модели во время генерации кода.

%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 удаляет весь массив записей.

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

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

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

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

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

%, если

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 директива:

% для

Синтаксис %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

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

%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;
	}
}

% язык

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"

СГЕНЕРИРУЙТЕ и 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Вызовы функций просматриваются сначала в файле, а затем в глобальных возможностях. Это позволяет иметь скрытые вспомогательные функции, используемые исключительно текущим объектом.

% 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 необходимо обработать:

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

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

% включают

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 директива и явный относительный путь.

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

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

Функция FEVAL

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

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

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

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

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

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

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

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

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

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

Используйте %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, в конце существующего блока с именем и текущим значением существующей переменной, как показано на этом рисунке. Оно возвращает значение блока.

Возможности

В следующих разделах описываются возможные возможности, которые могут иметь переменные 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

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

% с возможностями . 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, как показано в Командном Окне MATLAB, показаны ниже:

tlc -v polymorph.tlc

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

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

Оператор разрешения возможностей (::) используется, чтобы указать, что глобальные возможности видимости должна искать, когда функция 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 и глобальные возможности, как показано на следующей схеме:

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

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

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

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

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

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

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

Вернуть

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

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

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