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

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

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

Синтаксис

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

  • [text | %<expression>]* 

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

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

    %keyword представляет одну из директив Компилятора Выходного языка и [argument1, argument2, ...] представляет выражения, которые задают обязательные параметры. Например, оператор

    %assign sysNumber = sysIdx + 1

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

Директивы

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

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

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

%switch директива похожа на язык C switch оператор. Выражение expr должен иметь тип, который может быть сравнен для равенства с помощью the == 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

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

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

установить этот флаг на или прочь. Значение по умолчанию Выключено. Чтобы видеть, что ток устанавливает, использовать

get_param(model, 'TLCAssertion')

%error
%warning
%trace
%exit

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

%error tokens

tokens расширены и отображены.

%warning tokens

tokens расширены и отображены.

%trace tokens

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

%exit tokens

tokens расширены, отображены, и выходы TLC.

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

%exit Error Message

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

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

%assign

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

%assign [::]variable = expression 

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

Если необходимо отформатировать переменную, скажем, в строке, основанной на других переменных 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

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

%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

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

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

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

%include

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

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

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

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

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

Используйте наклонные черты вправо для имен папок, когда они работают над обоими UNIX® и системы PC. Однако, если вы действительно используете наклонные черты влево на имена папок PC, убедиться выйти из них, например, "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. Однако, если вы действительно используете наклонные черты влево на имена папок PC, убедиться выйти из них, например, "C:\\mytlc". В качестве альтернативы можно описать имя папки PC как литерал с помощью спецификатора формата L, как в L"C:\mytlc".

%roll
%endroll

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

Этот пример %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

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

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

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

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

"U"

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

"ui"

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

"Y"

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

"yi"

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

"P"

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

"<параметрический усилитель>/name"

Подобно "P", кроме специфичного для определенного name.

rwork

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

"<rwork>/name"

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

dwork

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

"<dwork>/name"

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

iwork

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

"<iWork>/name"

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

pwork

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

"<pwork>/name"

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

"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. См. %breakpoint Директиву.

%function
%return
%endfunction

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

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

Пустая функция не производит выход и не требуется, чтобы возвращать значение. Это задано как

%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

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

%for

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

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

Первый фрагмент %for директива идентична %foreach оператор. %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 создается содержащий выход. Аргумент режима является дополнительным. Если задано, это может быть "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Ввод).

Смотрите ГЕНЕРИРУЮТ и функции GENERATE_TYPE.

%undef

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

Комментарии

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

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

или

%endfunction %% Outputs function

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

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

/* Initialize sysNumber */
int sysNumber = 3;

копирует обе строки к буферу вывода.

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

Примечание

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

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

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

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

или

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

Примечание

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

Типы значения выходного языка

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

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

"Boolean"

1==1

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

"Complex"

3.0+5.0i

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

"Complex32"

3.0F+5.0Fi

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

"File"

%openfile x

Буфер строки открыт с %openfile.

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

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

"Function"

%function foo...

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

"Gaussian"

3+5i

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

"Identifier"abc

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

"Matrix"

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

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

"Number"

15

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

"Range"

[1:5]

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

"Real"3.14159

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

"Real32"

3.14159F

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

"Scope"

Block { ... }

Запись блока.

"Special"

FILE_EXISTS

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

"String"

"Hello, World"

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

"Subsystem"

<sub1>

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

"Без знака"

15U

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

"Unsigned Gaussian"

3U+5Ui

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

"Vector"

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

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

Выражения выходного языка

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

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

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

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

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

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

больше, чем

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

больше, чем или равный

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

сдвиг вправо

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

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

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

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

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

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

  • Boolean

  • Number

  • Unsigned

  • Real

  • Real32

  • Complex

  • Complex32

  • Gaussian

  • UnsignedGaussian

Кроме того, отметьте тот integral одно из следующего:

  • Number

  • Unsigned

  • Boolean

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

Выражения выходного языка

Выражение

Определение

constant

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

variable-name

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

::variable-name

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

expr[expr]

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

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

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

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

expr . expr

Первое выражение должно иметь допустимый осциллограф; второе выражение является названием параметра в том осциллографе.

(expr)

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

!expr

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

-expr

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

+expr

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

~expr

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

expr * expr

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

expr / expr

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

expr % expr

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

expr + expr

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

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

Строки: строки конкатенированы.

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

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

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

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

expr - expr

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

expr << expr

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

expr >> expr

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

expr > expr

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

expr < expr

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

expr >= expr

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

expr <= expr

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

expr == expr

Тесты, равны ли эти два выражения.

expr != expr

Тесты, не ли эти два выражения равны.

expr & expr

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

expr ^ expr

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

expr | expr

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

expr && expr

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

expr || expr

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

expr ? expr : expr

Тестирует первое выражение на TLC_TRUE. Если это правда, первое выражение возвращено; в противном случае второе выражение возвращено.

expr , expr

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

Примечание

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

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

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

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

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

B

Boolean

N

Номер

U

Без знака

F

Real32

D

Действительный

G

Гауссов

UG

UnsignedGaussian

C32

Complex32

C

Комплекс

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

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

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

 BNUFDGUGC32C
BBNUFDGUGC32C
NNNUFDGUGC32C
UUUUFDUGUGC32C
FFFFFDC32C32C32C
DDDDDDCCCC
GGGUGC32CGUGC32C
UGUGUGUGC32CUGUGC32C
C32C32C32C32C32CC32C32C32C
CCCCCCCCCC

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

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

%realformat string

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

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

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

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

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

%if

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

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

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

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

Switch

%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

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

  • Используйте %break выходить из самого близкого включения %for, %foreach, или %switch оператор.

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

для

Примечание

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

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

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

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

%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 \times.

Этот механизм передает каждому отдельному управлению циклом, должно ли это быть прокручено.

Крен

Синтаксис %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 установлен в пустую строку, "".

Когда Компилятор Выходного языка решает, что данный блок прокрутится, это выполняет 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

Примечание

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

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

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

Этот код Компилятора Выходного языка производит этот выход:

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

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

Компилятор Выходного языка предоставляет простую объектно-ориентированную услугу. Директивы языка

%language string
%generatefile
%implements

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

%language

%language директива задает сгенерированный выходной язык. Это требуется как проверка на непротиворечивость проверить файлы реализации, найденные для сгенерированного языка. %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"

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

%implements * "C"

Примечание

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

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

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

СГЕНЕРИРОВАТЬ.  GENERATE функционируйте берет два или больше входных параметра. Первый аргумент должен быть допустимым осциллографом и вторым строка, содержащая имя функции, чтобы вызвать. GENERATE функционируйте передает первый аргумент блока и любые дополнительные аргументы, заданные к вызванной функции. Возвращаемый аргумент является значением, если таковые имеются, возвращенный в вызванную функцию. Обратите внимание на то, что компилятор автоматически “определяет объем” или добавляет первый аргумент в список осциллографов, искавших, как будто это появляется на %with направляющая линия. (См. Переменное Определение объема.) Этот осциллограф удален, когда функция возвращается.

GENERATE_TYPE.  GENERATE_TYPE функционируйте берет три или больше входных параметра. Это обрабатывает первые два аргумента тождественно к GENERATE вызов функции. Третий аргумент является типом; тип, заданный в блоке Simulink, проигнорирован. Это средство используется, чтобы обработать генерацию кода S-функции процессом сборки. Таким образом, типом блока является S-function, но Компилятор Выходного языка генерирует его как определенную S-функцию, заданную GENERATE_TYPE. Например,

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

задает ту S-функцию block имеет тип dp_read.

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

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

Примечание

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

Управление выходным файлом

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

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

Открытый файл

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

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

Выбор File

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

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

%closefile

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

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

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

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

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

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

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

Введите управление файлом

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

%include string
%addincludepath string

Включение

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

%addincludepath

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

%addincludepath string

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

CAST(expr, expr)

Первое выражение должно быть строкой, которая соответствует одним из имен типов в таблице Target Language Value Types, и второе выражение будет брошено к тому типу. Типичное использование может быть должно бросить переменную к действительному формату как в

CAST("Real", variable-name) 

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

EXISTS(var)

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

FEVAL(matlab-command,
   TLC-expressions)

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

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

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

%matlab disp(2.718)

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

FILE_EXISTS(expr)

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

FORMAT(realvalueформат)

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

FIELDNAMES(record)

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

GETFIELDзапись,
   "имя поля"
)

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

GENERATEзапись,
    function-name, ...)

Выполняет вызовы функции, сопоставленные с определенным типом записи (т.е. функции записи блока). Например, используйте это, чтобы выполнить функции в .tlc файлы для встроенных блоков. Не то, чтобы TLC автоматически “определяет объем” или добавляет первый аргумент в список осциллографов, искавших, как будто это появляется на %with направляющая линия.

GENERATE_FILENAME(type)

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

GENERATE_FORMATTED_VALUE
   (expr, string, expand)

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

Например,

static const unsigned char contents[] =

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

;

выражения этот код С:

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

GENERATE_FUNCTION_EXISTS
   (record, function-name)

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

GENERATE_TYPE
   (запись, имя функции,
    ввод,

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

GENERATE_TYPE_FUNCTION_EXISTS
   (запись, имя функции,
   ввод,

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

GET_COMMAND_SWITCH

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

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

IDNUM(expr)

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

IDNUM("ABC123") выражения ["ABC", 123]

IMAG(expr)

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

INT8MAX

127

INT8MIN

-128

INT16MAX

32767

INT16MIN

-32768

INT32MAX

2147483647

INT32MIN

-2147483648

INTMIN

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

INTMAX

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

ISALIAS(record)

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

ISEQUAL(expr1, expr2)

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

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

ISEMPTY(expr)

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

ISFIELD(record, "fieldname")

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

ISINF(expr)

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

ISNAN(expr)

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

ISFINITE(expr)

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

ISSLPRMREF(param.value)

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

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

ISSUBSTRING(expr1, expr2)

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

NULL_FILE

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

NUMTLCFILES

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

OUTPUT_LINES

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

REAL(expr)

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

REMOVEFIELD(record, "fieldname")

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

ROLL_ITERATIONS()

Возвращает число раз, текущие области крена являются цикличным выполнением или NULL если не в %roll создать.

SETFIELD(record, "fieldname", value)

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

SIZE(expr[,expr])

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

[1,<number of blocks>]

SPRINTF(format,var,...)

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

STDOUT

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

STRING(expr)

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

STRINGOF(expr)

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

STRNCMP(expr1, expr2, value)

Возвращает TLC_TRUE если expr1 то же самое как expr2 к количеству символов, заданных в value, и TLC_FALSE в противном случае. expr1 и expr2 должен быть string, и value должен быть номер.

STRREP(expr1, expr2, expr3)

Принимает строку expr1 и возвращает новую строку, которая заменяет все экземпляры подстроки expr2 существующий в expr1 со строкой expr3.

SYSNAME(expr)

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

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

возвращается

["sub","Gain"]

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

TLCFILES

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

TLC_FALSE

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

TLC_TRUE

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

TLC_TIME

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

TLC_VERSION

Версия и дата Компилятора Выходного языка.

TYPE(expr)

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

UINT8MAX

255U

UINT16MAX

65535U

UINT32MAX

4294967295U

UINTMAX

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

WHITE_SPACE(expr)

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

WILL_ROLL(expr1, expr2)

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

Функция FEVAL

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

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

Примечание

  • Только один аргумент левой стороны позволен, когда вы используете FEVAL.

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

  • Для строковых операций рекомендуется использовать строку директивы TLC вместо функций FEVAL.

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

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

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

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

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

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

Вектор из строк

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

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

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

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

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

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

Примечание

Суффикс управляет типом Компилятора Выходного языка, полученным из константы.

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

Константы TLCЭквивалентное значение MATLAB
rtInfInfInf+inf
rtMinusInf-inf
rtNanNaNNaNnan
rtInfi, Infi, infiinf*i
rtMinusInfi-inf*i
rtNaNi, NaNi, naninan*i

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

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

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

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

rtInfF, InfF, rtMinusInfF, rtNaNF, NaNF

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

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

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

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

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

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

%assign [::]expression = constant-expression

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

%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 имеет один (и только один) осциллографов, описанных в Осциллографах.

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

Чтобы разрешить ссылки на переменную, TLC ведет поисковый список текущих осциллографов и ищет их в четко определенной последовательности. Поисковая последовательность описана в Как Ссылки на переменную Твердости TLC.

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

Осциллографы

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

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

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

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

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

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

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

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

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

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

%assign x = 3

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

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

Примечание

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

Осциллограф %with.  %with директива добавляет новый осциллограф, называемый %with scope, к текущему списку осциллографов. Эта директива облегчает относиться к ограниченным по объему блоком переменным.

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

%with expression
%endwith

Например, директива

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

добавляет the CompiledModel.System[sysidx] определите объем к поисковому списку. Этот осциллограф ищется перед чем-либо еще. Можно затем обратиться к имени системы просто

Name

вместо

CompiledModel.System[sysidx].Name

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

Функции, которые используют, генерируют осциллограф, включают GENERATE, GENERATE_TYPE, GENERATE_FUNCTION_EXISTS, и GENERATE_TYPE_FUNCTION_EXISTS. Смотрите ГЕНЕРИРУЮТ и Функции GENERATE_TYPE. В этом разделе рассматриваются, генерируют осциллограф с помощью GENERATE встроенная функция как пример.

Синтаксис GENERATE функция

GENERATE(blk,fn)

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

В этом контексте, записи под названием blk как говорят, находится в, генерируют осциллограф.

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

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

  • Следующий листинг показывает polymorph.tlc:

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

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

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

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

tlc -v polymorph.tlc

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

Примечание

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

Оператор разрешения области видимости

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

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

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

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

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

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

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

Глобальная область видимости.  В самом простом случае Компилятор Выходного языка разрешает ссылку на переменную путем поиска глобального пула (включая CompiledModel структура.

Осциллограф %with.  Можно изменить поисковый список и искать последовательность при помощи %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Выбор File, и %closefile директивы.

Функция опционально возвращает значение с %return директива. Возвращенное значение может быть типом, заданным в таблице в Типах Значения Выходного языка.

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

%function name(x,y,z) void

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

%endfunction

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

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

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

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

%function foo() Output
...
%endfunction

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

%function foo() void
...
%endfunction

Переменное определение объема в функциях

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

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

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

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

возврат

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

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

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

Похожие темы

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