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

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

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

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

%exit Error Message

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

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

%assign

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

%assign [::]variable = expression 

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

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

Ограничивает осциллограф переменных к файлу, в котором они заданы. %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"); в противном случае это - "".

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

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

%function
%return
%endfunction

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

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

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

%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

Примечание: 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 удаляет целый массив записи.

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

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

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

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

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

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

для

Синтаксис %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 несколько директива включения

%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

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

%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

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

СГЕНЕРИРУЙТЕ и функции 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.

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

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

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

%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 должен обработать:

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

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

Включение

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

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

Как правило, %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

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

Осциллограф %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) имя функции, которая будет диспетчеризирована. Когда функция диспетчеризируется через 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 разрешает ссылки на переменную

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

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

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

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

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

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

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

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

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

возврат

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

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

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