answer stringlengths 15 1.25M |
|---|
<div class="easyui-tabs" data-options="fit:true,border:false,plain:true">
<div title="" data-options="cache:true">
<table width="100%" height="100%" align="center" valign="middle">
<tr>
<td align="center" style="font-size: 14px;color:grey;cursor: default" onclick="<API key>.upload()"><img src="__STATIC__/img/upload.png" alt=""/></td>
</tr>
</table>
</div>
<div title="" data-options="cache:true">
<table id="<API key>" class="easyui-datagrid" data-options="fit:true,border:false,fitColumns:true,rownumbers:false,singleSelect:true,striped:true,url:'<{:U('Storage/public_dialog', array('grid'=>'datagrid'))}>',onDblClickRow:<API key>.click,toolbar:'#<API key>',onLoadSuccess:<API key>.tooltip">
<thead>
<tr>
<th data-options="field:'operate',width:30,align:'center',formatter:<API key>.operate"></th>
<th data-options="field:'name',width:200,formatter:<API key>.name"></th>
<th data-options="field:'size',width:50"></th>
</tr>
</thead>
</table>
<div id="<API key>" style="padding:1px;height:auto">
<form style="padding:0 5px">
<input type="text" name="path" value="/" style="width:200px;padding:2px" readonly />
<a href="javascript:;" onclick="<API key>.refresh()" class="easyui-linkbutton" iconCls="<API key>" plain="true"></a>
<a href="javascript:;" onclick="<API key>.back(this)" class="easyui-linkbutton" iconCls="<API key>" plain="true"></a>
</form>
</div>
</div>
<div title="" data-options="cache:true">
<form style="text-align: center">
<input class="easyui-validatebox" data-options="required:true,validType:['url','length[10,255]']" type="text" style="width: 80%;margin:20px auto;"/>
<a href="javascript:;" onclick="<API key>.input(this)" class="easyui-linkbutton"></a>
</form>
</div>
</div>
<script type="text/javascript">
var <API key> = {
dialog : '#globel-dialog-div',
datagrid: '#<API key>',
//name
name: function(val, arr){
var icon = 'icons-folder-folder';
if(arr.type != 'dir'){
icon = '<API key>';
var ext = /[^\.]+$/.exec(val);
icon += ' icons-ext-' + ext[0].toLowerCase();
}
return '<span class="tree-icon tree-file ' + icon + '" url="./Public/upload/' + arr.url + '"></span>' + val;
},
operate: function (val, arr) {
switch(arr.type){
case 'file':
return '<a href="javascript:;" onclick="<API key>.callback(\'' + arr.url + '\')"></a>';
break;
case 'dir':
var path = '/' + arr.path;
return '<a href="javascript:;" onclick="<API key>.open(\'' + path + '\')"></a>';
break;
}
return '-';
},
refresh: function(){
$(this.datagrid).datagrid('reload');
},
tooltip: function(){
var that = <API key>;
$(that.datagrid).datagrid('getPanel').find('div.datagrid-body td[field="name"] div.datagrid-cell').each(function(){
var url = $(this).find('span:first').attr('url');
var ext = /[^\.]+$/.exec(url);
ext = ext[0].toLowerCase();
var content = null;
switch(ext){
case 'jpg':
case 'jpeg':
case 'png':
case 'bmp':
case 'gif':
content = '<img src="'+ url +'" height="160" />';
break;
}
if(content) $(this).tooltip({trackMouse: true,content: content});
});
},
click: function(rowIndex, rowData){
var that = <API key>;
switch(rowData.type){
case 'file':
that.callback(rowData.url);
break;
case 'dir':
var path = '/' + rowData.path;
that.open(path);
break;
}
},
open: function(path){
path = path.replace(/[\\\/]+/g, '/') || '/';
var queryParams = $(this.datagrid).datagrid('options').queryParams;
queryParams['path'] = path;
$(this.datagrid).datagrid('reload');
$('#<API key>').find('input[name="path"]').val(path);
},
back: function(that){
var path = $('#<API key>').find('input[name="path"]').val();
path = path.replace(/[\\\/][^\\\/]+[\\\/]?$/, '');
this.open(path);
},
upload: function(){
var that = this;
$.app.method.upload(
"<{:U('Upload/file')}>",
function(res){
if(res.status){
var url = res.info;
that.callback(url);
that.refresh();
}else{
$.app.method.tip('', (res.info || ''), 'error');
}
},
function(filename){
return that.verify(filename);
}
);
},
//url
input: function(that){
var _this = this;
$(that).parent('form:first').form('submit', {
onSubmit: function(){
var isValid = $(this).form('validate');
if (!isValid) return false;
var url = $(that).prev('input[type="text"]').val();
_this.callback(url);
return false;
}
});
},
verify: function(filename){
<notempty name="ext">
if(!filename.match(/\.<{:implode('$|\\.', $ext)}>$/i)){
$.app.method.tip('', '', 'error');
return false;
}
</notempty>
return true;
},
callback: function(url){
if(!this.verify(url)) return false;
<if condition="$callback">
<{$callback}>(url);
</if>
}
};
</script> |
#include <boost/config.hpp>
#if defined(BOOST_MSVC)
#pragma warning(disable: 4786) // identifier truncated in debug info
#pragma warning(disable: 4710) // function not inlined
#pragma warning(disable: 4711) // function selected for automatic inline expansion
#pragma warning(disable: 4514) // unreferenced inline removed
#endif
#include <boost/phoenix/core.hpp>
#include <boost/phoenix/bind.hpp>
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
#pragma warning(push, 3)
#endif
#include <iostream>
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
#pragma warning(pop)
#endif
#include <boost/detail/lightweight_test.hpp>
#include <boost/shared_ptr.hpp>
struct X
{
int v_;
X( int v ): v_( v )
{
}
int f()
{
return v_;
}
};
struct Y
{
boost::shared_ptr<X> f()
{
return boost::shared_ptr<X>( new X( 42 ) );
}
};
int main()
{
using boost::phoenix::bind;
//using boost::phoenix::placeholders::_1;
Y y;
// Change bind_rv_sp_test.cpp to bind to _1. Renamed f to g in y
//BOOST_TEST( bind( &X::f, _1) ( bind( &Y::g, &y )()) == 42 );
//boost::shared_ptr<X> xp = bind( &Y::f, &y )();
boost::shared_ptr<X> xp = y.f();
// BOOST_TEST( bind( &X::f, xp)() == 42 );
BOOST_TEST( (*xp).f() == 42 );
return boost::report_errors();
} |
#include <my_global.h>
#include <<API key>.h>
#include "zlib.h"
#include <string.h>
static void usage()
{
printf("%s Ver 1.6 for %s at %s\n","zlib_decompress",SYSTEM_TYPE,
MACHINE_TYPE);
puts(<API key>("2015"));
puts("Decompress data compressed by mysqlpump using zlib compression "
"algorithm by reading from input file and writing uncompressed "
"data to output file");
printf("Usage: %s input_file output_file\n", "zlib_decompress");
}
static const int INPUT_BUFFER_SIZE= 1024 * 1024;
static const int OUTPUT_BUFFER_SIZE= 1024 * 1024;
int main(int argc, char **argv)
{
if (argc != 3)
{
usage();
exit(1);
}
FILE* input_file= fopen(argv[1], "rb");
FILE* output_file= fopen(argv[2], "wb");
if (input_file == NULL)
{
fprintf(stderr,
"zlib_decompress: [Error] Cannot open input file for reading.\n"
);
exit(1);
}
if (output_file == NULL)
{
fprintf(stderr,
"zlib_decompress: [Error] Cannot create output file.\n"
);
exit(1);
}
z_stream <API key>;
memset(&<API key>, 0, sizeof(<API key>));
inflateInit(&<API key>);
char* input_buffer= new char[INPUT_BUFFER_SIZE];
char* output_buffer= new char[OUTPUT_BUFFER_SIZE];
bool is_eof= false;
while (!is_eof)
{
int bytes_read= fread(input_buffer, 1, INPUT_BUFFER_SIZE, input_file);
if (bytes_read < INPUT_BUFFER_SIZE)
{
is_eof= feof(input_file);
if (!is_eof)
{
fprintf(stderr,
"zlib_decompress: [Error] Encountered problem during reading input.\n"
);
exit(1);
}
}
<API key>.avail_in= bytes_read;
<API key>.next_in= (Bytef*)input_buffer;
do
{
<API key>.avail_out= OUTPUT_BUFFER_SIZE;
<API key>.next_out= (Bytef*)output_buffer;
int res= inflate(&<API key>, Z_NO_FLUSH);
if (res == Z_STREAM_ERROR)
{
fprintf(stderr,
"zlib_decompress: [Error] Encountered problem during decompression.\n"
);
exit(1);
}
fwrite(output_buffer, 1,
OUTPUT_BUFFER_SIZE - <API key>.avail_out, output_file);
} while (<API key>.avail_out == 0);
}
inflateEnd(&<API key>);
delete[] input_buffer;
delete[] output_buffer;
fclose(input_file);
fclose(output_file);
exit(0);
} |
<?php
// no direct access
defined('_JEXEC') or die;
// import com_content route helper
require_once (JPATH_SITE.DS.'components'.DS.'com_content'.DS.'helpers'.DS.'route.php');
class <API key> {
// configuration array
private $config;
// constructor
function __construct($config) {
// init the style config
$this->config = $config;
}
// getData function
function getData($ids) {
// prepare an array
$results = array();
// prepare an query part
$query_ids = implode(',', $ids);
// generate the query
$database = JFactory::getDBO();
// SQL query for slides
$query = '
SELECT
`c`.`id` AS `id`,
`c`.`catid` AS `cid`,
`c`.`title` AS `title`,
`c`.`introtext` AS `introtext`
FROM
#__content AS `c`
WHERE
`c`.`id` IN ('.$query_ids.')
;';
// running query
$database->setQuery($query);
// if results exists
if( $datas = $database->loadObjectList() ) {
// parsing data
foreach($datas as $item) {
// array with prepared image
$results[$item->id] = array(
'id' => $item->id,
'cid' => $item->cid,
'title' => stripslashes($item->title),
'introtext' => $item->introtext,
'link' => JRoute::_(ContentHelperRoute::getArticleRoute($item->id, $item->cid))
);
}
}
// return the results
return $results;
}
function getDataK2($ids) {
require_once (JPATH_SITE.DS.'components'.DS.'com_k2'.DS.'helpers'.DS.'route.php');
// prepare an array
$results = array();
// prepare an query part
$query_ids = implode(',', $ids);
// generate the query
$database = JFactory::getDBO();
// SQL query for slides
$query = '
SELECT
`c`.`id` AS `id`,
`c`.`catid` AS `cid`,
`c`.`title` AS `title`,
`c`.`introtext` AS `introtext`,
`c`.alias AS `alias`,
`cats`.alias AS `cat_alias`
FROM
#__k2_items AS `c`
LEFT JOIN
#__k2_categories AS `cats`
ON cats.id = `c`.`id`
WHERE
`c`.`id` IN ('.$query_ids.')
;';
// running query
$database->setQuery($query);
// if results exists
if( $datas = $database->loadObjectList() ) {
// parsing data
foreach($datas as $item) {
// array with prepared image
$results[$item->id] = array(
'id' => $item->id,
'cid' => $item->cid,
'title' => stripslashes($item->title),
'introtext' => $item->introtext,
'link' => urldecode(JRoute::_(K2HelperRoute::getItemRoute($item->id.':'.urlencode($item->alias), $item->cid.':'.urlencode($item->cat_alias))))
);
}
}
// return the results
return $results;
}
}
/* eof */ |
/*
* Scripts for spells with SPELLFAMILY_SHAMAN and SPELLFAMILY_GENERIC spells used by shaman players.
* Ordered alphabetically using scriptname.
* Scriptnames of files in this file should be prefixed with "spell_sha_".
*/
#include "stdafx.hpp"
#include "Player.h"
#include "ScriptMgr.h"
#include "GridNotifiers.h"
#include "Unit.h"
#include "SpellScript.h"
#include "SpellAuraEffects.h"
enum ShamanSpells
{
<API key> = 52752,
<API key> = 6277,
<API key> = 52025,
<API key> = 57723,
<API key> = 1535,
<API key> = 8349,
<API key> = 55456,
<API key> = 55441,
<API key> = 51480,
<API key> = 64694,
<API key> = 52032,
<API key> = 39609,
SPELL_SHAMAN_SATED = 57724,
<API key> = 51483,
<API key> = 64695,
<API key> = 6474,
<API key> = 59566,
<API key> = 52042
};
enum ShamanSpellIcons
{
<API key> = 338,
<API key> = 3087
};
// 52759 - Ancestral Awakening (Proc)
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>);
bool Validate(SpellInfo const* /*spellInfo*/)
{
if (!sSpellMgr->GetSpellInfo(<API key>))
return false;
return true;
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
int32 damage = GetEffectValue();
if (GetHitUnit())
GetCaster()->CastCustomSpell(GetHitUnit(), <API key>, &damage, NULL, NULL, true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(<API key>::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// 51474 - Astral Shift
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public AuraScript
{
PrepareAuraScript(<API key>);
uint32 absorbPct;
bool Load()
{
absorbPct = GetSpellInfo()->Effects[EFFECT_0].CalcValue(GetCaster());
return true;
}
void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
{
// Set absorbtion amount to unlimited
amount = -1;
}
void Absorb(AuraEffect* /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
{
// reduces all damage taken while stun, fear or silence
if (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_FLEEING | UNIT_FLAG_SILENCED) || (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_STUNNED) && GetTarget()->HasAuraWithMechanic(1<<MECHANIC_STUN)))
absorbAmount = CalculatePct(dmgInfo.GetDamage(), absorbPct);
}
void Register()
{
DoEffectCalcAmount += <API key>(<API key>::CalculateAmount, EFFECT_0, <API key>);
OnEffectAbsorb += AuraEffectAbsorbFn(<API key>::Absorb, EFFECT_0);
}
};
AuraScript* GetAuraScript() const
{
return new <API key>();
}
};
// 2825 - Bloodlust
class spell_sha_bloodlust : public SpellScriptLoader
{
public:
spell_sha_bloodlust() : SpellScriptLoader("spell_sha_bloodlust") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>);
bool Validate(SpellInfo const* /*spellInfo*/)
{
if (!sSpellMgr->GetSpellInfo(SPELL_SHAMAN_SATED))
return false;
return true;
}
void <API key>(std::list<WorldObject*>& targets)
{
targets.remove_if(Trinity::UnitAuraCheck(true, SPELL_SHAMAN_SATED));
}
void ApplyDebuff()
{
if (Unit* target = GetHitUnit())
target->CastSpell(target, SPELL_SHAMAN_SATED, true);
}
void Register()
{
<API key> += <API key>(<API key>::<API key>, EFFECT_0, <API key>);
<API key> += <API key>(<API key>::<API key>, EFFECT_1, <API key>);
<API key> += <API key>(<API key>::<API key>, EFFECT_2, <API key>);
AfterHit += SpellHitFn(<API key>::ApplyDebuff);
}
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// -1064 - Chain Heal
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>);
bool Load()
{
firstHeal = true;
riptide = false;
return true;
}
void HandleHeal(SpellEffIndex /*effIndex*/)
{
if (firstHeal)
{
// Check if the target has Riptide
if (AuraEffect* aurEff = GetHitUnit()->GetAuraEffect(<API key>, SPELLFAMILY_SHAMAN, 0, 0, 0x10, GetCaster()->GetGUID()))
{
riptide = true;
// Consume it
GetHitUnit()->RemoveAura(aurEff->GetBase());
}
firstHeal = false;
}
// Riptide increases the Chain Heal effect by 25%
if (riptide)
SetHitHeal(GetHitHeal() * 1.25f);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(<API key>::HandleHeal, EFFECT_0, SPELL_EFFECT_HEAL);
}
bool firstHeal;
bool riptide;
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// 8171 - Cleansing Totem (Pulse)
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>);
bool Validate(SpellInfo const* /*spellInfo*/)
{
if (!sSpellMgr->GetSpellInfo(<API key>))
return false;
return true;
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
int32 bp = 1;
if (GetCaster() && GetHitUnit() && GetOriginalCaster())
GetCaster()->CastCustomSpell(GetHitUnit(), <API key>, NULL, &bp, NULL, true, NULL, NULL, GetOriginalCaster()->GetGUID());
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(<API key>::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// 6474 - Earthbind Totem - Fix Talent: Earthen Power
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public AuraScript
{
PrepareAuraScript(<API key>);
bool Validate(SpellInfo const* /*spellInfo*/)
{
if (!sSpellMgr->GetSpellInfo(<API key>) || !sSpellMgr->GetSpellInfo(<API key>))
return false;
return true;
}
void <API key>(AuraEffect const* /*aurEff*/)
{
if (!GetCaster())
return;
if (Player* owner = GetCaster()-><API key>())
if (AuraEffect* aur = owner->GetDummyAuraEffect(SPELLFAMILY_SHAMAN, 2289, 0))
if (roll_chance_i(aur->GetBaseAmount()))
GetTarget()->CastSpell((Unit*)NULL, <API key>, true);
}
void Apply(AuraEffect const* /*aurEff*/, <API key> /*mode*/)
{
if (!GetCaster())
return;
Player* owner = GetCaster()-><API key>();
if (!owner)
return;
// Storm, Earth and Fire
if (AuraEffect* aurEff = owner-><API key>(<API key>, EFFECT_1))
{
if (roll_chance_i(aurEff->GetAmount()))
GetCaster()->CastSpell(GetCaster(), <API key>, false);
}
}
void Register()
{
OnEffectPeriodic += <API key>(<API key>::<API key>, EFFECT_0, <API key>);
OnEffectApply += AuraEffectApplyFn(<API key>::Apply, EFFECT_0, <API key>, <API key>);
}
};
AuraScript* GetAuraScript() const
{
return new <API key>();
}
};
class <API key>
{
public:
<API key>() { }
bool operator() (WorldObject* target)
{
if (!target->ToUnit())
return true;
if (!target->ToUnit()->HasAuraWithMechanic(1 << MECHANIC_SNARE))
return true;
return false;
}
};
// 59566 - Earthen Power
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>);
void FilterTargets(std::list<WorldObject*>& unitList)
{
unitList.remove_if(<API key>());
}
void Register()
{
<API key> += <API key>(<API key>::FilterTargets, EFFECT_0, <API key>);
}
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// -1535 - Fire Nova
class spell_sha_fire_nova : public SpellScriptLoader
{
public:
spell_sha_fire_nova() : SpellScriptLoader("spell_sha_fire_nova") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>);
bool Validate(SpellInfo const* spellInfo)
{
if (!sSpellMgr->GetSpellInfo(<API key>) || sSpellMgr-><API key>(<API key>) != sSpellMgr-><API key>(spellInfo->Id))
return false;
uint8 rank = sSpellMgr->GetSpellRank(spellInfo->Id);
if (!sSpellMgr->GetSpellWithRank(<API key>, rank, true))
return false;
return true;
}
SpellCastResult CheckFireTotem()
{
// fire totem
if (!GetCaster()->m_SummonSlot[1])
{
<API key>(<API key>);
return <API key>;
}
return SPELL_CAST_OK;
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
if (Unit* caster = GetCaster())
{
uint8 rank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id);
if (uint32 spellId = sSpellMgr->GetSpellWithRank(<API key>, rank))
{
Creature* totem = caster->GetMap()->GetCreature(caster->m_SummonSlot[1]);
if (totem && totem->isTotem())
caster->CastSpell(totem, spellId, true);
}
}
}
void Register()
{
OnCheckCast += SpellCheckCastFn(<API key>::CheckFireTotem);
OnEffectHitTarget += SpellEffectFn(<API key>::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// -8050 - Flame Shock
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public AuraScript
{
PrepareAuraScript(<API key>);
bool Validate(SpellInfo const* /*spell*/)
{
if (!sSpellMgr->GetSpellInfo(<API key>))
return false;
if (!sSpellMgr->GetSpellInfo(<API key>))
return false;
return true;
}
void HandleDispel(DispelInfo* /*dispelInfo*/)
{
if (Unit* caster = GetCaster())
// Lava Flows
if (AuraEffect const* aurEff = caster->GetDummyAuraEffect(SPELLFAMILY_SHAMAN, <API key>, EFFECT_0))
{
if (sSpellMgr-><API key>(<API key>) != sSpellMgr-><API key>(aurEff->GetId()))
return;
uint8 rank = sSpellMgr->GetSpellRank(aurEff->GetId());
caster->CastSpell(caster, sSpellMgr->GetSpellWithRank(<API key>, rank), true);
}
}
void Register()
{
AfterDispel += AuraDispelFn(<API key>::HandleDispel);
}
};
AuraScript* GetAuraScript() const
{
return new <API key>();
}
};
// 52041, 52046, 52047, 52048, 52049, 52050, 58759, 58760, 58761 - Healing Stream Totem
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>);
bool Validate(SpellInfo const* /*spellInfo*/)
{
if (!sSpellMgr->GetSpellInfo(<API key>) || !sSpellMgr->GetSpellInfo(<API key>))
return false;
return true;
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
int32 damage = GetEffectValue();
SpellInfo const* triggeringSpell = GetTriggeringSpell();
if (Unit* target = GetHitUnit())
if (Unit* caster = GetCaster())
{
if (Unit* owner = caster->GetOwner())
{
if (triggeringSpell)
damage = int32(owner-><API key>(target, triggeringSpell, damage, HEAL));
// Restorative Totems
if (AuraEffect* dummy = owner->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, <API key>, 1))
AddPct(damage, dummy->GetAmount());
// Glyph of Healing Stream Totem
if (AuraEffect const* aurEff = owner->GetAuraEffect(<API key>, EFFECT_0))
AddPct(damage, aurEff->GetAmount());
damage = int32(target-><API key>(owner, triggeringSpell, damage, HEAL));
}
caster->CastCustomSpell(target, <API key>, &damage, 0, 0, true, 0, 0, GetOriginalCaster()->GetGUID());
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(<API key>::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// 32182 - Heroism
class spell_sha_heroism : public SpellScriptLoader
{
public:
spell_sha_heroism() : SpellScriptLoader("spell_sha_heroism") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>);
bool Validate(SpellInfo const* /*spellInfo*/)
{
if (!sSpellMgr->GetSpellInfo(<API key>))
return false;
return true;
}
void <API key>(std::list<WorldObject*>& targets)
{
targets.remove_if(Trinity::UnitAuraCheck(true, <API key>));
}
void ApplyDebuff()
{
if (Unit* target = GetHitUnit())
target->CastSpell(target, <API key>, true);
}
void Register()
{
<API key> += <API key>(<API key>::<API key>, EFFECT_0, <API key>);
<API key> += <API key>(<API key>::<API key>, EFFECT_1, <API key>);
<API key> += <API key>(<API key>::<API key>, EFFECT_2, <API key>);
AfterHit += SpellHitFn(<API key>::ApplyDebuff);
}
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// 60103 - Lava Lash
class spell_sha_lava_lash : public SpellScriptLoader
{
public:
spell_sha_lava_lash() : SpellScriptLoader("spell_sha_lava_lash") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>)
bool Load()
{
return GetCaster()->GetTypeId() == TYPEID_PLAYER;
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
if (Player* caster = GetCaster()->ToPlayer())
{
int32 damage = GetEffectValue();
int32 hitDamage = GetHitDamage();
if (caster->GetItemByPos(<API key>, <API key>))
{
// Damage is increased by 25% if your off-hand weapon is enchanted with Flametongue.
if (caster->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, 0x200000, 0, 0))
AddPct(hitDamage, damage);
SetHitDamage(hitDamage);
}
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(<API key>::HandleDummy, EFFECT_1, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// 52031, 52033, 52034, 52035, 52036, 58778, 58779, 58780 - Mana Spring Totem
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>);
bool Validate(SpellInfo const* /*spellInfo*/)
{
if (!sSpellMgr->GetSpellInfo(<API key>))
return false;
return true;
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
int32 damage = GetEffectValue();
if (Unit* target = GetHitUnit())
if (Unit* caster = GetCaster())
if (target->getPowerType() == POWER_MANA)
caster->CastCustomSpell(target, <API key>, &damage, 0, 0, true, 0, 0, GetOriginalCaster()->GetGUID());
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(<API key>::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// 39610 - Mana Tide Totem
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public SpellScript
{
PrepareSpellScript(<API key>);
bool Validate(SpellInfo const* /*spellInfo*/)
{
if (!sSpellMgr->GetSpellInfo(<API key>) || !sSpellMgr->GetSpellInfo(<API key>))
return false;
return true;
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
if (Unit* caster = GetCaster())
if (Unit* unitTarget = GetHitUnit())
{
if (unitTarget->getPowerType() == POWER_MANA)
{
int32 effValue = GetEffectValue();
// Glyph of Mana Tide
if (Unit* owner = caster->GetOwner())
if (AuraEffect* dummy = owner->GetAuraEffect(<API key>, 0))
effValue += dummy->GetAmount();
// Regenerate 6% of Total Mana Every 3 secs
int32 effBasePoints0 = int32(CalculatePct(unitTarget->GetMaxPower(POWER_MANA), effValue));
caster->CastCustomSpell(unitTarget, <API key>, &effBasePoints0, NULL, NULL, true, NULL, NULL, GetOriginalCaster()->GetGUID());
}
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(<API key>::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new <API key>();
}
};
// 6495 - Sentry Totem
class <API key> : public SpellScriptLoader
{
public:
<API key>() : SpellScriptLoader("<API key>") { }
class <API key> : public AuraScript
{
PrepareAuraScript(<API key>);
bool Validate(SpellInfo const* /*spell*/)
{
if (!sSpellMgr->GetSpellInfo(<API key>))
return false;
return true;
}
void AfterApply(AuraEffect const* /*aurEff*/, <API key> /*mode*/)
{
if (Unit* caster = GetCaster())
if (Creature* totem = caster->GetMap()->GetCreature(caster->m_SummonSlot[4]))
if (totem->isTotem())
caster->CastSpell(totem, <API key>, true);
}
void AfterRemove(AuraEffect const* /*aurEff*/, <API key> /*mode*/)
{
if (Unit* caster = GetCaster())
if (caster->GetTypeId() == TYPEID_PLAYER)
caster->ToPlayer()-><API key>();
}
void Register()
{
AfterEffectApply += AuraEffectApplyFn(<API key>::AfterApply, EFFECT_1, SPELL_AURA_DUMMY, <API key>);
AfterEffectRemove += AuraEffectRemoveFn(<API key>::AfterRemove, EFFECT_1, SPELL_AURA_DUMMY, <API key>);
}
};
AuraScript* GetAuraScript() const
{
return new <API key>();
}
};
void <API key>()
{
new <API key>();
new <API key>();
new spell_sha_bloodlust();
new <API key>();
new <API key>();
new <API key>();
new <API key>();
new spell_sha_fire_nova();
new <API key>();
new <API key>();
new spell_sha_heroism();
new spell_sha_lava_lash();
new <API key>();
new <API key>();
new <API key>();
} |
/*
* There are duplicates of this code in:
* - tools/blktap2/drivers/hashtable.h
* - tools/vtpm_manager/util/hashtable.h
*/
#ifndef <API key>
#define <API key>
struct hashtable;
/* Example of use:
*
* struct hashtable *h;
* struct some_key *k;
* struct some_value *v;
*
* static unsigned int hash_from_key_fn( void *k );
* static int keys_equal_fn ( void *key1, void *key2 );
*
* h = create_hashtable(16, hash_from_key_fn, keys_equal_fn);
* k = (struct some_key *) malloc(sizeof(struct some_key));
* v = (struct some_value *) malloc(sizeof(struct some_value));
*
* (initialise k and v to suitable values)
*
* if (! hashtable_insert(h,k,v) )
* { exit(-1); }
*
* if (NULL == (found = hashtable_search(h,k) ))
* { printf("not found!"); }
*
* if (NULL == (found = hashtable_remove(h,k) ))
* { printf("Not found\n"); }
*
*/
/* Macros may be used to define type-safe(r) hashtable access functions, with
* methods specialized to take known key and value types as parameters.
*
* Example:
*
* Insert this at the start of your file:
*
* <API key>(insert_some, struct some_key, struct some_value);
* <API key>(search_some, struct some_key, struct some_value);
* <API key>(remove_some, struct some_key, struct some_value);
*
* This defines the functions 'insert_some', 'search_some' and 'remove_some'.
* These operate just like hashtable_insert etc., with the same parameters,
* but their function signatures have 'struct some_key *' rather than
* 'void *', and hence can generate compile time errors if your program is
* supplying incorrect data as a key (and similarly for value).
*
* Note that the hash and key equality functions passed to create_hashtable
* still take 'void *' parameters instead of 'some key *'. This shouldn't be
* a difficult issue as they're only defined and passed once, and the other
* functions will ensure that only valid keys are supplied to them.
*
* The cost for this checking is increased code size and runtime overhead
* - if performance is important, it may be worth switching back to the
* unsafe methods once your program has been debugged with the safe methods.
* This just requires switching to some simple alternative defines - eg:
* #define insert_some hashtable_insert
*
*/
/*****************************************************************************
* create_hashtable
* @name create_hashtable
* @param minsize minimum initial size of hashtable
* @param hashfunction function for hashing keys
* @param key_eq_fn function for determining key equality
* @return newly created hashtable or NULL on failure
*/
struct hashtable *
create_hashtable(unsigned int minsize,
unsigned int (*hashfunction) (void*),
int (*key_eq_fn) (void*,void*));
/*****************************************************************************
* hashtable_insert
* @name hashtable_insert
* @param h the hashtable to insert into
* @param k the key - hashtable claims ownership and will free on removal
* @param v the value - does not claim ownership
* @return non-zero for successful insertion
*
* This function will cause the table to expand if the insertion would take
* the ratio of entries to table size over the maximum load factor.
*
* This function does not check for repeated insertions with a duplicate key.
* The value returned when using a duplicate key is undefined -- when
* the hashtable changes size, the order of retrieval of duplicate key
* entries is reversed.
* If in doubt, remove before insert.
*/
int
hashtable_insert(struct hashtable *h, void *k, void *v);
#define <API key>(fnname, keytype, valuetype) \
int fnname (struct hashtable *h, keytype *k, valuetype *v) \
{ \
return hashtable_insert(h,k,v); \
}
/*****************************************************************************
* hashtable_search
* @name hashtable_search
* @param h the hashtable to search
* @param k the key to search for - does not claim ownership
* @return the value associated with the key, or NULL if none found
*/
void *
hashtable_search(struct hashtable *h, void *k);
#define <API key>(fnname, keytype, valuetype) \
valuetype * fnname (struct hashtable *h, keytype *k) \
{ \
return (valuetype *) (hashtable_search(h,k)); \
}
/*****************************************************************************
* hashtable_remove
* @name hashtable_remove
* @param h the hashtable to remove the item from
* @param k the key to search for - does not claim ownership
* @return the value associated with the key, or NULL if none found
*/
void * /* returns value */
hashtable_remove(struct hashtable *h, void *k);
#define <API key>(fnname, keytype, valuetype) \
valuetype * fnname (struct hashtable *h, keytype *k) \
{ \
return (valuetype *) (hashtable_remove(h,k)); \
}
/*****************************************************************************
* hashtable_count
* @name hashtable_count
* @param h the hashtable
* @return the number of items stored in the hashtable
*/
unsigned int
hashtable_count(struct hashtable *h);
/*****************************************************************************
* hashtable_destroy
* @name hashtable_destroy
* @param h the hashtable
* @param free_values whether to call 'free' on the remaining values
*/
void
hashtable_destroy(struct hashtable *h, int free_values);
#endif /* <API key> */ |
#ifndef CLICK_FIXCONFIG_H
#define CLICK_FIXCONFIG_H 1
#if CLICK_LINUXMODULE && <API key>
// The .smp_locks section and C++-style weak linkage interact badly.
# if CONFIG_SMP && (defined(__i386__) || defined(__x86_64__))
# include <asm/alternative.h>
# undef LOCK_PREFIX
# define LOCK_PREFIX "lock ; "
# endif
#endif
#endif |
#! /bin/sh
# This program is free software; you can redistribute it and/or modify
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
# This program is distributed in the hope that it will be useful,
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# Weak "grepping" test trying to ensure that remaking rules in a subdir
# are correctly generated.
# See also sister functional test 'remake-subdir-only.sh'.
. test-init.sh
cat > configure.ac <<END
AC_INIT([$me], [1.0])
AM_INIT_AUTOMAKE
AC_CONFIG_FILES([sub/Makefile])
AC_OUTPUT
END
mkdir sub
: > sub/Makefile.am
$ACLOCAL
$AUTOMAKE
grep '^Makefile' sub/Makefile.in
grep '\$(AUTOMAKE).* sub/Makefile' sub/Makefile.in
: |
#ifdef HAS_DX
#include <DirectXPackedVector.h>
#include "Application.h"
#include "RenderSystemDX.h"
#include "cores/VideoPlayer/VideoRenderers/RenderManager.h"
#include "guilib/D3DResource.h"
#include "guilib/GUIShaderDX.h"
#include "guilib/GUITextureD3D.h"
#include "guilib/GUIWindowManager.h"
#include "settings/AdvancedSettings.h"
#include "threads/SingleLock.h"
#include "utils/MathUtils.h"
#include "utils/TimeUtils.h"
#include "utils/log.h"
#include "win32/WIN32Util.h"
#include "win32/dxerr.h"
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "dxguid.lib")
#define RATIONAL_TO_FLOAT(rational) ((rational.Denominator != 0) ? (float)rational.Numerator / (float)rational.Denominator : 0.0)
using namespace DirectX::PackedVector;
CRenderSystemDX::CRenderSystemDX() : CRenderSystemBase()
{
<API key> = <API key>;
m_hFocusWnd = nullptr;
m_hDeviceWnd = nullptr;
m_nBackBufferWidth = 0;
m_nBackBufferHeight = 0;
m_bFullScreenDevice = false;
m_bVSync = true;
m_nDeviceStatus = S_OK;
m_inScene = false;
m_needNewDevice = false;
m_resizeInProgress = false;
m_screenHeight = 0;
m_systemFreq = <API key>();
m_defaultD3DUsage = D3D11_USAGE_DEFAULT;
m_featureLevel = <API key>;
m_driverType = <API key>;
m_adapter = nullptr;
m_pOutput = nullptr;
m_dxgiFactory = nullptr;
m_pD3DDev = nullptr;
m_pImdContext = nullptr;
m_pContext = nullptr;
m_pSwapChain = nullptr;
m_pSwapChain1 = nullptr;
m_pRenderTargetView = nullptr;
m_depthStencilState = nullptr;
m_depthStencilView = nullptr;
m_BlendEnableState = nullptr;
m_BlendDisableState = nullptr;
m_BlendEnabled = false;
m_RSScissorDisable = nullptr;
m_RSScissorEnable = nullptr;
m_ScissorsEnabled = false;
m_pTextureRight = nullptr;
<API key> = nullptr;
<API key> = nullptr;
m_pGUIShader = nullptr;
m_bResizeRequred = false;
m_bHWStereoEnabled = false;
ZeroMemory(&m_cachedMode, sizeof(m_cachedMode));
ZeroMemory(&m_viewPort, sizeof(m_viewPort));
ZeroMemory(&m_scissor, sizeof(CRect));
ZeroMemory(&m_adapterDesc, sizeof(DXGI_ADAPTER_DESC));
<API key> = false;
m_bStereoEnabled = false;
}
CRenderSystemDX::~CRenderSystemDX()
{
}
bool CRenderSystemDX::InitRenderSystem()
{
m_bVSync = true;
CLog::Log(LOGDEBUG, __FUNCTION__" - Initializing D3D11 Factory...");
HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(&m_dxgiFactory));
if (FAILED(hr))
{
CLog::Log(LOGERROR, __FUNCTION__" - D3D11 initialization failed.");
return false;
}
UpdateMonitor();
return CreateDevice();
}
void CRenderSystemDX::SetRenderParams(unsigned int width, unsigned int height, bool fullScreen, float refreshRate)
{
m_nBackBufferWidth = width;
m_nBackBufferHeight = height;
m_bFullScreenDevice = fullScreen;
m_refreshRate = refreshRate;
}
void CRenderSystemDX::SetMonitor(HMONITOR monitor)
{
if (!m_dxgiFactory)
return;
DXGI_OUTPUT_DESC outputDesc;
if (m_pOutput && SUCCEEDED(m_pOutput->GetDesc(&outputDesc)) && outputDesc.Monitor == monitor)
return;
// find the appropriate screen
IDXGIAdapter1* pAdapter;
for (unsigned i = 0; m_dxgiFactory->EnumAdapters1(i, &pAdapter) != <API key>; ++i)
{
DXGI_ADAPTER_DESC1 adaperDesc;
pAdapter->GetDesc1(&adaperDesc);
IDXGIOutput* pOutput;
for (unsigned j = 0; pAdapter->EnumOutputs(j, &pOutput) != <API key>; ++j)
{
pOutput->GetDesc(&outputDesc);
if (outputDesc.Monitor == monitor)
{
CLog::Log(LOGDEBUG, __FUNCTION__" - Selected %S output. ", outputDesc.DeviceName);
// update monitor info
SAFE_RELEASE(m_pOutput);
m_pOutput = pOutput;
// check if adapter is changed
if ( m_adapterDesc.AdapterLuid.HighPart != adaperDesc.AdapterLuid.HighPart
|| m_adapterDesc.AdapterLuid.LowPart != adaperDesc.AdapterLuid.LowPart)
{
CLog::Log(LOGDEBUG, __FUNCTION__" - Selected %S adapter. ", m_adapterDesc.Description);
pAdapter->GetDesc(&m_adapterDesc);
SAFE_RELEASE(m_adapter);
m_adapter = pAdapter;
m_needNewDevice = true;
return;
}
return;
}
pOutput->Release();
}
pAdapter->Release();
}
}
bool CRenderSystemDX::ResetRenderSystem(int width, int height, bool fullScreen, float refreshRate)
{
if (!m_pD3DDev)
return false;
if (m_hDeviceWnd != nullptr)
{
HMONITOR hMonitor = MonitorFromWindow(m_hDeviceWnd, <API key>);
if (hMonitor)
SetMonitor(hMonitor);
}
SetRenderParams(width, height, fullScreen, refreshRate);
CRect rc(0, 0, float(width), float(height));
SetViewPort(rc);
if (!m_needNewDevice)
{
<API key>();
<API key>();
}
else
{
OnDeviceLost();
OnDeviceReset();
}
return true;
}
void CRenderSystemDX::OnMove()
{
if (!m_bRenderCreated)
return;
DXGI_OUTPUT_DESC outputDesc;
m_pOutput->GetDesc(&outputDesc);
HMONITOR newMonitor = MonitorFromWindow(m_hDeviceWnd, <API key>);
if (newMonitor != NULL && outputDesc.Monitor != newMonitor)
{
SetMonitor(newMonitor);
if (m_needNewDevice)
{
CLog::Log(LOGDEBUG, "%s - Adapter changed, reseting render system.", __FUNCTION__);
ResetRenderSystem(m_nBackBufferWidth, m_nBackBufferHeight, m_bFullScreenDevice, m_refreshRate);
}
}
}
void CRenderSystemDX::OnResize(unsigned int width, unsigned int height)
{
if (!m_bRenderCreated)
return;
m_nBackBufferWidth = width;
m_nBackBufferHeight = height;
<API key>();
}
void CRenderSystemDX::<API key>(IDXGIOutput* output, DXGI_MODE_DESC* <API key>, bool useCached /*= false*/)
{
DXGI_OUTPUT_DESC outputDesc;
output->GetDesc(&outputDesc);
HMONITOR hMonitor = outputDesc.Monitor;
MONITORINFOEX monitorInfo;
monitorInfo.cbSize = sizeof(MONITORINFOEX);
GetMonitorInfo(hMonitor, &monitorInfo);
DEVMODE devMode;
devMode.dmSize = sizeof(DEVMODE);
devMode.dmDriverExtra = 0;
EnumDisplaySettings(monitorInfo.szDevice, <API key>, &devMode);
bool <API key> = 1 == devMode.dmDisplayFrequency || 0 == devMode.dmDisplayFrequency;
float refreshRate = RATIONAL_TO_FLOAT(m_cachedMode.RefreshRate);
// this needed to improve performance for VideoSync bacause <API key> is very slow
if (!useCached
|| m_cachedMode.Width != devMode.dmPelsWidth
|| m_cachedMode.Height != devMode.dmPelsHeight
|| long(refreshRate) != devMode.dmDisplayFrequency)
{
DXGI_MODE_DESC current;
current.Width = devMode.dmPelsWidth;
current.Height = devMode.dmPelsHeight;
current.RefreshRate.Numerator = <API key> ? 0 : devMode.dmDisplayFrequency;
current.RefreshRate.Denominator = <API key> ? 0 : 1;
current.Format = <API key>;
current.ScanlineOrdering = m_interlaced ? <API key> : <API key>;
current.Scaling = <API key>;
output-><API key>(¤t, &m_cachedMode, m_pD3DDev);
}
ZeroMemory(<API key>, sizeof(DXGI_MODE_DESC));
<API key>->Width = m_cachedMode.Width;
<API key>->Height = m_cachedMode.Height;
<API key>->RefreshRate.Numerator = m_cachedMode.RefreshRate.Numerator;
<API key>->RefreshRate.Denominator = m_cachedMode.RefreshRate.Denominator;
<API key>->Format = m_cachedMode.Format;
<API key>->ScanlineOrdering = m_cachedMode.ScanlineOrdering;
<API key>->Scaling = m_cachedMode.Scaling;
}
void CRenderSystemDX::GetDisplayMode(DXGI_MODE_DESC *mode, bool useCached /*= false*/)
{
<API key>(m_pOutput, mode, useCached);
}
inline void DXWait(ID3D11Device* pDevice, ID3D11DeviceContext* pContext)
{
ID3D11Query* wait = NULL;
CD3D11_QUERY_DESC qd(D3D11_QUERY_EVENT);
if (SUCCEEDED(pDevice->CreateQuery(&qd, &wait)))
{
pContext->End(wait);
while (S_FALSE == pContext->GetData(wait, NULL, 0, 0))
Sleep(1);
}
SAFE_RELEASE(wait);
}
void CRenderSystemDX::<API key>()
{
if (!m_bRenderCreated)
return;
HRESULT hr = S_OK;
BOOL bFullScreen;
m_pSwapChain->GetFullscreenState(&bFullScreen, NULL);
// full-screen to windowed translation. Only change FS state and return
if (!!bFullScreen && m_useWindowedDX)
{
CLog::Log(LOGDEBUG, "%s - Switching swap chain to windowed mode.", __FUNCTION__);
OnDisplayLost();
hr = m_pSwapChain->SetFullscreenState(false, NULL);
if (SUCCEEDED(hr))
m_bResizeRequred = true;
else
CLog::Log(LOGERROR, "%s - Failed switch full screen state: %s.", __FUNCTION__, GetErrorDescription(hr).c_str());
}
// true full-screen
else if (m_bFullScreenDevice && !m_useWindowedDX)
{
IDXGIOutput* pOutput = NULL;
m_pSwapChain->GetContainingOutput(&pOutput);
DXGI_OUTPUT_DESC trgDesc, currDesc;
m_pOutput->GetDesc(&trgDesc);
pOutput->GetDesc(&currDesc);
if (trgDesc.Monitor != currDesc.Monitor || !bFullScreen)
{
// swap chain requires to change FS mode after resize or transition from windowed to full-screen.
CLog::Log(LOGDEBUG, "%s - Switching swap chain to fullscreen state.", __FUNCTION__);
OnDisplayLost();
hr = m_pSwapChain->SetFullscreenState(true, m_pOutput);
if (SUCCEEDED(hr))
m_bResizeRequred = true;
else
CLog::Log(LOGERROR, "%s - Failed switch full screen state: %s.", __FUNCTION__, GetErrorDescription(hr).c_str());
}
SAFE_RELEASE(pOutput);
// do not change modes if hw stereo enabled
if (m_bHWStereoEnabled)
goto end;
<API key> scDesc;
m_pSwapChain->GetDesc(&scDesc);
DXGI_MODE_DESC currentMode, // closest to current mode
toMatchMode, // required mode
matchedMode; // closest to required mode
// find current mode on target output
<API key>(m_pOutput, ¤tMode);
float currentRefreshRate = RATIONAL_TO_FLOAT(currentMode.RefreshRate);
CLog::Log(LOGDEBUG, "%s - Current display mode is: %dx%d@%0.3f", __FUNCTION__, currentMode.Width, currentMode.Height, currentRefreshRate);
// use backbuffer dimention to find required display mode
toMatchMode.Width = m_nBackBufferWidth;
toMatchMode.Height = m_nBackBufferHeight;
bool <API key> = 0 == m_refreshRate;
toMatchMode.RefreshRate.Numerator = <API key> ? 0 : m_refreshRate;
toMatchMode.RefreshRate.Denominator = <API key> ? 0 : 1;
toMatchMode.Format = scDesc.BufferDesc.Format;
toMatchMode.Scaling = scDesc.BufferDesc.Scaling;
toMatchMode.ScanlineOrdering = scDesc.BufferDesc.ScanlineOrdering;
// find closest mode
m_pOutput-><API key>(&toMatchMode, &matchedMode, m_pD3DDev);
float matchedRefreshRate = RATIONAL_TO_FLOAT(matchedMode.RefreshRate);
CLog::Log(LOGDEBUG, "%s - Found matched mode: %dx%d@%0.3f", __FUNCTION__, matchedMode.Width, matchedMode.Height, matchedRefreshRate);
// change mode if required (current != required)
if ( currentMode.Width != matchedMode.Width
|| currentMode.Height != matchedMode.Height
|| currentRefreshRate != matchedRefreshRate)
{
// change monitor resolution (in fullscreen mode) to required mode
CLog::Log(LOGDEBUG, "%s - Switching mode to %dx%d@%0.3f.", __FUNCTION__, matchedMode.Width, matchedMode.Height, matchedRefreshRate);
if (!m_bResizeRequred)
OnDisplayLost();
hr = m_pSwapChain->ResizeTarget(&matchedMode);
if (SUCCEEDED(hr))
m_bResizeRequred = true;
else
CLog::Log(LOGERROR, "%s - Failed to switch output mode: %s", __FUNCTION__, GetErrorDescription(hr).c_str());
}
}
end:
<API key>();
}
bool CRenderSystemDX::IsFormatSupport(DXGI_FORMAT format, unsigned int usage)
{
UINT supported;
m_pD3DDev->CheckFormatSupport(format, &supported);
return (supported & usage) != 0;
}
bool CRenderSystemDX::DestroyRenderSystem()
{
DeleteDevice();
// restore stereo setting on exit
if (g_advancedSettings.<API key>)
<API key>(<API key>);
SAFE_RELEASE(m_pOutput);
SAFE_RELEASE(m_adapter);
SAFE_RELEASE(m_dxgiFactory);
return true;
}
void CRenderSystemDX::DeleteDevice()
{
CSingleLock lock(m_resourceSection);
if (m_pGUIShader)
m_pGUIShader->End();
// tell any shared resources
for (std::vector<ID3DResource *>::iterator i = m_resources.begin(); i != m_resources.end(); ++i)
(*i)->OnDestroyDevice();
if (m_pSwapChain)
m_pSwapChain->SetFullscreenState(false, NULL);
SAFE_DELETE(m_pGUIShader);
SAFE_RELEASE(m_pTextureRight);
SAFE_RELEASE(<API key>);
SAFE_RELEASE(<API key>);
SAFE_RELEASE(m_BlendEnableState);
SAFE_RELEASE(m_BlendDisableState);
SAFE_RELEASE(m_RSScissorDisable);
SAFE_RELEASE(m_RSScissorEnable);
SAFE_RELEASE(m_depthStencilState);
SAFE_RELEASE(m_depthStencilView);
SAFE_RELEASE(m_pRenderTargetView);
if (m_pContext && m_pContext != m_pImdContext)
{
m_pContext->ClearState();
m_pContext->Flush();
SAFE_RELEASE(m_pContext);
}
if (m_pImdContext)
{
m_pImdContext->ClearState();
m_pImdContext->Flush();
SAFE_RELEASE(m_pImdContext);
}
SAFE_RELEASE(m_pSwapChain);
SAFE_RELEASE(m_pSwapChain1);
SAFE_RELEASE(m_pD3DDev);
#ifdef _DEBUG
if (m_d3dDebug)
{
m_d3dDebug-><API key>(D3D11_RLDO_SUMMARY | D3D11_RLDO_DETAIL);
SAFE_RELEASE(m_d3dDebug);
}
#endif
m_bResizeRequred = false;
m_bHWStereoEnabled = false;
m_bRenderCreated = false;
m_bStereoEnabled = false;
}
void CRenderSystemDX::OnDeviceLost()
{
CSingleLock lock(m_resourceSection);
g_windowManager.SendMessage(GUI_MSG_NOTIFY_ALL, 0, 0, <API key>);
OnDisplayLost();
if (m_needNewDevice)
DeleteDevice();
else
{
// just resetting the device
for (std::vector<ID3DResource *>::iterator i = m_resources.begin(); i != m_resources.end(); ++i)
(*i)->OnLostDevice();
}
}
void CRenderSystemDX::OnDeviceReset()
{
CSingleLock lock(m_resourceSection);
if (m_needNewDevice)
CreateDevice();
if (m_bRenderCreated)
{
// we're back
for (std::vector<ID3DResource *>::iterator i = m_resources.begin(); i != m_resources.end(); ++i)
(*i)->OnResetDevice();
g_windowManager.SendMessage(GUI_MSG_NOTIFY_ALL, 0, 0, <API key>);
}
OnDisplayReset();
}
bool CRenderSystemDX::CreateDevice()
{
CSingleLock lock(m_resourceSection);
HRESULT hr;
SAFE_RELEASE(m_pD3DDev);
D3D_FEATURE_LEVEL featureLevels[] =
{
<API key>,
<API key>,
<API key>,
<API key>,
<API key>,
<API key>,
<API key>,
};
// the VIDEO_SUPPORT flag force lowering feature level if current env not support video on 11_1
UINT createDeviceFlags = <API key>;
#ifdef _DEBUG
createDeviceFlags |= <API key>;
#endif
D3D_DRIVER_TYPE driverType = m_adapter == nullptr ? <API key> : <API key>;
// we should specify <API key> if create device with specified adapter.
hr = D3D11CreateDevice(m_adapter, driverType, nullptr, createDeviceFlags, featureLevels, ARRAYSIZE(featureLevels),
D3D11_SDK_VERSION, &m_pD3DDev, &m_featureLevel, &m_pImdContext);
if (FAILED(hr))
{
// DirectX 11.0 platforms will not recognize <API key> so we need to retry without it
CLog::Log(LOGDEBUG, "%s - First try to create device failed with error: %s.", __FUNCTION__, GetErrorDescription(hr).c_str());
CLog::Log(LOGDEBUG, "%s - Trying to create device with lowest feature level: %#x.", __FUNCTION__, featureLevels[1]);
hr = D3D11CreateDevice(m_adapter, driverType, nullptr, createDeviceFlags, &featureLevels[1], ARRAYSIZE(featureLevels) - 1,
D3D11_SDK_VERSION, &m_pD3DDev, &m_featureLevel, &m_pImdContext);
if (FAILED(hr))
{
// still failed. seems driver doesn't support video API acceleration, try without VIDEO_SUPPORT flag
CLog::Log(LOGDEBUG, "%s - Next try to create device failed with error: %s.", __FUNCTION__, GetErrorDescription(hr).c_str());
CLog::Log(LOGDEBUG, "%s - Trying to create device without video API support.", __FUNCTION__);
createDeviceFlags &= ~<API key>;
hr = D3D11CreateDevice(m_adapter, driverType, nullptr, createDeviceFlags, &featureLevels[1], ARRAYSIZE(featureLevels) - 1,
D3D11_SDK_VERSION, &m_pD3DDev, &m_featureLevel, &m_pImdContext);
if (SUCCEEDED(hr))
CLog::Log(LOGNOTICE, "%s - Your video driver doesn't support DirectX 11 Video Acceleration API. Application is not be able to use hardware video processing and decoding", __FUNCTION__);
}
}
if (FAILED(hr))
{
CLog::Log(LOGERROR, "%s - D3D11 device creation failure with error %s.", __FUNCTION__, GetErrorDescription(hr).c_str());
return false;
}
if (!m_adapter)
{
// get adapter from device if it was not detected previously
IDXGIDevice1* pDXGIDevice = nullptr;
if (SUCCEEDED(m_pD3DDev->QueryInterface(__uuidof(IDXGIDevice1), reinterpret_cast<void**>(&pDXGIDevice))))
{
IDXGIAdapter *pAdapter = nullptr;
if (SUCCEEDED(pDXGIDevice->GetAdapter(&pAdapter)))
{
hr = pAdapter->QueryInterface(__uuidof(IDXGIAdapter1), reinterpret_cast<void**>(&m_adapter));
SAFE_RELEASE(pAdapter);
if (FAILED(hr))
return false;
m_adapter->GetDesc(&m_adapterDesc);
CLog::Log(LOGDEBUG, __FUNCTION__" - Selected %S adapter. ", m_adapterDesc.Description);
}
SAFE_RELEASE(pDXGIDevice);
}
}
if (!m_adapter)
{
CLog::Log(LOGERROR, "%s - Failed to find adapter.", __FUNCTION__);
return false;
}
SAFE_RELEASE(m_dxgiFactory);
m_adapter->GetParent(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(&m_dxgiFactory));
if (g_advancedSettings.<API key>)
<API key>(true);
if (!m_pOutput)
{
HMONITOR hMonitor = MonitorFromWindow(m_hDeviceWnd, <API key>);
SetMonitor(hMonitor);
}
if ( g_advancedSettings.<API key>
&& FAILED(m_pD3DDev-><API key>(0, &m_pContext)))
{
CLog::Log(LOGERROR, "%s - Failed to create deferred context, deferred rendering is not possible, fallback to immediate rendering.", __FUNCTION__);
}
// make immediate context as default context if deferred context was not created
if (!m_pContext)
m_pContext = m_pImdContext;
if (m_featureLevel < <API key>)
m_maxTextureSize = <API key>;
else if (m_featureLevel < <API key>)
m_maxTextureSize = <API key>;
else if (m_featureLevel < <API key>)
m_maxTextureSize = <API key>;
else
// 11_x and greater feature level. Limit this size to avoid memory overheads
m_maxTextureSize = <API key> >> 1;
// use multi-thread protection on the device context to prevent deadlock issues that can sometimes happen
// when decoder call ID3D11VideoContext::GetDecoderBuffer or ID3D11VideoContext::<API key>.
ID3D10Multithread *pMultiThreading = NULL;
if (SUCCEEDED(m_pD3DDev->QueryInterface(__uuidof(ID3D10Multithread), reinterpret_cast<void**>(&pMultiThreading))))
{
pMultiThreading-><API key>(true);
pMultiThreading->Release();
}
<API key>();
#ifdef _DEBUG
if (SUCCEEDED(m_pD3DDev->QueryInterface(__uuidof(ID3D11Debug), reinterpret_cast<void**>(&m_d3dDebug))))
{
ID3D11InfoQueue *d3dInfoQueue = nullptr;
if (SUCCEEDED(m_d3dDebug->QueryInterface(__uuidof(ID3D11InfoQueue), reinterpret_cast<void**>(&d3dInfoQueue))))
{
D3D11_MESSAGE_ID hide[] =
{
<API key>, // avoid <API key> (dx bug)
<API key> // avoid warning for some labels out of screen
// Add more message IDs here as needed
};
<API key> filter;
ZeroMemory(&filter, sizeof(filter));
filter.DenyList.NumIDs = _countof(hide);
filter.DenyList.pIDList = hide;
d3dInfoQueue-><API key>(&filter);
d3dInfoQueue->Release();
}
}
#endif
m_adapterDesc = {};
if (SUCCEEDED(m_adapter->GetDesc(&m_adapterDesc)))
{
CLog::Log(LOGDEBUG, "%s - on adapter %S (VendorId: %#x DeviceId: %#x) with feature level %#x.", __FUNCTION__,
m_adapterDesc.Description, m_adapterDesc.VendorId, m_adapterDesc.DeviceId, m_featureLevel);
m_RenderRenderer = StringUtils::Format("%S", m_adapterDesc.Description);
IDXGIFactory2* dxgiFactory2 = nullptr;
m_dxgiFactory->QueryInterface(__uuidof(IDXGIFactory2), reinterpret_cast<void**>(&dxgiFactory2));
m_RenderVersion = StringUtils::Format("DirectX %s (FL %d.%d)",
dxgiFactory2 != nullptr ? "11.1" : "11.0",
(m_featureLevel >> 12) & 0xF,
(m_featureLevel >> 8) & 0xF);
SAFE_RELEASE(dxgiFactory2);
}
m_renderCaps = 0;
unsigned int usage = <API key> | <API key>;
if ( IsFormatSupport(<API key>, usage)
&& IsFormatSupport(<API key>, usage)
&& IsFormatSupport(<API key>, usage))
m_renderCaps |= RENDER_CAPS_DXT;
// MSDN: At feature levels 9_1, 9_2 and 9_3, the display device supports the use of 2D textures with dimensions that are not powers of two under two conditions.
// First, only one MIP-map level for each texture can be created - we are using only 1 mip level)
// Second, no wrap sampler modes for textures are allowed - we are using clamp everywhere
// At feature levels 10_0, 10_1 and 11_0, the display device unconditionally supports the use of 2D textures with dimensions that are not powers of two.
// so, setup caps NPOT
m_renderCaps |= RENDER_CAPS_NPOT;
if ((m_renderCaps & RENDER_CAPS_DXT) != 0)
m_renderCaps |= <API key>;
// Temporary - allow limiting the caps to debug a texture problem
if (g_advancedSettings.m_RestrictCapsMask != 0)
m_renderCaps &= ~g_advancedSettings.m_RestrictCapsMask;
if (m_renderCaps & RENDER_CAPS_DXT)
CLog::Log(LOGDEBUG, "%s - RENDER_CAPS_DXT", __FUNCTION__);
if (m_renderCaps & RENDER_CAPS_NPOT)
CLog::Log(LOGDEBUG, "%s - RENDER_CAPS_NPOT", __FUNCTION__);
if (m_renderCaps & <API key>)
CLog::Log(LOGDEBUG, "%s - <API key>", __FUNCTION__);
if (!CreateStates() || !InitGUIShader() || !<API key>())
return false;
m_bRenderCreated = true;
m_needNewDevice = false;
// tell any shared objects about our resurrection
for (std::vector<ID3DResource *>::iterator i = m_resources.begin(); i != m_resources.end(); ++i)
(*i)->OnCreateDevice();
RestoreViewPort();
return true;
}
bool CRenderSystemDX::<API key>()
{
if (m_resizeInProgress)
return false;
HRESULT hr;
<API key> scDesc = { 0 };
bool bNeedRecreate = false;
bool bNeedResize = false;
bool bHWStereoEnabled = <API key> == g_graphicsContext.GetStereoMode();
if (m_pSwapChain)
{
m_pSwapChain->GetDesc(&scDesc);
bNeedResize = m_bResizeRequred ||
m_nBackBufferWidth != scDesc.BufferDesc.Width ||
m_nBackBufferHeight != scDesc.BufferDesc.Height;
}
else
bNeedResize = true;
if (m_pSwapChain1)
{
<API key> scDesc;
m_pSwapChain1->GetDesc1(&scDesc);
bNeedRecreate = scDesc.Stereo != bHWStereoEnabled;
}
if (!bNeedRecreate && !bNeedResize)
{
<API key>();
return true;
}
m_resizeInProgress = true;
CLog::Log(LOGDEBUG, "%s - (Re)Create window size (%dx%d) dependent resources.", __FUNCTION__, m_nBackBufferWidth, m_nBackBufferHeight);
bool bRestoreRTView = false;
{
<API key>* pRTView; <API key>* pDSView;
m_pContext->OMGetRenderTargets(1, &pRTView, &pDSView);
bRestoreRTView = NULL != pRTView || NULL != pDSView;
SAFE_RELEASE(pRTView);
SAFE_RELEASE(pDSView);
}
m_pContext->OMSetRenderTargets(0, NULL, NULL);
FinishCommandList(false);
SAFE_RELEASE(m_pRenderTargetView);
SAFE_RELEASE(m_depthStencilView);
SAFE_RELEASE(<API key>);
SAFE_RELEASE(<API key>);
SAFE_RELEASE(m_pTextureRight);
if (bNeedRecreate)
{
if (!m_bResizeRequred)
{
OnDisplayLost();
m_bResizeRequred = true;
}
BOOL fullScreen;
m_pSwapChain1->GetFullscreenState(&fullScreen, NULL);
if (fullScreen)
m_pSwapChain1->SetFullscreenState(false, NULL);
// disable/enable stereo 3D on system level
if (g_advancedSettings.<API key>)
<API key>(bHWStereoEnabled);
CLog::Log(LOGDEBUG, "%s - Destroying swapchain in order to switch %s stereoscopic 3D.", __FUNCTION__, bHWStereoEnabled ? "to" : "from");
SAFE_RELEASE(m_pSwapChain);
SAFE_RELEASE(m_pSwapChain1);
m_pImdContext->ClearState();
m_pImdContext->Flush();
// flush command is asynchronous, so wait until destruction is completed
// otherwise it can cause problems with flip presentation model swap chains.
DXWait(m_pD3DDev, m_pImdContext);
}
uint32_t scFlags = m_useWindowedDX ? 0 : <API key>;
if (!m_pSwapChain)
{
CLog::Log(LOGDEBUG, "%s - Creating swapchain in %s mode.", __FUNCTION__, bHWStereoEnabled ? "Stereoscopic 3D" : "Mono");
// Create swap chain
IDXGIFactory2* dxgiFactory2 = NULL;
hr = m_dxgiFactory->QueryInterface(__uuidof(IDXGIFactory2), reinterpret_cast<void**>(&dxgiFactory2));
if (SUCCEEDED(hr) && dxgiFactory2)
{
// DirectX 11.1 or later
<API key> scDesc1 = { 0 };
scDesc1.Width = m_nBackBufferWidth;
scDesc1.Height = m_nBackBufferHeight;
scDesc1.BufferCount = 3 * (1 + bHWStereoEnabled);
scDesc1.Format = <API key>;
scDesc1.BufferUsage = <API key>;
scDesc1.AlphaMode = <API key>;
scDesc1.Stereo = bHWStereoEnabled;
scDesc1.SwapEffect = <API key>;
scDesc1.Flags = scFlags;
scDesc1.SampleDesc.Count = 1;
scDesc1.SampleDesc.Quality = 0;
<API key> scFSDesc = { 0 };
scFSDesc.ScanlineOrdering = m_interlaced ? <API key> : <API key>;
scFSDesc.Windowed = m_useWindowedDX;
hr = dxgiFactory2-><API key>(m_pD3DDev, m_hFocusWnd, &scDesc1, &scFSDesc, NULL, &m_pSwapChain1);
// some drivers (AMD) are denied to switch in stereoscopic 3D mode, if so then fallback to mono mode
if (FAILED(hr) && bHWStereoEnabled)
{
// switch to stereo mode failed, create mono swapchain
CLog::Log(LOGERROR, "%s - Creating stereo swap chain failed with error: %s.", __FUNCTION__, GetErrorDescription(hr).c_str());
CLog::Log(LOGNOTICE, "%s - Fallback to monoscopic mode.", __FUNCTION__);
scDesc1.Stereo = false;
bHWStereoEnabled = false;
hr = dxgiFactory2-><API key>(m_pD3DDev, m_hFocusWnd, &scDesc1, &scFSDesc, NULL, &m_pSwapChain1);
// fallback to split_horisontal mode.
g_graphicsContext.SetStereoMode(<API key>);
}
if (SUCCEEDED(hr))
{
m_pSwapChain1->QueryInterface(__uuidof(IDXGISwapChain), reinterpret_cast<void**>(&m_pSwapChain));
// this hackish way to disable stereo in windowed mode:
// - restart presenting, 0 in sync interval discards current frame also
// - wait until new frame will be drawn
// sleep value possible depends on hardware m.b. need a setting in as.xml
if (!g_advancedSettings.<API key> && m_useWindowedDX && !bHWStereoEnabled && m_bHWStereoEnabled)
{
m_pSwapChain1->Present(0, <API key>);
Sleep(100);
}
m_bHWStereoEnabled = bHWStereoEnabled;
}
dxgiFactory2->Release();
}
else
{
// DirectX 11.0 systems
scDesc.BufferCount = 3;
scDesc.BufferUsage = <API key>;
scDesc.OutputWindow = m_hFocusWnd;
scDesc.Windowed = m_useWindowedDX;
scDesc.SwapEffect = <API key>;
scDesc.Flags = scFlags;
scDesc.BufferDesc.Width = m_nBackBufferWidth;
scDesc.BufferDesc.Height = m_nBackBufferHeight;
scDesc.BufferDesc.Format = <API key>;
scDesc.BufferDesc.Scaling = <API key>;
scDesc.BufferDesc.ScanlineOrdering = m_interlaced ? <API key> : <API key>;
scDesc.SampleDesc.Count = 1;
scDesc.SampleDesc.Quality = 0;
hr = m_dxgiFactory->CreateSwapChain(m_pD3DDev, &scDesc, &m_pSwapChain);
}
if (FAILED(hr))
{
CLog::Log(LOGERROR, "%s - Creating swap chain failed with error: %s.", __FUNCTION__, GetErrorDescription(hr).c_str());
m_bRenderCreated = false;
return false;
}
// tell DXGI to not interfere with application's handling of window mode changes
m_dxgiFactory-><API key>(m_hFocusWnd, <API key> | <API key>);
}
else
{
// resize swap chain buffers with preserving the existing buffer count and format.
hr = m_pSwapChain->ResizeBuffers(scDesc.BufferCount, m_nBackBufferWidth, m_nBackBufferHeight, scDesc.BufferDesc.Format, scFlags);
if (FAILED(hr))
{
CLog::Log(LOGERROR, "%s - Failed to resize buffers (%s).", __FUNCTION__, GetErrorDescription(hr).c_str());
if (<API key> == hr)
{
OnDeviceLost();
return false;
}
// wait a bit and try again
Sleep(50);
hr = m_pSwapChain->ResizeBuffers(scDesc.BufferCount, m_nBackBufferWidth, m_nBackBufferHeight, scDesc.BufferDesc.Format, scFlags);
}
}
// Create a render target view
ID3D11Texture2D* pBackBuffer = nullptr;
hr = m_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&pBackBuffer));
if (FAILED(hr))
{
CLog::Log(LOGERROR, "%s - Failed to get back buffer (%s).", __FUNCTION__, GetErrorDescription(hr).c_str());
return false;
}
// Create a view interface on the rendertarget to use on bind for mono or left eye view.
<API key> rtDesc(<API key>, DXGI_FORMAT_UNKNOWN, 0, 0, 1);
hr = m_pD3DDev-><API key>(pBackBuffer, &rtDesc, &m_pRenderTargetView);
if (FAILED(hr))
{
CLog::Log(LOGERROR, "%s - Failed to create render target view (%s).", __FUNCTION__, GetErrorDescription(hr).c_str());
pBackBuffer->Release();
return false;
}
if (m_bHWStereoEnabled)
{
// Stereo swapchains have an arrayed resource, so create a second Render Target for the right eye buffer.
<API key> rtDesc(<API key>, DXGI_FORMAT_UNKNOWN, 0, 1, 1);
hr = m_pD3DDev-><API key>(pBackBuffer, &rtDesc, &<API key>);
if (FAILED(hr))
{
CLog::Log(LOGERROR, "%s - Failed to create right eye buffer (%s).", __FUNCTION__, GetErrorDescription(hr).c_str());
g_graphicsContext.SetStereoMode(<API key>); // try fallback to mono
}
}
pBackBuffer->Release();
DXGI_FORMAT zFormat = <API key>;
if (IsFormatSupport(<API key>, <API key>)) zFormat = <API key>;
else if (IsFormatSupport(<API key>, <API key>)) zFormat = <API key>;
else if (IsFormatSupport(<API key>, <API key>)) zFormat = <API key>;
ID3D11Texture2D* depthStencilBuffer = NULL;
// Initialize the description of the depth buffer.
<API key> depthBufferDesc(zFormat, m_nBackBufferWidth, m_nBackBufferHeight, 1, 1, <API key>);
// Create the texture for the depth buffer using the filled out description.
hr = m_pD3DDev->CreateTexture2D(&depthBufferDesc, NULL, &depthStencilBuffer);
if (FAILED(hr))
{
CLog::Log(LOGERROR, "%s - Failed to create depth stencil buffer (%s).", __FUNCTION__, GetErrorDescription(hr).c_str());
return false;
}
// Create the depth stencil view.
<API key> viewDesc(<API key>);
hr = m_pD3DDev-><API key>(depthStencilBuffer, &viewDesc, &m_depthStencilView);
depthStencilBuffer->Release();
if (FAILED(hr))
{
CLog::Log(LOGERROR, "%s - Failed to create depth stencil view (%s).", __FUNCTION__, GetErrorDescription(hr).c_str());
return false;
}
if (m_viewPort.Height == 0 || m_viewPort.Width == 0)
{
CRect rect(0, 0, m_nBackBufferWidth, m_nBackBufferHeight);
SetViewPort(rect);
}
// set camera to center of screen
CPoint camPoint = { m_nBackBufferWidth * 0.5f, m_nBackBufferHeight * 0.5f };
SetCameraPosition(camPoint, m_nBackBufferWidth, m_nBackBufferHeight);
<API key>();
if (bRestoreRTView)
m_pContext->OMSetRenderTargets(1, &m_pRenderTargetView, m_depthStencilView);
// notify about resurection of display
if (m_bResizeRequred)
OnDisplayBack();
m_resizeInProgress = false;
m_bResizeRequred = false;
return true;
}
void CRenderSystemDX::<API key>(void)
{
RENDER_STEREO_MODE stereoMode = g_graphicsContext.GetStereoMode();
if ( <API key>
&& <API key> != stereoMode
&& <API key> != stereoMode
&& <API key> != stereoMode)
{
// release resources
SAFE_RELEASE(<API key>);
SAFE_RELEASE(<API key>);
SAFE_RELEASE(m_pTextureRight);
}
if ( !<API key>
&& ( <API key> == stereoMode
|| <API key> == stereoMode))
{
// Create a second Render Target for the right eye buffer
HRESULT hr;
<API key> texDesc(<API key>, m_nBackBufferWidth, m_nBackBufferHeight, 1, 1,
<API key> | <API key>);
hr = m_pD3DDev->CreateTexture2D(&texDesc, NULL, &m_pTextureRight);
if (SUCCEEDED(hr))
{
<API key> rtDesc(<API key>);
hr = m_pD3DDev-><API key>(m_pTextureRight, &rtDesc, &<API key>);
if (SUCCEEDED(hr))
{
<API key> srDesc(<API key>);
hr = m_pD3DDev-><API key>(m_pTextureRight, &srDesc, &<API key>);
if (FAILED(hr))
CLog::Log(LOGERROR, "%s - Failed to create right view shader resource.", __FUNCTION__);
}
else
CLog::Log(LOGERROR, "%s - Failed to create right view render target.", __FUNCTION__);
}
if (FAILED(hr))
{
SAFE_RELEASE(<API key>);
SAFE_RELEASE(<API key>);
SAFE_RELEASE(m_pTextureRight);
CLog::Log(LOGERROR, "%s - Failed to create right eye buffer.", __FUNCTION__);
g_graphicsContext.SetStereoMode(<API key>); // try fallback to mono
}
}
}
bool CRenderSystemDX::CreateStates()
{
if (!m_pD3DDev)
return false;
SAFE_RELEASE(m_depthStencilState);
SAFE_RELEASE(m_BlendEnableState);
SAFE_RELEASE(m_BlendDisableState);
// Initialize the description of the stencil state.
<API key> depthStencilDesc;
ZeroMemory(&depthStencilDesc, sizeof(<API key>));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = false;
depthStencilDesc.DepthWriteMask = <API key>;
depthStencilDesc.DepthFunc = <API key>;
depthStencilDesc.StencilEnable = false;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = <API key>;
depthStencilDesc.FrontFace.StencilDepthFailOp = <API key>;
depthStencilDesc.FrontFace.StencilPassOp = <API key>;
depthStencilDesc.FrontFace.StencilFunc = <API key>;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = <API key>;
depthStencilDesc.BackFace.StencilDepthFailOp = <API key>;
depthStencilDesc.BackFace.StencilPassOp = <API key>;
depthStencilDesc.BackFace.StencilFunc = <API key>;
// Create the depth stencil state.
HRESULT hr = m_pD3DDev-><API key>(&depthStencilDesc, &m_depthStencilState);
if(FAILED(hr))
return false;
// Set the depth stencil state.
m_pContext-><API key>(m_depthStencilState, 0);
<API key> rasterizerState;
rasterizerState.CullMode = D3D11_CULL_NONE;
rasterizerState.FillMode = D3D11_FILL_SOLID;// DEBUG - <API key>
rasterizerState.<API key> = false;
rasterizerState.DepthBias = 0;
rasterizerState.DepthBiasClamp = 0.0f;
rasterizerState.DepthClipEnable = true;
rasterizerState.<API key> = 0.0f;
rasterizerState.ScissorEnable = false;
rasterizerState.MultisampleEnable = false;
rasterizerState.<API key> = false;
if (FAILED(m_pD3DDev-><API key>(&rasterizerState, &m_RSScissorDisable)))
return false;
rasterizerState.ScissorEnable = true;
if (FAILED(m_pD3DDev-><API key>(&rasterizerState, &m_RSScissorEnable)))
return false;
m_pContext->RSSetState(m_RSScissorDisable); // by default
D3D11_BLEND_DESC blendState = { 0 };
ZeroMemory(&blendState, sizeof(D3D11_BLEND_DESC));
blendState.RenderTarget[0].BlendEnable = true;
blendState.RenderTarget[0].SrcBlend = <API key>; // <API key>;
blendState.RenderTarget[0].DestBlend = <API key>; // <API key>;
blendState.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendState.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendState.RenderTarget[0].DestBlendAlpha = <API key>;
blendState.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendState.RenderTarget[0].<API key> = <API key>;
m_pD3DDev->CreateBlendState(&blendState, &m_BlendEnableState);
blendState.RenderTarget[0].BlendEnable = false;
m_pD3DDev->CreateBlendState(&blendState, &m_BlendDisableState);
// by default
m_pContext->OMSetBlendState(m_BlendEnableState, nullptr, 0xFFFFFFFF);
m_BlendEnabled = true;
return true;
}
void CRenderSystemDX::PresentRenderImpl(bool rendered)
{
HRESULT hr;
if (!rendered)
return;
if (!m_bRenderCreated || m_resizeInProgress)
return;
if (m_nDeviceStatus != S_OK)
{
// if <API key> occurred we just clear command queue and return
if (m_nDeviceStatus == <API key>)
FinishCommandList(false);
return;
}
if ( m_stereoMode == <API key>
|| m_stereoMode == <API key>)
{
// all views prepared, let's merge them before present
m_pContext->OMSetRenderTargets(1, &m_pRenderTargetView, m_depthStencilView);
CRect destRect = { 0.0f, 0.0f, float(m_nBackBufferWidth), float(m_nBackBufferHeight) };
SHADER_METHOD method = <API key> == m_stereoMode
? <API key>
: <API key>;
SetAlphaBlendEnable(true);
CD3DTexture::DrawQuad(destRect, 0, 1, &<API key>, NULL, method);
CD3DHelper::<API key>(m_pContext);
}
FinishCommandList();
m_pImdContext->Flush();
hr = m_pSwapChain->Present((m_bVSync ? 1 : 0), 0);
if (<API key> == hr)
{
CLog::Log(LOGDEBUG, "%s - device removed", __FUNCTION__);
return;
}
if (<API key> == hr)
{
<API key>();
<API key>();
hr = S_OK;
}
if (FAILED(hr))
{
CLog::Log(LOGDEBUG, "%s - Present failed. %s", __FUNCTION__, GetErrorDescription(hr).c_str());
return;
}
// after present swapchain unbinds RT view from immediate context, need to restore it because it can be used by something else
if (m_pContext == m_pImdContext)
m_pContext->OMSetRenderTargets(1, &m_pRenderTargetView, m_depthStencilView);
}
bool CRenderSystemDX::BeginRender()
{
if (!m_bRenderCreated)
return false;
HRESULT oldStatus = m_nDeviceStatus;
m_nDeviceStatus = m_pSwapChain->Present(0, DXGI_PRESENT_TEST);
// handling of return values.
switch (m_nDeviceStatus)
{
case <API key>: // GPU has been physically removed from the system, or a driver upgrade occurred.
CLog::Log(LOGERROR, "<API key>");
m_needNewDevice = true;
break;
case <API key>: // This is an run-time issue that should be investigated and fixed.
CLog::Log(LOGERROR, "<API key>");
m_nDeviceStatus = <API key>;
m_needNewDevice = true;
break;
case <API key>: // application provided invalid parameter data. Try to return after resize buffers
CLog::Log(LOGERROR, "<API key>");
// in most cases when <API key> occurs it means what DXGI silently leaves from FSE mode.
// if so, we should return for FSE mode and resize buffers
<API key>();
<API key>();
m_nDeviceStatus = S_OK;
break;
case <API key>: // decide what we should do when windows content is not visible
// do not spam to log file
if (m_nDeviceStatus != oldStatus)
CLog::Log(LOGDEBUG, "<API key>");
// Status OCCLUDED is not an error and not handled by FAILED macro,
// but if it occurs we should not render anything, this status will be accounted on present stage
}
if (FAILED(m_nDeviceStatus))
{
if (<API key> == m_nDeviceStatus)
{
OnDeviceLost();
OnDeviceReset();
}
return false;
}
m_pContext->OMSetRenderTargets(1, &m_pRenderTargetView, m_depthStencilView);
m_inScene = true;
return true;
}
bool CRenderSystemDX::EndRender()
{
m_inScene = false;
if (!m_bRenderCreated)
return false;
if(m_nDeviceStatus != S_OK)
return false;
return true;
}
bool CRenderSystemDX::ClearBuffers(color_t color)
{
if (!m_bRenderCreated || m_resizeInProgress)
return false;
float fColor[4];
CD3DHelper::XMStoreColor(fColor, color);
<API key>* pRTView = m_pRenderTargetView;
if ( m_stereoMode != <API key>
&& m_stereoMode != <API key>)
{
// if stereo anaglyph/tab/sbs, data was cleared when left view was rendererd
if (m_stereoView == <API key>)
{
// execute command's queue
FinishCommandList();
// do not clear RT for anaglyph modes
if ( m_stereoMode == <API key>
|| m_stereoMode == <API key>
|| m_stereoMode == <API key>)
{
pRTView = nullptr;
}
// for interlaced/checkerboard/hw clear right view
else if (<API key>)
pRTView = <API key>;
}
}
if (pRTView == nullptr)
return true;
CRect clRect(0, 0, m_nBackBufferWidth, m_nBackBufferHeight);
// Unlike Direct3D 9, D3D11 <API key> always clears full extent of the resource view.
// Viewport and scissor settings are not applied. So clear RT by drawing full sized rect with clear color
if (m_ScissorsEnabled && m_scissor != clRect)
{
bool alphaEnabled = m_BlendEnabled;
if (alphaEnabled)
SetAlphaBlendEnable(false);
CGUITextureD3D::DrawQuad(clRect, color);
if (alphaEnabled)
SetAlphaBlendEnable(true);
}
else
m_pContext-><API key>(pRTView, fColor);
m_pContext-><API key>(m_depthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0, 0);
return true;
}
bool CRenderSystemDX::IsExtSupported(const char* extension)
{
return false;
}
void CRenderSystemDX::SetVSync(bool enable)
{
m_bVSync = enable;
}
void CRenderSystemDX::CaptureStateBlock()
{
if (!m_bRenderCreated)
return;
}
void CRenderSystemDX::ApplyStateBlock()
{
if (!m_bRenderCreated)
return;
m_pContext->RSSetState(m_ScissorsEnabled ? m_RSScissorEnable : m_RSScissorDisable);
m_pContext-><API key>(m_depthStencilState, 0);
float factors[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
m_pContext->OMSetBlendState(m_BlendEnabled ? m_BlendEnableState : m_BlendDisableState, factors, 0xFFFFFFFF);
m_pGUIShader->ApplyStateBlock();
}
void CRenderSystemDX::SetCameraPosition(const CPoint &camera, int screenWidth, int screenHeight, float stereoFactor)
{
if (!m_bRenderCreated)
return;
// grab the viewport dimensions and location
float w = m_viewPort.Width*0.5f;
float h = m_viewPort.Height*0.5f;
XMFLOAT2 offset = XMFLOAT2(camera.x - screenWidth*0.5f, camera.y - screenHeight*0.5f);
// world view. Until this is moved onto the GPU (via a vertex shader for instance), we set it to the identity here.
m_pGUIShader->SetWorld(XMMatrixIdentity());
// Initialize the view matrix
// camera view. Multiply the Y coord by -1 then translate so that everything is relative to the camera
// position.
XMMATRIX flipY, translate;
flipY = XMMatrixScaling(1.0, -1.0f, 1.0f);
translate = XMMatrixTranslation(-(w + offset.x - stereoFactor), -(h + offset.y), 2 * h);
m_pGUIShader->SetView(XMMatrixMultiply(translate, flipY));
// projection onto screen space
m_pGUIShader->SetProjection(<API key>((-w - offset.x)*0.5f, (w - offset.x)*0.5f, (-h + offset.y)*0.5f, (h + offset.y)*0.5f, h, 100 * h));
}
void CRenderSystemDX::Project(float &x, float &y, float &z)
{
if (!m_bRenderCreated)
return;
m_pGUIShader->Project(x, y, z);
}
bool CRenderSystemDX::TestRender()
{
/*
static unsigned int lastTime = 0;
static float delta = 0;
unsigned int thisTime = XbmcThreads::SystemClockMillis();
if(thisTime - lastTime > 10)
{
lastTime = thisTime;
delta++;
}
CLog::Log(LOGINFO, "Delta = %d", delta);
if(delta > m_nBackBufferWidth)
delta = 0;
<API key> pVB = NULL;
// A structure for our custom vertex type
struct CUSTOMVERTEX
{
FLOAT x, y, z, rhw; // The transformed position for the vertex
DWORD color; // The vertex color
};
// Our custom FVF, which describes our custom vertex structure
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)
// Initialize three vertices for rendering a triangle
CUSTOMVERTEX vertices[] =
{
{ delta + 100.0f, 50.0f, 0.5f, 1.0f, 0xffff0000, }, // x, y, z, rhw, color
{ delta+200.0f, 250.0f, 0.5f, 1.0f, 0xff00ff00, },
{ delta, 250.0f, 0.5f, 1.0f, 0xff00ffff, },
};
// Create the vertex buffer. Here we are allocating enough memory
// (from the default pool) to hold all our 3 custom vertices. We also
// specify the FVF, so the vertex buffer knows what data it contains.
if( FAILED( m_pD3DDevice->CreateVertexBuffer( 3 * sizeof( CUSTOMVERTEX ),
0, D3DFVF_CUSTOMVERTEX,
D3DPOOL_DEFAULT, &pVB, NULL ) ) )
{
return false;
}
// Now we fill the vertex buffer. To do this, we need to Lock() the VB to
// gain access to the vertices. This mechanism is required becuase vertex
// buffers may be in device memory.
VOID* pVertices;
if( FAILED( pVB->Lock( 0, sizeof( vertices ), ( void** )&pVertices, 0 ) ) )
return false;
memcpy( pVertices, vertices, sizeof( vertices ) );
pVB->Unlock();
m_pD3DDevice->SetStreamSource( 0, pVB, 0, sizeof( CUSTOMVERTEX ) );
m_pD3DDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
m_pD3DDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 1 );
pVB->Release();
*/
return true;
}
void CRenderSystemDX::<API key>(const TransformMatrix &finalMatrix)
{
if (!m_bRenderCreated)
return;
}
void CRenderSystemDX::<API key>()
{
if (!m_bRenderCreated)
return;
}
void CRenderSystemDX::GetViewPort(CRect& viewPort)
{
if (!m_bRenderCreated)
return;
viewPort.x1 = m_viewPort.TopLeftX;
viewPort.y1 = m_viewPort.TopLeftY;
viewPort.x2 = m_viewPort.TopLeftX + m_viewPort.Width;
viewPort.y2 = m_viewPort.TopLeftY + m_viewPort.Height;
}
void CRenderSystemDX::SetViewPort(CRect& viewPort)
{
if (!m_bRenderCreated)
return;
m_viewPort.MinDepth = 0.0f;
m_viewPort.MaxDepth = 1.0f;
m_viewPort.TopLeftX = viewPort.x1;
m_viewPort.TopLeftY = viewPort.y1;
m_viewPort.Width = viewPort.x2 - viewPort.x1;
m_viewPort.Height = viewPort.y2 - viewPort.y1;
m_pContext->RSSetViewports(1, &m_viewPort);
m_pGUIShader->SetViewPort(m_viewPort);
}
void CRenderSystemDX::RestoreViewPort()
{
if (!m_bRenderCreated)
return;
m_pContext->RSSetViewports(1, &m_viewPort);
m_pGUIShader->SetViewPort(m_viewPort);
}
bool CRenderSystemDX::<API key>()
{
if (!m_bRenderCreated)
return false;
return m_pGUIShader != NULL && m_pGUIShader-><API key>();
}
CRect CRenderSystemDX::<API key>(const CRect &rect)
{
if (!m_bRenderCreated)
return CRect();
float xFactor = m_pGUIShader->GetClipXFactor();
float xOffset = m_pGUIShader->GetClipXOffset();
float yFactor = m_pGUIShader->GetClipYFactor();
float yOffset = m_pGUIShader->GetClipYOffset();
return CRect(rect.x1 * xFactor + xOffset,
rect.y1 * yFactor + yOffset,
rect.x2 * xFactor + xOffset,
rect.y2 * yFactor + yOffset);
}
void CRenderSystemDX::SetScissors(const CRect& rect)
{
if (!m_bRenderCreated)
return;
m_scissor = rect;
CD3D11_RECT scissor(MathUtils::round_int(rect.x1)
, MathUtils::round_int(rect.y1)
, MathUtils::round_int(rect.x2)
, MathUtils::round_int(rect.y2));
m_pContext->RSSetScissorRects(1, &scissor);
m_pContext->RSSetState(m_RSScissorEnable);
m_ScissorsEnabled = true;
}
void CRenderSystemDX::ResetScissors()
{
if (!m_bRenderCreated)
return;
m_scissor.SetRect(0, 0, m_nBackBufferWidth, m_nBackBufferHeight);
m_pContext->RSSetState(m_RSScissorDisable);
m_ScissorsEnabled = false;
}
void CRenderSystemDX::Register(ID3DResource *resource)
{
CSingleLock lock(m_resourceSection);
m_resources.push_back(resource);
}
void CRenderSystemDX::Unregister(ID3DResource* resource)
{
CSingleLock lock(m_resourceSection);
std::vector<ID3DResource*>::iterator i = find(m_resources.begin(), m_resources.end(), resource);
if (i != m_resources.end())
m_resources.erase(i);
}
std::string CRenderSystemDX::GetErrorDescription(HRESULT hr)
{
WCHAR buff[1024];
<API key>(hr, buff, 1024);
std::wstring error(DXGetErrorString(hr));
std::wstring descr(buff);
return StringUtils::Format("%X - %ls (%ls)", hr, error.c_str(), descr.c_str());
}
void CRenderSystemDX::SetStereoMode(RENDER_STEREO_MODE mode, RENDER_STEREO_VIEW view)
{
CRenderSystemBase::SetStereoMode(mode, view);
if (!m_bRenderCreated)
return;
UINT writeMask = <API key>;
if(m_stereoMode == <API key>)
{
if(m_stereoView == <API key>)
writeMask = <API key>;
else if(m_stereoView == <API key>)
writeMask = <API key> | <API key>;
}
if(m_stereoMode == <API key>)
{
if(m_stereoView == <API key>)
writeMask = <API key>;
else if(m_stereoView == <API key>)
writeMask = <API key> | <API key>;
}
if (m_stereoMode == <API key>)
{
if (m_stereoView == <API key>)
writeMask = <API key> | <API key>;
else if (m_stereoView == <API key>)
writeMask = <API key>;
}
if ( <API key> == m_stereoMode
|| <API key> == m_stereoMode
|| <API key> == m_stereoMode)
{
if (m_stereoView == <API key>)
{
// render right eye view to right render target
m_pContext->OMSetRenderTargets(1, &<API key>, m_depthStencilView);
}
}
D3D11_BLEND_DESC desc;
m_BlendEnableState->GetDesc(&desc);
// update blend state
if (desc.RenderTarget[0].<API key> != writeMask)
{
SAFE_RELEASE(m_BlendDisableState);
SAFE_RELEASE(m_BlendEnableState);
desc.RenderTarget[0].<API key> = writeMask;
m_pD3DDev->CreateBlendState(&desc, &m_BlendEnableState);
desc.RenderTarget[0].BlendEnable = false;
m_pD3DDev->CreateBlendState(&desc, &m_BlendDisableState);
float blendFactors[] = { 0.0f, 0.0f, 0.0f, 0.0f };
m_pContext->OMSetBlendState(m_BlendEnabled ? m_BlendEnableState : m_BlendDisableState, blendFactors, 0xFFFFFFFF);
}
}
bool CRenderSystemDX::GetStereoEnabled() const
{
bool result = false;
IDXGIFactory2* dxgiFactory2 = nullptr;
if (SUCCEEDED(m_dxgiFactory->QueryInterface(__uuidof(IDXGIFactory2), reinterpret_cast<void**>(&dxgiFactory2))))
result = dxgiFactory2-><API key>();
SAFE_RELEASE(dxgiFactory2);
return result;
}
bool CRenderSystemDX::<API key>() const
{
bool result = false;
IDXGIDisplayControl * pDXGIDisplayControl = nullptr;
if (SUCCEEDED(m_dxgiFactory->QueryInterface(__uuidof(IDXGIDisplayControl), (void **)&pDXGIDisplayControl)))
result = pDXGIDisplayControl->IsStereoEnabled();
SAFE_RELEASE(pDXGIDisplayControl);
return result;
}
void CRenderSystemDX::<API key>(bool enable)
{
IDXGIDisplayControl * pDXGIDisplayControl = nullptr;
if (SUCCEEDED(m_dxgiFactory->QueryInterface(__uuidof(IDXGIDisplayControl), (void **)&pDXGIDisplayControl)))
pDXGIDisplayControl->SetStereoEnabled(enable);
SAFE_RELEASE(pDXGIDisplayControl);
}
void CRenderSystemDX::<API key>(bool first)
{
if (first)
<API key> = <API key>();
if (!first || !<API key>)
<API key>(true);
m_bStereoEnabled = GetStereoEnabled();
<API key>(false);
}
bool CRenderSystemDX::SupportsStereo(RENDER_STEREO_MODE mode) const
{
switch (mode)
{
case <API key>:
case <API key>:
case <API key>:
case <API key>:
case <API key>:
return true;
case <API key>:
return m_bStereoEnabled || GetStereoEnabled();
default:
return CRenderSystemBase::SupportsStereo(mode);
}
}
void CRenderSystemDX::FlushGPU()
{
if (!m_bRenderCreated)
return;
FinishCommandList();
m_pImdContext->Flush();
}
bool CRenderSystemDX::InitGUIShader()
{
if (!m_pD3DDev)
return false;
SAFE_DELETE(m_pGUIShader);
m_pGUIShader = new CGUIShaderDX();
if (!m_pGUIShader->Initialize())
{
CLog::Log(LOGERROR, __FUNCTION__ " - Failed to initialize GUI shader.");
return false;
}
m_pGUIShader->ApplyStateBlock();
return true;
}
void CRenderSystemDX::SetAlphaBlendEnable(bool enable)
{
if (!m_bRenderCreated)
return;
float blendFactors[] = { 0.0f, 0.0f, 0.0f, 0.0f };
m_pContext->OMSetBlendState(enable ? m_BlendEnableState : m_BlendDisableState, 0, 0xFFFFFFFF);
m_BlendEnabled = enable;
}
void CRenderSystemDX::FinishCommandList(bool bExecute /*= true*/)
{
if (m_pImdContext == m_pContext)
return;
ID3D11CommandList* pCommandList = NULL;
if (FAILED(m_pContext->FinishCommandList(true, &pCommandList)))
{
CLog::Log(LOGERROR, "%s - Failed to finish command queue.", __FUNCTION__);
return;
}
if (bExecute)
m_pImdContext->ExecuteCommandList(pCommandList, false);
SAFE_RELEASE(pCommandList);
}
void CRenderSystemDX::<API key>(uint8_t latency)
{
if (!m_pD3DDev)
return;
IDXGIDevice1* pDXGIDevice = nullptr;
if (SUCCEEDED(m_pD3DDev->QueryInterface(__uuidof(IDXGIDevice1), reinterpret_cast<void**>(&pDXGIDevice))))
{
// in windowed mode DWM uses triple buffering in any case.
// for FSEM we use same buffering to avoid possible shuttering/tearing
if (latency == -1)
latency = m_useWindowedDX ? 1 : 3;
pDXGIDevice-><API key>(latency);
SAFE_RELEASE(pDXGIDevice);
}
}
#endif |
<?php
/*
* ACF Flexible Content Field Class
*
* All the logic for this field type
*
* @class <API key>
* @extends acf_field
* @package ACF
* @subpackage Fields
*/
if( ! class_exists('<API key>') ) :
class <API key> extends acf_field {
/*
* __construct
*
* This function will setup the field type data
*
* @type function
* @date 5/03/2014
* @since 5.0.0
*
* @param n/a
* @return n/a
*/
function __construct() {
// vars
$this->name = 'flexible_content';
$this->label = __("Flexible Content",'acf');
$this->category = 'layout';
$this->defaults = array(
'layouts' => array(),
'min' => '',
'max' => '',
'button_label' => __("Add Row",'acf'),
);
$this->l10n = array(
'layout' => __("layout", 'acf'),
'layouts' => __("layouts", 'acf'),
'remove' => __("remove {layout}?", 'acf'),
'min' => __("This field requires at least {min} {identifier}",'acf'),
'max' => __("This field has a limit of {max} {identifier}",'acf'),
'min_layout' => __("This field requires at least {min} {label} {identifier}",'acf'),
'max_layout' => __("Maximum {label} limit reached ({max} {identifier})",'acf'),
'available' => __("{available} {label} {identifier} available (max {max})",'acf'),
'required' => __("{required} {label} {identifier} required (min {min})",'acf'),
);
// ajax
add_action('wp_ajax_acf/fields/flexible_content/layout_title', array($this, 'ajax_layout_title'));
add_action('wp_ajax_nopriv_acf/fields/flexible_content/layout_title', array($this, 'ajax_layout_title'));
// filters
add_filter('acf/clone_field', array($this, 'acf_clone_field'), 10, 2);
// do not delete!
parent::__construct();
}
/*
* get_valid_layout
*
* This function will fill in the missing keys to create a valid layout
*
* @type function
* @date 3/10/13
* @since 1.1.0
*
* @param $layout (array)
* @return $layout (array)
*/
function get_valid_layout( $layout = array() ) {
// parse
$layout = wp_parse_args($layout, array(
'key' => uniqid(),
'name' => '',
'label' => '',
'display' => 'block',
'sub_fields' => array(),
'min' => '',
'max' => '',
));
// return
return $layout;
}
/*
* load_field()
*
* This filter is appied to the $field after it is loaded from the database
*
* @type filter
* @since 3.6
* @date 23/01/13
*
* @param $field - the field array holding all the field options
*
* @return $field - the field array holding all the field options
*/
function load_field( $field ) {
// bail early if no field layouts
if( empty($field['layouts']) ) {
return $field;
}
// vars
$sub_fields = acf_get_fields($field);
// loop through layouts, sub fields and swap out the field key with the real field
foreach( array_keys($field['layouts']) as $i ) {
// extract layout
$layout = acf_extract_var( $field['layouts'], $i );
// validate layout
$layout = $this->get_valid_layout( $layout );
// append sub fields
if( !empty($sub_fields) ) {
foreach( array_keys($sub_fields) as $k ) {
// check if 'parent_layout' is empty
if( empty($sub_fields[ $k ]['parent_layout']) ) {
// parent_layout did not save for this field, default it to first layout
$sub_fields[ $k ]['parent_layout'] = $layout['key'];
}
// append sub field to layout,
if( $sub_fields[ $k ]['parent_layout'] == $layout['key'] ) {
$layout['sub_fields'][] = acf_extract_var( $sub_fields, $k );
}
}
}
// append back to layouts
$field['layouts'][ $i ] = $layout;
}
// return
return $field;
}
/*
* render_field()
*
* Create the HTML interface for your field
*
* @param $field - an array holding all the field's data
*
* @type action
* @since 3.6
* @date 23/01/13
*/
function render_field( $field ) {
// defaults
if( empty($field['button_label']) ) {
$field['button_label'] = $this->defaults['button_label'];
}
// sort layouts into names
$layouts = array();
foreach( $field['layouts'] as $k => $layout ) {
$layouts[ $layout['name'] ] = $layout;
}
// hidden input
acf_hidden_input(array(
'type' => 'hidden',
'name' => $field['name'],
));
// no value message
$no_value_message = __('Click the "%s" button below to start creating your layout','acf');
$no_value_message = apply_filters('acf/fields/flexible_content/no_value_message', $no_value_message, $field);
?>
<div <?php acf_esc_attr_e(array( 'class' => '<API key>', 'data-min' => $field['min'], 'data-max' => $field['max'] )); ?>>
<div class="no-value-message" <?php if( $field['value'] ){ echo 'style="display:none;"'; } ?>>
<?php printf( $no_value_message, $field['button_label'] ); ?>
</div>
<div class="clones">
<?php foreach( $layouts as $layout ): ?>
<?php $this->render_layout( $field, $layout, 'acfcloneindex', array() ); ?>
<?php endforeach; ?>
</div>
<div class="values">
<?php if( !empty($field['value']) ): ?>
<?php foreach( $field['value'] as $i => $value ): ?>
<?php
// validate
if( empty($layouts[ $value['acf_fc_layout'] ]) ) {
continue;
}
$this->render_layout( $field, $layouts[ $value['acf_fc_layout'] ], $i, $value );
?>
<?php endforeach; ?>
<?php endif; ?>
</div>
<ul class="acf-actions acf-hl">
<li>
<a class="acf-button button button-primary" data-event="add-layout"><?php echo $field['button_label']; ?></a>
</li>
</ul>
<script type="text-html" class="tmpl-popup"><?php
?><div class="acf-fc-popup">
<ul>
<?php foreach( $layouts as $layout ):
$atts = array(
'data-layout' => $layout['name'],
'data-min' => $layout['min'],
'data-max' => $layout['max'],
);
?>
<li>
<a href="#" <?php acf_esc_attr_e( $atts ); ?>><?php echo $layout['label']; ?><span class="status"></span></a>
</li>
<?php endforeach; ?>
</ul>
<a href="#" class="focus"></a>
</div>
</script>
</div>
<?php
}
/*
* render_layout
*
* description
*
* @type function
* @date 19/11/2013
* @since 5.0.0
*
* @param $post_id (int)
* @return $post_id (int)
*/
function render_layout( $field, $layout, $i, $value ) {
// vars
$order = 0;
$el = 'div';
$div = array(
'class' => 'layout',
'data-id' => $i,
'data-layout' => $layout['name']
);
// collapsed class
if( <API key>($field['key'], $i) ) {
$div['class'] .= ' -collapsed';
}
// clone
if( is_numeric($i) ) {
$order = $i + 1;
} else {
$div['class'] .= ' acf-clone';
}
// title
$title = $this->get_layout_title( $field, $layout, $i, $value );
// remove row
reset_rows();
?>
<div <?php acf_esc_attr_e($div); ?>>
<div class="acf-hidden">
<?php acf_hidden_input(array( 'name' => "{$field['name']}[{$i}][acf_fc_layout]", 'value' => $layout['name'] )); ?>
</div>
<div class="<API key>" title="<?php _e('Drag to reorder','acf'); ?>"><?php echo $title; ?></div>
<ul class="<API key> acf-hl">
<li class="<API key>">
<a class="acf-icon -plus small" href="#" data-event="add-layout" title="<?php _e('Add layout','acf'); ?>"></a>
</li>
<li class="<API key>">
<a class="acf-icon -minus small" href="#" data-event="remove-layout" title="<?php _e('Remove layout','acf'); ?>"></a>
</li>
<li>
<a class="acf-icon -collapse small" href="#" data-event="collapse-layout" title="<?php _e('Click to toggle','acf'); ?>"></a>
</li>
</ul>
<?php if( !empty($layout['sub_fields']) ): ?>
<?php if( $layout['display'] == 'table' ):
// update vars
$el = 'td';
?>
<table class="acf-table">
<thead>
<tr>
<?php foreach( $layout['sub_fields'] as $sub_field ):
$atts = array(
'class' => "acf-th acf-th-{$sub_field['name']}",
'data-key' => $sub_field['key'],
);
// Add custom width
if( $sub_field['wrapper']['width'] ) {
$atts['data-width'] = $sub_field['wrapper']['width'];
}
?>
<th <?php acf_esc_attr_e( $atts ); ?>>
<?php echo acf_get_field_label( $sub_field ); ?>
<?php if( $sub_field['instructions'] ): ?>
<p class="description"><?php echo $sub_field['instructions']; ?></p>
<?php endif; ?>
</th>
<?php endforeach; ?>
</tr>
</thead>
<tbody>
<?php else: ?>
<div class="acf-fields <?php if($layout['display'] == 'row'): ?>-left<?php endif; ?>">
<?php endif; ?>
<?php
// loop though sub fields
foreach( $layout['sub_fields'] as $sub_field ) {
// prevent repeater field from creating multiple conditional logic items for each row
if( $i !== 'acfcloneindex' ) {
$sub_field['conditional_logic'] = 0;
}
// add value
if( isset($value[ $sub_field['key'] ]) ) {
// this is a normal value
$sub_field['value'] = $value[ $sub_field['key'] ];
} elseif( isset($sub_field['default_value']) ) {
// no value, but this sub field has a default value
$sub_field['value'] = $sub_field['default_value'];
}
// update prefix to allow for nested values
$sub_field['prefix'] = "{$field['name']}[{$i}]";
// render input
<API key>( $sub_field, $el );
}
?>
<?php if( $layout['display'] == 'table' ): ?>
</tbody>
</table>
<?php else: ?>
</div>
<?php endif; ?>
<?php endif; ?>
</div>
<?php
}
/*
* <API key>()
*
* Create extra options for your field. This is rendered when editing a field.
* The value of $field['name'] can be used (like bellow) to save extra data to the $field
*
* @type action
* @since 3.6
* @date 23/01/13
*
* @param $field - an array holding all the field's data
*/
function <API key>( $field ) {
// load default layout
if( empty($field['layouts']) ) {
$field['layouts'] = array(
array()
);
}
// loop through layouts
foreach( $field['layouts'] as $layout ) {
// get valid layout
$layout = $this->get_valid_layout( $layout );
// vars
$layout_prefix = "{$field['prefix']}[layouts][{$layout['key']}]";
?><tr class="acf-field" data-name="fc_layout" data-setting="flexible_content" data-id="<?php echo $layout['key']; ?>">
<td class="acf-label">
<label><?php _e("Layout",'acf'); ?></label>
<p class="description acf-fl-actions">
<a data-name="acf-fc-reorder" title="<?php _e("Reorder Layout",'acf'); ?>" ><?php _e("Reorder",'acf'); ?></a>
<a data-name="acf-fc-delete" title="<?php _e("Delete Layout",'acf'); ?>" href="#"><?php _e("Delete",'acf'); ?></a>
<a data-name="acf-fc-duplicate" title="<?php _e("Duplicate Layout",'acf'); ?>" href="#"><?php _e("Duplicate",'acf'); ?></a>
<a data-name="acf-fc-add" title="<?php _e("Add New Layout",'acf'); ?>" href="#"><?php _e("Add New",'acf'); ?></a>
</p>
</td>
<td class="acf-input">
<ul class="acf-fc-meta acf-bl">
<li class="acf-fc-meta-key">
<?php
acf_hidden_input(array(
'name' => "{$layout_prefix}[key]",
'data-name' => 'layout-key',
'value' => $layout['key']
));
?>
</li>
<li class="acf-fc-meta-label">
<?php
acf_render_field(array(
'type' => 'text',
'name' => 'label',
'prefix' => $layout_prefix,
'value' => $layout['label'],
'prepend' => __('Label','acf')
));
?>
</li>
<li class="acf-fc-meta-name">
<?php
acf_render_field(array(
'type' => 'text',
'name' => 'name',
'prefix' => $layout_prefix,
'value' => $layout['name'],
'prepend' => __('Name','acf')
));
?>
</li>
<li class="acf-fc-meta-display">
<div class="acf-input-prepend"><?php _e('Layout','acf'); ?></div>
<div class="acf-input-wrap select">
<?php
acf_render_field(array(
'type' => 'select',
'name' => 'display',
'prefix' => $layout_prefix,
'value' => $layout['display'],
'choices' => array(
'table' => __('Table','acf'),
'block' => __('Block','acf'),
'row' => __('Row','acf')
),
));
?>
</div>
</li>
<li class="acf-fc-meta-min">
<?php
acf_render_field(array(
'type' => 'text',
'name' => 'min',
'prefix' => $layout_prefix,
'value' => $layout['min'],
'prepend' => __('Min','acf')
));
?>
</li>
<li class="acf-fc-meta-max">
<?php
acf_render_field(array(
'type' => 'text',
'name' => 'max',
'prefix' => $layout_prefix,
'value' => $layout['max'],
'prepend' => __('Max','acf')
));
?>
</li>
</ul>
<?php
// vars
$args = array(
'fields' => $layout['sub_fields'],
'layout' => $layout['display'],
'parent' => $field['ID']
);
acf_get_view('field-group-fields', $args);
?>
</td>
</tr>
<?php
}
// endforeach
// min
<API key>( $field, array(
'label' => __('Button Label','acf'),
'instructions' => '',
'type' => 'text',
'name' => 'button_label',
));
// min
<API key>( $field, array(
'label' => __('Minimum Layouts','acf'),
'instructions' => '',
'type' => 'number',
'name' => 'min',
));
// max
<API key>( $field, array(
'label' => __('Maximum Layouts','acf'),
'instructions' => '',
'type' => 'number',
'name' => 'max',
));
}
/*
* load_value()
*
* This filter is applied to the $value after it is loaded from the db
*
* @type filter
* @since 3.6
* @date 23/01/13
*
* @param $value (mixed) the value found in the database
* @param $post_id (mixed) the $post_id from which the value was loaded
* @param $field (array) the field array holding all the field options
* @return $value
*/
function load_value( $value, $post_id, $field ) {
// bail early if no value
if( empty($value) || empty($field['layouts']) ) {
return $value;
}
// value must be an array
$value = acf_get_array( $value );
// vars
$rows = array();
// populate $layouts
$layouts = array();
foreach( array_keys($field['layouts']) as $i ) {
// get layout
$layout = $field['layouts'][ $i ];
// append to $layouts
$layouts[ $layout['name'] ] = $layout['sub_fields'];
}
// loop through rows
foreach( $value as $i => $l ) {
// append to $values
$rows[ $i ] = array();
$rows[ $i ]['acf_fc_layout'] = $l;
// bail early if layout deosnt contain sub fields
if( empty($layouts[ $l ]) ) {
continue;
}
// get layout
$layout = $layouts[ $l ];
// loop through sub fields
foreach( array_keys($layout) as $j ) {
// get sub field
$sub_field = $layout[ $j ];
// bail ealry if no name (tab)
if( acf_is_empty($sub_field['name']) ) continue;
// update full name
$sub_field['name'] = "{$field['name']}_{$i}_{$sub_field['name']}";
// get value
$sub_value = acf_get_value( $post_id, $sub_field );
// add value
$rows[ $i ][ $sub_field['key'] ] = $sub_value;
}
// foreach
}
// foreach
// return
return $rows;
}
/*
* format_value()
*
* This filter is appied to the $value after it is loaded from the db and before it is returned to the template
*
* @type filter
* @since 3.6
* @date 23/01/13
*
* @param $value (mixed) the value which was loaded from the database
* @param $post_id (mixed) the $post_id from which the value was loaded
* @param $field (array) the field array holding all the field options
*
* @return $value (mixed) the modified value
*/
function format_value( $value, $post_id, $field ) {
// bail early if no value
if( empty($value) || empty($field['layouts']) ) {
return false;
}
// populate $layouts
$layouts = array();
foreach( array_keys($field['layouts']) as $i ) {
// get layout
$layout = $field['layouts'][ $i ];
// append to $layouts
$layouts[ $layout['name'] ] = $layout['sub_fields'];
}
// loop over rows
foreach( array_keys($value) as $i ) {
// get layout name
$l = $value[ $i ]['acf_fc_layout'];
// bail early if layout deosnt exist
if( empty($layouts[ $l ]) ) continue;
// get layout
$layout = $layouts[ $l ];
// loop through sub fields
foreach( array_keys($layout) as $j ) {
// get sub field
$sub_field = $layout[ $j ];
// bail ealry if no name (tab)
if( acf_is_empty($sub_field['name']) ) continue;
// extract value
$sub_value = acf_extract_var( $value[ $i ], $sub_field['key'] );
// update $sub_field name
$sub_field['name'] = "{$field['name']}_{$i}_{$sub_field['name']}";
// format value
$sub_value = acf_format_value( $sub_value, $post_id, $sub_field );
// append to $row
$value[ $i ][ $sub_field['_name'] ] = $sub_value;
}
}
// return
return $value;
}
/*
* validate_value
*
* description
*
* @type function
* @date 11/02/2014
* @since 5.0.0
*
* @param $post_id (int)
* @return $post_id (int)
*/
function validate_value( $valid, $value, $field, $input ){
// remove acfcloneindex
if( isset($value['acfcloneindex']) ) {
unset($value['acfcloneindex']);
}
// valid
if( $field['required'] && empty($value) ) {
$valid = false;
}
// populate $layouts
$layouts = array();
foreach( array_keys($field['layouts']) as $i ) {
$layout = acf_extract_var($field['layouts'], $i);
// append to $layouts
$layouts[ $layout['name'] ] = $layout['sub_fields'];
}
// check sub fields
if( !empty($value) ) {
// loop through rows
foreach( $value as $i => $row ) {
// get layout
$l = $row['acf_fc_layout'];
// loop through sub fields
if( !empty($layouts[ $l ]) ) {
foreach( $layouts[ $l ] as $sub_field ) {
// get sub field key
$k = $sub_field['key'];
// exists?
if( ! isset($value[ $i ][ $k ]) ) {
continue;
}
// validate
acf_validate_value( $value[ $i ][ $k ], $sub_field, "{$input}[{$i}][{$k}]" );
}
// foreach
}
}
// foreach
}
// return
return $valid;
}
/*
* update_value()
*
* This filter is appied to the $value before it is updated in the db
*
* @type filter
* @since 3.6
* @date 23/01/13
*
* @param $value - the value which will be saved in the database
* @param $field - the field array holding all the field options
* @param $post_id - the $post_id of which the value will be saved
*
* @return $value - the modified value
*/
function update_value( $value, $post_id, $field ) {
// remove acfcloneindex
if( isset($value['acfcloneindex']) ) {
unset($value['acfcloneindex']);
}
// vars
$order = array();
$layouts = array();
// populate $layouts
foreach( $field['layouts'] as $layout ) {
$layouts[ $layout['name'] ] = $layout['sub_fields'];
}
// update sub fields
if( !empty($value) ) {
$i = -1;
// loop through rows
foreach( $value as $row ) {
$i++;
// get layout
$l = $row['acf_fc_layout'];
// append to order
$order[] = $l;
// loop through sub fields
if( !empty($layouts[ $l ]) ) {
foreach( $layouts[ $l ] as $sub_field ) {
// value
$v = false;
// key (backend)
if( isset($row[ $sub_field['key'] ]) ) {
$v = $row[ $sub_field['key'] ];
} elseif( isset($row[ $sub_field['name'] ]) ) {
$v = $row[ $sub_field['name'] ];
} else {
// input is not set (hidden by conditioanl logic)
continue;
}
// modify name for save
$sub_field['name'] = "{$field['name']}_{$i}_{$sub_field['name']}";
// update field
acf_update_value( $v, $post_id, $sub_field );
}
// foreach
}
}
// foreach
}
// remove old data
$old_order = acf_get_metadata( $post_id, $field['name'] );
$old_count = empty($old_order) ? 0 : count($old_order);
$new_count = empty($order) ? 0 : count($order);
if( $old_count > $new_count ) {
for( $i = $new_count; $i < $old_count; $i++ ) {
// get layout
$l = $old_order[ $i ];
// loop through sub fields
if( !empty($layouts[ $l ]) ) {
foreach( $layouts[ $l ] as $sub_field ) {
// modify name for delete
$sub_field['name'] = "{$field['name']}_{$i}_{$sub_field['name']}";
// delete value
acf_delete_value( $post_id, $sub_field );
}
}
}
}
// save false for empty value
if( empty($order) ) {
$order = '';
}
// return
return $order;
}
/*
* delete_value
*
* description
*
* @type function
* @date 1/07/2015
* @since 5.2.3
*
* @param $post_id (int)
* @return $post_id (int)
*/
function delete_value( $post_id, $key, $field ) {
// get old value (db only)
$old_order = acf_get_metadata( $post_id, $field['name'] );
// bail early if no rows or no sub fields
if( empty($old_order) ) return;
// vars
$layouts = array();
// populate $layouts
foreach( $field['layouts'] as $layout ) {
$layouts[ $layout['name'] ] = $layout['sub_fields'];
}
// loop
foreach( $old_order as $i => $l ) {
// bail early if no layout
if( empty($layouts[ $l ]) ) continue;
// loop through sub fields
foreach( $layouts[ $l ] as $sub_field ) {
// modify name for delete
$sub_field['name'] = "{$key}_{$i}_{$sub_field['name']}";
// delete value
acf_delete_value( $post_id, $sub_field );
}
}
}
/*
* update_field()
*
* This filter is appied to the $field before it is saved to the database
*
* @type filter
* @since 3.6
* @date 23/01/13
*
* @param $field - the field array holding all the field options
* @param $post_id - the field group ID (post_type = acf)
*
* @return $field - the modified field
*/
function update_field( $field ) {
// vars
$layouts = acf_extract_var($field, 'layouts');
// update layouts
$field['layouts'] = array();
// loop through sub fields
if( !empty($layouts) ) {
foreach( $layouts as $layout ) {
// remove sub fields
unset($layout['sub_fields']);
// append to layouts
$field['layouts'][] = $layout;
}
}
// return
return $field;
}
/*
* delete_field
*
* description
*
* @type function
* @date 4/04/2014
* @since 5.0.0
*
* @param $post_id (int)
* @return $post_id (int)
*/
function delete_field( $field ) {
if( !empty($field['layouts']) ) {
// loop through layouts
foreach( $field['layouts'] as $layout ) {
// loop through sub fields
if( !empty($layout['sub_fields']) ) {
foreach( $layout['sub_fields'] as $sub_field ) {
acf_delete_field( $sub_field['ID'] );
}
// foreach
}
}
// foreach
}
}
/*
* duplicate_field()
*
* This filter is appied to the $field before it is duplicated and saved to the database
*
* @type filter
* @since 3.6
* @date 23/01/13
*
* @param $field - the field array holding all the field options
*
* @return $field - the modified field
*/
function duplicate_field( $field ) {
// vars
$sub_fields = array();
if( !empty($field['layouts']) ) {
// loop through layouts
foreach( $field['layouts'] as $layout ) {
// extract sub fields
$extra = acf_extract_var( $layout, 'sub_fields' );
// merge
if( !empty($extra) ) {
$sub_fields = array_merge($sub_fields, $extra);
}
}
// foreach
}
// save field to get ID
$field = acf_update_field( $field );
// duplicate sub fields
<API key>( $sub_fields, $field['ID'] );
// return
return $field;
}
/*
* ajax_layout_title
*
* description
*
* @type function
* @date 2/03/2016
* @since 5.3.2
*
* @param $post_id (int)
* @return $post_id (int)
*/
function ajax_layout_title() {
// options
$options = acf_parse_args( $_POST, array(
'post_id' => 0,
'i' => 0,
'field_key' => '',
'nonce' => '',
'layout' => '',
'acf' => array()
));
// load field
$field = acf_get_field( $options['field_key'] );
if( !$field ) die();
// vars
$layout = false;
foreach( $field['layouts'] as $k => $layout ) {
if( $layout['name'] === $options['layout'] ) break;
}
// bail ealry if no layout
if( !$layout ) die();
// value
// this flexible content field may be a sub field so it is important to
// loop though all $_POST data to find thi's field's row value
$value = $options['acf'];
while( is_array($value) ) {
// get first key
$k = key($value);
// update value
$value = array_pop( $value[ $k ] );
// stop looking if we have found the correct field's value
if( $k === $options['field_key'] ) break;
}
// title
$title = $this->get_layout_title( $field, $layout, $options['i'], $value );
// echo
echo $title;
die;
}
function get_layout_title( $field, $layout, $i, $value ) {
// vars
$rows = array();
$rows[ $i ] = $value;
// add loop
acf_add_loop(array(
'selector' => $field['name'],
'name' => $field['name'],
'value' => $rows,
'field' => $field,
'i' => $i,
'post_id' => 0,
));
// vars
$title = $layout['label'];
// filters
$title = apply_filters('acf/fields/flexible_content/layout_title', $title, $field, $layout, $i);
$title = apply_filters('acf/fields/flexible_content/layout_title/name='.$field['_name'], $title, $field, $layout, $i);
$title = apply_filters('acf/fields/flexible_content/layout_title/key='.$field['key'], $title, $field, $layout, $i);
// remove loop
acf_remove_loop();
// prepend order
$title = '<span class="acf-fc-layout-order">' . ($i+1) . '</span> ' . $title;
// return
return $title;
}
/*
* acf_clone_field
*
* This function will update clone field settings based on the origional field
*
* @type function
* @date 28/06/2016
* @since 5.3.8
*
* @param $clone (array)
* @param $field (array)
* @return $clone
*/
function acf_clone_field( $field, $clone_field ) {
// remove parent_layout
// - allows a sub field to be rendered as a normal field
unset($field['parent_layout']);
// attempt to merger parent_layout
if( isset($clone_field['parent_layout']) ) {
$field['parent_layout'] = $clone_field['parent_layout'];
}
// return
return $field;
}
}
// initialize
<API key>( new <API key>() );
endif; // class_exists check
?> |
C
C This source code is part of
C
C G R O M A C S
C
C Copyright (c) 1991-2000, University of Groningen, The Netherlands.
C Copyright (c) 2001-2009, The GROMACS Development Team
C
C Gromacs is a library for molecular simulation and trajectory analysis,
C written by Erik Lindahl, David van der Spoel, Berk Hess, and others - for
C a full list of developers and information, check out http:
C
C This program is free software; you can redistribute it and/or modify it under
C the terms of the GNU Lesser General Public License as published by the Free
C Software Foundation; either version 2 of the License, or (at your option) any
C later version.
C As a special exception, you may use this file as part of a free software
C library without restriction. Specifically, if other files instantiate
C templates or use macros or inline functions from this file, or you compile
C this file and link it with other files to produce an executable, this
C file does not by itself cause the resulting executable to be covered by
C the GNU Lesser General Public License.
C
C In plain-speak: do not worry about classes/macros/templates either - only
C changes to the library have to be LGPL, not an application linking with it.
C
C To help fund GROMACS development, we humbly ask that you cite
C the papers people have written on it - you can find them on the website!
C
C
C Gromacs nonbonded kernel f77skernel313
C Coulomb interaction: Tabulated
C VdW interaction: Lennard-Jones
C water optimization: TIP4P - other atoms
C Calculate forces: yes
C
subroutine f77skernel313(
& nri,
& iinr,
& jindex,
& jjnr,
& shift,
& shiftvec,
& fshift,
& gid,
& pos,
& faction,
& charge,
& facel,
& krf,
& crf,
& Vc,
& type,
& ntype,
& vdwparam,
& Vvdw,
& tabscale,
& VFtab,
& invsqrta,
& dvda,
& gbtabscale,
& GBtab,
& nthreads,
& count,
& mtx,
& outeriter,
& inneriter,
& work)
implicit none
integer*4 nri,iinr(*),jindex(*),jjnr(*),shift(*)
real*4 shiftvec(*),fshift(*),pos(*),faction(*)
integer*4 gid(*),type(*),ntype
real*4 charge(*),facel,krf,crf,Vc(*),vdwparam(*)
real*4 Vvdw(*),tabscale,VFtab(*)
real*4 invsqrta(*),dvda(*),gbtabscale,GBtab(*)
integer*4 nthreads,count,mtx,outeriter,inneriter
real*4 work(*)
integer*4 n,ii,is3,ii3,k,nj0,nj1,jnr,j3,ggid
integer*4 nn0,nn1,nouter,ninner
real*4 shX,shY,shZ
real*4 fscal,tx,ty,tz
real*4 rinvsq
real*4 jq
real*4 qq,vcoul,vctot
integer*4 nti
integer*4 tj
real*4 rinvsix
real*4 Vvdw6,Vvdwtot
real*4 Vvdw12
real*4 r,rt,eps,eps2
integer*4 n0,nnn
real*4 Y,F,Geps,Heps2,Fp,VV
real*4 FF
real*4 fijC
real*4 ix1,iy1,iz1,fix1,fiy1,fiz1
real*4 ix2,iy2,iz2,fix2,fiy2,fiz2
real*4 ix3,iy3,iz3,fix3,fiy3,fiz3
real*4 ix4,iy4,iz4,fix4,fiy4,fiz4
real*4 jx1,jy1,jz1,fjx1,fjy1,fjz1
real*4 dx11,dy11,dz11,rsq11
real*4 dx21,dy21,dz21,rsq21,rinv21
real*4 dx31,dy31,dz31,rsq31,rinv31
real*4 dx41,dy41,dz41,rsq41,rinv41
real*4 qH,qM
real*4 c6,c12
C Initialize water data
ii = iinr(1)+1
qH = facel*charge(ii+1)
qM = facel*charge(ii+3)
nti = 2*ntype*type(ii)
C Reset outer and inner iteration counters
nouter = 0
ninner = 0
C Loop over thread workunits
10 call f77kernelsync(mtx,count,nri,nthreads,nn0,nn1)
if(nn1.gt.nri) nn1=nri
C Start outer loop over neighborlists
do n=nn0+1,nn1
C Load shift vector for this list
is3 = 3*shift(n)+1
shX = shiftvec(is3)
shY = shiftvec(is3+1)
shZ = shiftvec(is3+2)
C Load limits for loop over neighbors
nj0 = jindex(n)+1
nj1 = jindex(n+1)
C Get outer coordinate index
ii = iinr(n)+1
ii3 = 3*ii-2
C Load i atom data, add shift vector
ix1 = shX + pos(ii3+0)
iy1 = shY + pos(ii3+1)
iz1 = shZ + pos(ii3+2)
ix2 = shX + pos(ii3+3)
iy2 = shY + pos(ii3+4)
iz2 = shZ + pos(ii3+5)
ix3 = shX + pos(ii3+6)
iy3 = shY + pos(ii3+7)
iz3 = shZ + pos(ii3+8)
ix4 = shX + pos(ii3+9)
iy4 = shY + pos(ii3+10)
iz4 = shZ + pos(ii3+11)
C Zero the potential energy for this list
vctot = 0
Vvdwtot = 0
C Clear i atom forces
fix1 = 0
fiy1 = 0
fiz1 = 0
fix2 = 0
fiy2 = 0
fiz2 = 0
fix3 = 0
fiy3 = 0
fiz3 = 0
fix4 = 0
fiy4 = 0
fiz4 = 0
do k=nj0,nj1
C Get j neighbor index, and coordinate index
jnr = jjnr(k)+1
j3 = 3*jnr-2
C load j atom coordinates
jx1 = pos(j3+0)
jy1 = pos(j3+1)
jz1 = pos(j3+2)
C Calculate distance
dx11 = ix1 - jx1
dy11 = iy1 - jy1
dz11 = iz1 - jz1
rsq11 = dx11*dx11+dy11*dy11+dz11*dz11
dx21 = ix2 - jx1
dy21 = iy2 - jy1
dz21 = iz2 - jz1
rsq21 = dx21*dx21+dy21*dy21+dz21*dz21
dx31 = ix3 - jx1
dy31 = iy3 - jy1
dz31 = iz3 - jz1
rsq31 = dx31*dx31+dy31*dy31+dz31*dz31
dx41 = ix4 - jx1
dy41 = iy4 - jy1
dz41 = iz4 - jz1
rsq41 = dx41*dx41+dy41*dy41+dz41*dz41
C Calculate 1/r and 1/r2
rinvsq = 1.0/rsq11
rinv21 = 1.0/sqrt(rsq21)
rinv31 = 1.0/sqrt(rsq31)
rinv41 = 1.0/sqrt(rsq41)
C Load parameters for j atom
tj = nti+2*type(jnr)+1
c6 = vdwparam(tj)
c12 = vdwparam(tj+1)
C Lennard-Jones interaction
rinvsix = rinvsq*rinvsq*rinvsq
Vvdw6 = c6*rinvsix
Vvdw12 = c12*rinvsix*rinvsix
Vvdwtot = Vvdwtot+Vvdw12-Vvdw6
fscal = (12.0*Vvdw12-6.0*Vvdw6)*rinvsq
C Calculate temporary vectorial force
tx = fscal*dx11
ty = fscal*dy11
tz = fscal*dz11
C Increment i atom force
fix1 = fix1 + tx
fiy1 = fiy1 + ty
fiz1 = fiz1 + tz
C Decrement j atom force
fjx1 = faction(j3+0) - tx
fjy1 = faction(j3+1) - ty
fjz1 = faction(j3+2) - tz
C Load parameters for j atom
jq = charge(jnr+0)
qq = qH*jq
C Calculate table index
r = rsq21*rinv21
C Calculate table index
rt = r*tabscale
n0 = rt
eps = rt-n0
eps2 = eps*eps
nnn = 4*n0+1
C Tabulated coulomb interaction
Y = VFtab(nnn)
F = VFtab(nnn+1)
Geps = eps*VFtab(nnn+2)
Heps2 = eps2*VFtab(nnn+3)
Fp = F+Geps+Heps2
VV = Y+eps*Fp
FF = Fp+Geps+2.0*Heps2
vcoul = qq*VV
fijC = qq*FF
vctot = vctot + vcoul
fscal = -((fijC)*tabscale)*rinv21
C Calculate temporary vectorial force
tx = fscal*dx21
ty = fscal*dy21
tz = fscal*dz21
C Increment i atom force
fix2 = fix2 + tx
fiy2 = fiy2 + ty
fiz2 = fiz2 + tz
C Decrement j atom force
fjx1 = fjx1 - tx
fjy1 = fjy1 - ty
fjz1 = fjz1 - tz
C Load parameters for j atom
C Calculate table index
r = rsq31*rinv31
C Calculate table index
rt = r*tabscale
n0 = rt
eps = rt-n0
eps2 = eps*eps
nnn = 4*n0+1
C Tabulated coulomb interaction
Y = VFtab(nnn)
F = VFtab(nnn+1)
Geps = eps*VFtab(nnn+2)
Heps2 = eps2*VFtab(nnn+3)
Fp = F+Geps+Heps2
VV = Y+eps*Fp
FF = Fp+Geps+2.0*Heps2
vcoul = qq*VV
fijC = qq*FF
vctot = vctot + vcoul
fscal = -((fijC)*tabscale)*rinv31
C Calculate temporary vectorial force
tx = fscal*dx31
ty = fscal*dy31
tz = fscal*dz31
C Increment i atom force
fix3 = fix3 + tx
fiy3 = fiy3 + ty
fiz3 = fiz3 + tz
C Decrement j atom force
fjx1 = fjx1 - tx
fjy1 = fjy1 - ty
fjz1 = fjz1 - tz
C Load parameters for j atom
qq = qM*jq
C Calculate table index
r = rsq41*rinv41
C Calculate table index
rt = r*tabscale
n0 = rt
eps = rt-n0
eps2 = eps*eps
nnn = 4*n0+1
C Tabulated coulomb interaction
Y = VFtab(nnn)
F = VFtab(nnn+1)
Geps = eps*VFtab(nnn+2)
Heps2 = eps2*VFtab(nnn+3)
Fp = F+Geps+Heps2
VV = Y+eps*Fp
FF = Fp+Geps+2.0*Heps2
vcoul = qq*VV
fijC = qq*FF
vctot = vctot + vcoul
fscal = -((fijC)*tabscale)*rinv41
C Calculate temporary vectorial force
tx = fscal*dx41
ty = fscal*dy41
tz = fscal*dz41
C Increment i atom force
fix4 = fix4 + tx
fiy4 = fiy4 + ty
fiz4 = fiz4 + tz
C Decrement j atom force
faction(j3+0) = fjx1 - tx
faction(j3+1) = fjy1 - ty
faction(j3+2) = fjz1 - tz
C Inner loop uses 158 flops/iteration
end do
C Add i forces to mem and shifted force list
faction(ii3+0) = faction(ii3+0) + fix1
faction(ii3+1) = faction(ii3+1) + fiy1
faction(ii3+2) = faction(ii3+2) + fiz1
faction(ii3+3) = faction(ii3+3) + fix2
faction(ii3+4) = faction(ii3+4) + fiy2
faction(ii3+5) = faction(ii3+5) + fiz2
faction(ii3+6) = faction(ii3+6) + fix3
faction(ii3+7) = faction(ii3+7) + fiy3
faction(ii3+8) = faction(ii3+8) + fiz3
faction(ii3+9) = faction(ii3+9) + fix4
faction(ii3+10) = faction(ii3+10) + fiy4
faction(ii3+11) = faction(ii3+11) + fiz4
fshift(is3) = fshift(is3)+fix1+fix2+fix3+fix4
fshift(is3+1) = fshift(is3+1)+fiy1+fiy2+fiy3+fiy4
fshift(is3+2) = fshift(is3+2)+fiz1+fiz2+fiz3+fiz4
C Add potential energies to the group for this list
ggid = gid(n)+1
Vc(ggid) = Vc(ggid) + vctot
Vvdw(ggid) = Vvdw(ggid) + Vvdwtot
C Increment number of inner iterations
ninner = ninner + nj1 - nj0
C Outer loop uses 38 flops/iteration
end do
C Increment number of outer iterations
nouter = nouter + nn1 - nn0
if(nn1.lt.nri) goto 10
C Write outer/inner iteration count to pointers
outeriter = nouter
inneriter = ninner
return
end
C
C Gromacs nonbonded kernel f77skernel313nf
C Coulomb interaction: Tabulated
C VdW interaction: Lennard-Jones
C water optimization: TIP4P - other atoms
C Calculate forces: no
C
subroutine f77skernel313nf(
& nri,
& iinr,
& jindex,
& jjnr,
& shift,
& shiftvec,
& fshift,
& gid,
& pos,
& faction,
& charge,
& facel,
& krf,
& crf,
& Vc,
& type,
& ntype,
& vdwparam,
& Vvdw,
& tabscale,
& VFtab,
& invsqrta,
& dvda,
& gbtabscale,
& GBtab,
& nthreads,
& count,
& mtx,
& outeriter,
& inneriter,
& work)
implicit none
integer*4 nri,iinr(*),jindex(*),jjnr(*),shift(*)
real*4 shiftvec(*),fshift(*),pos(*),faction(*)
integer*4 gid(*),type(*),ntype
real*4 charge(*),facel,krf,crf,Vc(*),vdwparam(*)
real*4 Vvdw(*),tabscale,VFtab(*)
real*4 invsqrta(*),dvda(*),gbtabscale,GBtab(*)
integer*4 nthreads,count,mtx,outeriter,inneriter
real*4 work(*)
integer*4 n,ii,is3,ii3,k,nj0,nj1,jnr,j3,ggid
integer*4 nn0,nn1,nouter,ninner
real*4 shX,shY,shZ
real*4 rinvsq
real*4 jq
real*4 qq,vcoul,vctot
integer*4 nti
integer*4 tj
real*4 rinvsix
real*4 Vvdw6,Vvdwtot
real*4 Vvdw12
real*4 r,rt,eps,eps2
integer*4 n0,nnn
real*4 Y,F,Geps,Heps2,Fp,VV
real*4 ix1,iy1,iz1
real*4 ix2,iy2,iz2
real*4 ix3,iy3,iz3
real*4 ix4,iy4,iz4
real*4 jx1,jy1,jz1
real*4 dx11,dy11,dz11,rsq11
real*4 dx21,dy21,dz21,rsq21,rinv21
real*4 dx31,dy31,dz31,rsq31,rinv31
real*4 dx41,dy41,dz41,rsq41,rinv41
real*4 qH,qM
real*4 c6,c12
C Initialize water data
ii = iinr(1)+1
qH = facel*charge(ii+1)
qM = facel*charge(ii+3)
nti = 2*ntype*type(ii)
C Reset outer and inner iteration counters
nouter = 0
ninner = 0
C Loop over thread workunits
10 call f77kernelsync(mtx,count,nri,nthreads,nn0,nn1)
if(nn1.gt.nri) nn1=nri
C Start outer loop over neighborlists
do n=nn0+1,nn1
C Load shift vector for this list
is3 = 3*shift(n)+1
shX = shiftvec(is3)
shY = shiftvec(is3+1)
shZ = shiftvec(is3+2)
C Load limits for loop over neighbors
nj0 = jindex(n)+1
nj1 = jindex(n+1)
C Get outer coordinate index
ii = iinr(n)+1
ii3 = 3*ii-2
C Load i atom data, add shift vector
ix1 = shX + pos(ii3+0)
iy1 = shY + pos(ii3+1)
iz1 = shZ + pos(ii3+2)
ix2 = shX + pos(ii3+3)
iy2 = shY + pos(ii3+4)
iz2 = shZ + pos(ii3+5)
ix3 = shX + pos(ii3+6)
iy3 = shY + pos(ii3+7)
iz3 = shZ + pos(ii3+8)
ix4 = shX + pos(ii3+9)
iy4 = shY + pos(ii3+10)
iz4 = shZ + pos(ii3+11)
C Zero the potential energy for this list
vctot = 0
Vvdwtot = 0
C Clear i atom forces
do k=nj0,nj1
C Get j neighbor index, and coordinate index
jnr = jjnr(k)+1
j3 = 3*jnr-2
C load j atom coordinates
jx1 = pos(j3+0)
jy1 = pos(j3+1)
jz1 = pos(j3+2)
C Calculate distance
dx11 = ix1 - jx1
dy11 = iy1 - jy1
dz11 = iz1 - jz1
rsq11 = dx11*dx11+dy11*dy11+dz11*dz11
dx21 = ix2 - jx1
dy21 = iy2 - jy1
dz21 = iz2 - jz1
rsq21 = dx21*dx21+dy21*dy21+dz21*dz21
dx31 = ix3 - jx1
dy31 = iy3 - jy1
dz31 = iz3 - jz1
rsq31 = dx31*dx31+dy31*dy31+dz31*dz31
dx41 = ix4 - jx1
dy41 = iy4 - jy1
dz41 = iz4 - jz1
rsq41 = dx41*dx41+dy41*dy41+dz41*dz41
C Calculate 1/r and 1/r2
rinvsq = 1.0/rsq11
rinv21 = 1.0/sqrt(rsq21)
rinv31 = 1.0/sqrt(rsq31)
rinv41 = 1.0/sqrt(rsq41)
C Load parameters for j atom
tj = nti+2*type(jnr)+1
c6 = vdwparam(tj)
c12 = vdwparam(tj+1)
C Lennard-Jones interaction
rinvsix = rinvsq*rinvsq*rinvsq
Vvdw6 = c6*rinvsix
Vvdw12 = c12*rinvsix*rinvsix
Vvdwtot = Vvdwtot+Vvdw12-Vvdw6
C Load parameters for j atom
jq = charge(jnr+0)
qq = qH*jq
C Calculate table index
r = rsq21*rinv21
C Calculate table index
rt = r*tabscale
n0 = rt
eps = rt-n0
eps2 = eps*eps
nnn = 4*n0+1
C Tabulated coulomb interaction
Y = VFtab(nnn)
F = VFtab(nnn+1)
Geps = eps*VFtab(nnn+2)
Heps2 = eps2*VFtab(nnn+3)
Fp = F+Geps+Heps2
VV = Y+eps*Fp
vcoul = qq*VV
vctot = vctot + vcoul
C Load parameters for j atom
C Calculate table index
r = rsq31*rinv31
C Calculate table index
rt = r*tabscale
n0 = rt
eps = rt-n0
eps2 = eps*eps
nnn = 4*n0+1
C Tabulated coulomb interaction
Y = VFtab(nnn)
F = VFtab(nnn+1)
Geps = eps*VFtab(nnn+2)
Heps2 = eps2*VFtab(nnn+3)
Fp = F+Geps+Heps2
VV = Y+eps*Fp
vcoul = qq*VV
vctot = vctot + vcoul
C Load parameters for j atom
qq = qM*jq
C Calculate table index
r = rsq41*rinv41
C Calculate table index
rt = r*tabscale
n0 = rt
eps = rt-n0
eps2 = eps*eps
nnn = 4*n0+1
C Tabulated coulomb interaction
Y = VFtab(nnn)
F = VFtab(nnn+1)
Geps = eps*VFtab(nnn+2)
Heps2 = eps2*VFtab(nnn+3)
Fp = F+Geps+Heps2
VV = Y+eps*Fp
vcoul = qq*VV
vctot = vctot + vcoul
C Inner loop uses 96 flops/iteration
end do
C Add i forces to mem and shifted force list
C Add potential energies to the group for this list
ggid = gid(n)+1
Vc(ggid) = Vc(ggid) + vctot
Vvdw(ggid) = Vvdw(ggid) + Vvdwtot
C Increment number of inner iterations
ninner = ninner + nj1 - nj0
C Outer loop uses 14 flops/iteration
end do
C Increment number of outer iterations
nouter = nouter + nn1 - nn0
if(nn1.lt.nri) goto 10
C Write outer/inner iteration count to pointers
outeriter = nouter
inneriter = ninner
return
end |
// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
#ifndef <API key>$1__
#define <API key>$1__
#pragma interface
#include <java/util/concurrent/TimeUnit.h>
class java::util::concurrent::TimeUnit$1 : public ::java::util::concurrent::TimeUnit
{
public: // actually package-private
TimeUnit$1(::java::lang::String *, jint);
public:
jlong toNanos(jlong);
jlong toMicros(jlong);
jlong toMillis(jlong);
jlong toSeconds(jlong);
jlong toMinutes(jlong);
jlong toHours(jlong);
jlong toDays(jlong);
jlong convert(jlong, ::java::util::concurrent::TimeUnit *);
public: // actually package-private
jint excessNanos(jlong, jlong);
public:
static ::java::lang::Class class$;
};
#endif // <API key>$1__ |
#ifndef MSVectorImplHEADER
#define MSVectorImplHEADER
#include <MSTypes/MSString.H>
#include <MSTypes/MSError.H>
#include <MSTypes/MSEnum.H>
#ifndef MSDefinesHEADER
#include <MSTypes/MSDefines.H>
#endif
//*** forward declarations ***//
#if HAVE_IOSTREAM
#include <iostream>
// #include <fstream>
using namespace std;
#else
class ostream;
#endif
class MSIndexVector;
class MSBinaryVector;
class MSTypesExport MSVectorImplOps
{
public:
MSVectorImplOps();
virtual ~MSVectorImplOps();
virtual void *allocate (unsigned int, unsigned int =0, MSAllocationFlag =MSRaw) const =0;
virtual void *allocateWithSize (unsigned int, unsigned int =0, MSAllocationFlag =MSRaw) const =0;
virtual void deallocate (void *, unsigned int =0, MSAllocationFlag =MSRaw) const =0;
virtual void incrementCount (void *) const =0;
virtual unsigned int refCount (const void *) const =0;
virtual void set (void *, unsigned int, const void *, MSAllocationFlag =MSConstructed) const =0;
virtual void set (void *, unsigned int, const void *, unsigned int, MSAllocationFlag =MSConstructed) const =0;
virtual void fill (void *, unsigned int, unsigned int, const void *, MSAllocationFlag =MSConstructed) const =0;
virtual void copy (const void *, void *, unsigned int, unsigned int =0, unsigned int =0,
MSAllocationFlag =MSConstructed) const =0;
virtual void copyBackward (void *, unsigned int, unsigned int, unsigned int) const =0;
virtual void destroy (void *, unsigned int, unsigned int) const =0;
virtual int isElementEqual (const void *, unsigned int, const void *) const =0;
virtual int isElementLess (const void *, unsigned int, const void *) const =0;
virtual int isElementLessEqual (const void *, unsigned int, const void *) const =0;
virtual long compareElement (const void *, unsigned int, const void *) const =0;
virtual void * elementAt (const void *, unsigned int) const =0;
virtual unsigned int size (const void *) const =0;
virtual void swapElements (void *, unsigned int, unsigned int) const =0;
virtual unsigned int gradeUp (const void *, unsigned int, unsigned int *) const =0;
virtual unsigned int gradeDown (const void *, unsigned int, unsigned int *) const =0;
virtual void *badData() const =0;
virtual void *defaultFiller() const =0;
virtual MSString asString (const void *, unsigned int) const =0;
virtual MSString asMSF (const void *, unsigned int) const =0;
virtual unsigned int elementLen (const void *, unsigned int) const =0;
virtual MSError::ErrorStatus setFromString (void *, unsigned int, const char *) const =0;
virtual MSError::ErrorStatus setFromMSF (void *, unsigned int, const char *) const =0;
virtual void print (const void *, unsigned int, ostream &) const =0;
virtual unsigned int numElements (const MSString &, const char) const =0;
virtual void setFromMSString (void *, unsigned int, const MSString &, unsigned int&, const char) const =0;
};
class MSTypesExport MSVectorImpl
{
public:
MSVectorImpl (MSVectorImplOps *, unsigned int =0);
MSVectorImpl (MSVectorImplOps *, unsigned int, void *);
MSVectorImpl (const MSVectorImpl &);
MSVectorImpl (MSVectorImplOps *, void *, unsigned int);
virtual ~MSVectorImpl();
virtual MSVectorImpl *create (unsigned int =0, unsigned int =0) const;
virtual MSVectorImpl *clone() const;
void makeUniqueCopy();
INLINELINKAGE void prepareToChange();
void <API key>();
void reallocateInPlace(unsigned int);
INLINELINKAGE void *internalGet (unsigned int) const;
INLINELINKAGE void vectorIndexError (unsigned int) const;
MSVectorImpl & operator= (const MSVectorImpl &);
MSString asString (const char =' ');
virtual MSString asMSF();
virtual MSError::ErrorStatus setFromString (const char *, const char =' ');
virtual MSError::ErrorStatus setFromMSF (const char *);
void set (unsigned, void *);
void setAll (const void *);
void setSelected (const MSIndexVector &, const MSVectorImpl &);
void setSelected (const MSIndexVector &, const void *);
void setSelected (const MSBinaryVector &, const MSVectorImpl &);
void setSelected (const MSBinaryVector &, const void *);
MSIndexVector setIndexSelected (const MSBinaryVector &, const MSVectorImpl &);
MSIndexVector setIndexSelected (const MSBinaryVector &, const void *);
void print (ostream &) const;
unsigned int indexOf (void *, unsigned int) const;
unsigned int lastIndexOf (void *, unsigned int) const;
unsigned int occurrencesOf (const void *, unsigned int) const;
MSIndexVector indicesOf (const MSVectorImpl &) const;
MSBinaryVector memberOf (const MSVectorImpl &) const;
MSError::ErrorStatus append (void *);
MSError::ErrorStatus append (const MSVectorImpl &);
unsigned int append (const char *, const char =' ');
MSError::ErrorStatus insertAt (unsigned int, void *);
MSError::ErrorStatus insertAt (unsigned int, const MSVectorImpl &);
MSError::ErrorStatus removeAt (unsigned int, unsigned int =1);
MSError::ErrorStatus remove (const MSIndexVector &);
MSError::ErrorStatus remove (const MSBinaryVector &);
MSError::ErrorStatus removeAll();
MSError::ErrorStatus select (const MSIndexVector &);
MSError::ErrorStatus compress (const MSBinaryVector &);
MSError::ErrorStatus reshape (unsigned int);
MSError::ErrorStatus exchange (unsigned int, unsigned int);
MSError::ErrorStatus reverse ();
MSError::ErrorStatus rotate (int);
MSError::ErrorStatus take (int, const void * =0);
MSError::ErrorStatus drop (int);
void reverse (const MSVectorImpl &);
void rotate (const MSVectorImpl &, int);
void take (const MSVectorImpl &, int, const void * =0);
void drop (const MSVectorImpl &, int);
void select (const MSVectorImpl &, const MSIndexVector &);
void compress (const MSVectorImpl &, const MSBinaryVector &);
MSBinaryVector unique();
virtual MSIndexVector gradeUp () const;
virtual MSIndexVector gradeDown() const;
INLINELINKAGE void permute (const MSIndexVector &);
unsigned int maxLength() const;
INLINELINKAGE unsigned int length() const;
INLINELINKAGE void *data() const;
long compare (const MSVectorImpl &) const;
MSBinaryVector binaryCompare (const MSVectorImpl &, MSComparison) const;
MSBinaryVector binaryCompare (const void *, MSComparison) const;
MSBoolean scalarCompare (const void *, MSComparison) const;
protected:
MSVectorImplOps *_pOperations;
void *_pElements;
unsigned int _len;
void *reallocate(unsigned int);
void reallocateAndCopy(unsigned int);
void blockLeft (unsigned int, unsigned int, unsigned int);
void blockRight (unsigned int, unsigned int, unsigned int);
INLINELINKAGE void internalSet (unsigned int, const void *);
INLINELINKAGE void internalSet (unsigned int, const MSVectorImpl &, unsigned int);
void indexError (unsigned int) const;
static unsigned int minSize();
void mergeSortUp(unsigned int *, unsigned int *) const;
void mergeSortDown(unsigned int *, unsigned int *) const;
};
#endif // MSVectorImplHEADER |
<?php
/**
* geo_fr_street_base module helper.
*
* @package e-venement
* @subpackage geo_fr_street_base
* @author Baptiste SIMON <baptiste.simon AT e-glop.net>
* @version SVN: $Id: helper.php 23810 2009-11-12 11:07:44Z Kris.Wallsmith $
*/
class <API key> extends <API key>
{
} |
#include <<API key>.h>
double
average(double *ar,
size_t n)
{
size_t i;
double sum = 0.;
if (n <= 0) {
log_err("Divide by zero or negative");
}
else if (n == 1) {
return ar[0];
}
else {
for (i = 0; i < n; i++) {
sum += ar[i];
}
}
return sum / n;
}
double
q_to_vp(double q,
double p)
{
double vp;
// full equation
// vp = q/(q+CONST_EPS*(1-q))*p;
// approximation used in VIC
vp = q * p / CONST_EPS;
return vp;
}
double
air_density(double t,
double p)
{
double rho;
// full equation
// rho = (p*1000)/(Rd * *t+CONST_TKFRZ) + (pv*1000)/(Rv * *t+CONST_TKFRZ);
// approximation used in VIC
rho = p / (CONST_RDAIR * (CONST_TKFRZ + t));
return rho;
}
char
will_it_snow(double *t,
double t_offset,
double max_snow_temp,
double *prcp,
size_t n)
{
size_t i;
for (i = 0; i < n; i++) {
if ((t[i] + t_offset) < max_snow_temp && prcp[i] > 0.) {
return 1;
}
}
return 0;
}
size_t
count_force_vars(FILE *gp)
{
size_t nvars;
unsigned long start_position;
char cmdstr[MAXSTRING];
char optstr[MAXSTRING];
// Figure out where we are in the input file
fflush(gp);
start_position = ftell(gp);
// read the first line
fgets(cmdstr, MAXSTRING, gp);
// initalize nvars
nvars = 0;
// Loop through the lines
while (!feof(gp)) {
if (cmdstr[0] != '#' && cmdstr[0] != '\n' && cmdstr[0] != '\0') {
// line is not blank or a comment
sscanf(cmdstr, "%s", optstr);
// if the line starts with FORCE_TYPE
if (strcasecmp("FORCE_TYPE", optstr) == 0) {
nvars++;
}
// else if we arive at another forcing file break out of loop
else if (strcasecmp("FORCING1", optstr) == 0 ||
strcasecmp("FORCING2", optstr) == 0) {
break;
}
}
fgets(cmdstr, MAXSTRING, gp);
}
// put the position in the file back to where we started
fseek(gp, start_position, SEEK_SET);
return nvars;
} |
/* $Id: byaddr.c,v 1.39 2007/06/19 23:47:16 tbox Exp $ */
/*! \file */
#include <config.h>
#include <isc/mem.h>
#include <isc/netaddr.h>
#include <isc/print.h>
#include <isc/string.h> /* Required for HP/UX (and others?) */
#include <isc/task.h>
#include <isc/util.h>
#include <dns/byaddr.h>
#include <dns/db.h>
#include <dns/events.h>
#include <dns/lookup.h>
#include <dns/rdata.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/resolver.h>
#include <dns/result.h>
#include <dns/view.h>
/*
* XXXRTH We could use a static event...
*/
struct dns_byaddr {
/* Unlocked. */
unsigned int magic;
isc_mem_t * mctx;
isc_mutex_t lock;
dns_fixedname_t name;
/* Locked by lock. */
unsigned int options;
dns_lookup_t * lookup;
isc_task_t * task;
dns_byaddrevent_t * event;
isc_boolean_t canceled;
};
#define BYADDR_MAGIC ISC_MAGIC('B', 'y', 'A', 'd')
#define VALID_BYADDR(b) ISC_MAGIC_VALID(b, BYADDR_MAGIC)
#define MAX_RESTARTS 16
static char hex_digits[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};
isc_result_t
<API key>(isc_netaddr_t *address, isc_boolean_t nibble,
dns_name_t *name)
{
/*
* We dropped bitstring labels, so all lookups will use nibbles.
*/
UNUSED(nibble);
return (<API key>(address,
<API key>, name));
}
isc_result_t
<API key>(isc_netaddr_t *address, unsigned int options,
dns_name_t *name)
{
char textname[128];
unsigned char *bytes;
int i;
char *cp;
isc_buffer_t buffer;
unsigned int len;
REQUIRE(address != NULL);
/*
* We create the text representation and then convert to a
* dns_name_t. This is not maximally efficient, but it keeps all
* of the knowledge of wire format in the dns_name_ routines.
*/
bytes = (unsigned char *)(&address->type);
if (address->family == AF_INET) {
(void)snprintf(textname, sizeof(textname),
"%u.%u.%u.%u.in-addr.arpa.",
(bytes[3] & 0xff),
(bytes[2] & 0xff),
(bytes[1] & 0xff),
(bytes[0] & 0xff));
} else if (address->family == AF_INET6) {
cp = textname;
for (i = 15; i >= 0; i
*cp++ = hex_digits[bytes[i] & 0x0f];
*cp++ = '.';
*cp++ = hex_digits[(bytes[i] >> 4) & 0x0f];
*cp++ = '.';
}
if ((options & <API key>) != 0)
strcpy(cp, "ip6.int.");
else
strcpy(cp, "ip6.arpa.");
} else
return (<API key>);
len = (unsigned int)strlen(textname);
isc_buffer_init(&buffer, textname, len);
isc_buffer_add(&buffer, len);
return (dns_name_fromtext(name, &buffer, dns_rootname,
ISC_FALSE, NULL));
}
static inline isc_result_t
copy_ptr_targets(dns_byaddr_t *byaddr, dns_rdataset_t *rdataset) {
isc_result_t result;
dns_name_t *name;
dns_rdata_t rdata = DNS_RDATA_INIT;
/*
* The caller must be holding the byaddr's lock.
*/
result = dns_rdataset_first(rdataset);
while (result == ISC_R_SUCCESS) {
dns_rdata_ptr_t ptr;
<API key>(rdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &ptr, NULL);
if (result != ISC_R_SUCCESS)
return (result);
name = isc_mem_get(byaddr->mctx, sizeof(*name));
if (name == NULL) {
<API key>(&ptr);
return (ISC_R_NOMEMORY);
}
dns_name_init(name, NULL);
result = dns_name_dup(&ptr.ptr, byaddr->mctx, name);
<API key>(&ptr);
if (result != ISC_R_SUCCESS) {
isc_mem_put(byaddr->mctx, name, sizeof(*name));
return (ISC_R_NOMEMORY);
}
ISC_LIST_APPEND(byaddr->event->names, name, link);
dns_rdata_reset(&rdata);
result = dns_rdataset_next(rdataset);
}
if (result == ISC_R_NOMORE)
result = ISC_R_SUCCESS;
return (result);
}
static void
lookup_done(isc_task_t *task, isc_event_t *event) {
dns_byaddr_t *byaddr = event->ev_arg;
dns_lookupevent_t *levent;
isc_result_t result;
REQUIRE(event->ev_type == <API key>);
REQUIRE(VALID_BYADDR(byaddr));
REQUIRE(byaddr->task == task);
UNUSED(task);
levent = (dns_lookupevent_t *)event;
if (levent->result == ISC_R_SUCCESS) {
result = copy_ptr_targets(byaddr, levent->rdataset);
byaddr->event->result = result;
} else
byaddr->event->result = levent->result;
isc_event_free(&event);
<API key>(&byaddr->task, (isc_event_t **)&byaddr->event);
}
static void
bevent_destroy(isc_event_t *event) {
dns_byaddrevent_t *bevent;
dns_name_t *name, *next_name;
isc_mem_t *mctx;
REQUIRE(event->ev_type == <API key>);
mctx = event->ev_destroy_arg;
bevent = (dns_byaddrevent_t *)event;
for (name = ISC_LIST_HEAD(bevent->names);
name != NULL;
name = next_name) {
next_name = ISC_LIST_NEXT(name, link);
ISC_LIST_UNLINK(bevent->names, name, link);
dns_name_free(name, mctx);
isc_mem_put(mctx, name, sizeof(*name));
}
isc_mem_put(mctx, event, event->ev_size);
}
isc_result_t
dns_byaddr_create(isc_mem_t *mctx, isc_netaddr_t *address, dns_view_t *view,
unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg, dns_byaddr_t **byaddrp)
{
isc_result_t result;
dns_byaddr_t *byaddr;
isc_event_t *ievent;
byaddr = isc_mem_get(mctx, sizeof(*byaddr));
if (byaddr == NULL)
return (ISC_R_NOMEMORY);
byaddr->mctx = mctx;
byaddr->options = options;
byaddr->event = isc_mem_get(mctx, sizeof(*byaddr->event));
if (byaddr->event == NULL) {
result = ISC_R_NOMEMORY;
goto cleanup_byaddr;
}
ISC_EVENT_INIT(byaddr->event, sizeof(*byaddr->event), 0, NULL,
<API key>, action, arg, byaddr,
bevent_destroy, mctx);
byaddr->event->result = ISC_R_FAILURE;
ISC_LIST_INIT(byaddr->event->names);
byaddr->task = NULL;
isc_task_attach(task, &byaddr->task);
result = isc_mutex_init(&byaddr->lock);
if (result != ISC_R_SUCCESS)
goto cleanup_event;
dns_fixedname_init(&byaddr->name);
result = <API key>(address, options,
dns_fixedname_name(&byaddr->name));
if (result != ISC_R_SUCCESS)
goto cleanup_lock;
byaddr->lookup = NULL;
result = dns_lookup_create(mctx, dns_fixedname_name(&byaddr->name),
dns_rdatatype_ptr, view, 0, task,
lookup_done, byaddr, &byaddr->lookup);
if (result != ISC_R_SUCCESS)
goto cleanup_lock;
byaddr->canceled = ISC_FALSE;
byaddr->magic = BYADDR_MAGIC;
*byaddrp = byaddr;
return (ISC_R_SUCCESS);
cleanup_lock:
DESTROYLOCK(&byaddr->lock);
cleanup_event:
ievent = (isc_event_t *)byaddr->event;
isc_event_free(&ievent);
byaddr->event = NULL;
isc_task_detach(&byaddr->task);
cleanup_byaddr:
isc_mem_put(mctx, byaddr, sizeof(*byaddr));
return (result);
}
void
dns_byaddr_cancel(dns_byaddr_t *byaddr) {
REQUIRE(VALID_BYADDR(byaddr));
LOCK(&byaddr->lock);
if (!byaddr->canceled) {
byaddr->canceled = ISC_TRUE;
if (byaddr->lookup != NULL)
dns_lookup_cancel(byaddr->lookup);
}
UNLOCK(&byaddr->lock);
}
void
dns_byaddr_destroy(dns_byaddr_t **byaddrp) {
dns_byaddr_t *byaddr;
REQUIRE(byaddrp != NULL);
byaddr = *byaddrp;
REQUIRE(VALID_BYADDR(byaddr));
REQUIRE(byaddr->event == NULL);
REQUIRE(byaddr->task == NULL);
dns_lookup_destroy(&byaddr->lookup);
DESTROYLOCK(&byaddr->lock);
byaddr->magic = 0;
isc_mem_put(byaddr->mctx, byaddr, sizeof(*byaddr));
*byaddrp = NULL;
} |
#if !defined (TERMINAL_H)
#define TERMINAL_H 1
/* If we're using autoconf, it will define HAVE_TERMIOS_H,
HAVE_TERMIO_H and HAVE_SGTTY_H for us. One day we can rewrite
ser-unix.c and inflow.c to inspect those names instead of
HAVE_TERMIOS, HAVE_TERMIO and the implicit HAVE_SGTTY (when neither
HAVE_TERMIOS or HAVE_TERMIO is set). Until then, make sure that
nothing has already defined the one of the names, and do the right
thing. */
#if !defined (HAVE_TERMIOS) && !defined(HAVE_TERMIO) && !defined(HAVE_SGTTY)
#if defined(HAVE_TERMIOS_H)
#define HAVE_TERMIOS
#else /* ! defined (HAVE_TERMIOS_H) */
#if defined(HAVE_TERMIO_H)
#define HAVE_TERMIO
#else /* ! defined (HAVE_TERMIO_H) */
#if defined(HAVE_SGTTY_H)
#define HAVE_SGTTY
#endif /* ! defined (HAVE_SGTTY_H) */
#endif /* ! defined (HAVE_TERMIO_H) */
#endif /* ! defined (HAVE_TERMIOS_H) */
#endif /* !defined (HAVE_TERMIOS) && !defined(HAVE_TERMIO) && !defined(HAVE_SGTTY) */
#if defined(HAVE_TERMIOS)
#include <termios.h>
#endif
#if !defined(_WIN32) && !defined (HAVE_TERMIOS)
/* Define a common set of macros -- BSD based -- and redefine whatever
the system offers to make it look like that. FIXME: serial.h and
ser-*.c deal with this in a much cleaner fashion; as soon as stuff
is converted to use them, can get rid of this crap. */
#ifdef HAVE_TERMIO
#include <termio.h>
#undef TIOCGETP
#define TIOCGETP TCGETA
#undef TIOCSETN
#define TIOCSETN TCSETA
#undef TIOCSETP
#define TIOCSETP TCSETAF
#define TERMINAL struct termio
#else /* sgtty */
#include <fcntl.h>
#include <sgtty.h>
#include <sys/ioctl.h>
#define TERMINAL struct sgttyb
#endif /* sgtty */
#endif
struct inferior;
extern void new_tty_prefork (const char *);
extern void new_tty (void);
extern void new_tty_postfork (void);
extern void copy_terminal_info (struct inferior *to, struct inferior *from);
/* Do we have job control? Can be assumed to always be the same within
a given run of GDB. In inflow.c. */
extern int job_control;
extern pid_t create_tty_session (void);
/* Set the process group of the caller to its own pid, or do nothing if
we lack job control. */
extern int gdb_setpgid (void);
/* Set up a serial structure describing standard input. In inflow.c. */
extern void <API key> (void);
extern int gdb_has_a_terminal (void);
/* Set the process group of the caller to its own pid, or do nothing
if we lack job control. */
extern int gdb_setpgid (void);
#endif /* !defined (TERMINAL_H) */ |
.size 8000
.text@48
jp lstatint
.text@100
jp lbegin
.data@143
80
.text@150
lbegin:
ld a, ff
ldff(45), a
ld b, 40
call lwaitly_b
ld a, 40
ldff(41), a
ld a, 02
ldff(ff), a
xor a, a
ldff(0f), a
ei
ld a, 44
ldff(45), a
.text@1000
lstatint:
nop
.text@1020
ld a, 77
ldff(44), a
ldff a, (41)
jp lprint_a
.text@7000
lprint_a:
push af
ld b, 91
call lwaitly_b
xor a, a
ldff(40), a
ld bc, 7a00
ld hl, 8000
ld d, 00
lprint_copytiles:
ld a, (bc)
inc bc
ld(hl++), a
dec d
jrnz lprint_copytiles
pop af
ld b, a
srl a
srl a
srl a
srl a
ld(9800), a
ld a, b
and a, 0f
ld(9801), a
ld a, c0
ldff(47), a
ld a, 80
ldff(68), a
ld a, ff
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
xor a, a
ldff(69), a
ldff(69), a
ldff(43), a
ld a, 91
ldff(40), a
lprint_limbo:
jr lprint_limbo
.text@7400
lwaitly_b:
ld c, 44
lwaitly_b_loop:
ldff a, (c)
cmp a, b
jrnz lwaitly_b_loop
ret
.data@7a00
00 00 7f 7f 41 41 41 41
41 41 41 41 41 41 7f 7f
00 00 08 08 08 08 08 08
08 08 08 08 08 08 08 08
00 00 7f 7f 01 01 01 01
7f 7f 40 40 40 40 7f 7f
00 00 7f 7f 01 01 01 01
3f 3f 01 01 01 01 7f 7f
00 00 41 41 41 41 41 41
7f 7f 01 01 01 01 01 01
00 00 7f 7f 40 40 40 40
7e 7e 01 01 01 01 7e 7e
00 00 7f 7f 40 40 40 40
7f 7f 41 41 41 41 7f 7f
00 00 7f 7f 01 01 02 02
04 04 08 08 10 10 10 10
00 00 3e 3e 41 41 41 41
3e 3e 41 41 41 41 3e 3e
00 00 7f 7f 41 41 41 41
7f 7f 01 01 01 01 7f 7f
00 00 08 08 22 22 41 41
7f 7f 41 41 41 41 41 41
00 00 7e 7e 41 41 41 41
7e 7e 41 41 41 41 7e 7e
00 00 3e 3e 41 41 40 40
40 40 40 40 41 41 3e 3e
00 00 7e 7e 41 41 41 41
41 41 41 41 41 41 7e 7e
00 00 7f 7f 40 40 40 40
7f 7f 40 40 40 40 7f 7f
00 00 7f 7f 40 40 40 40
7f 7f 40 40 40 40 40 40 |
#ifndef _ASM_ASMMACRO_32_H
#define _ASM_ASMMACRO_32_H
#include <asm/asm-offsets.h>
#include <asm/regdef.h>
#include <asm/fpregdef.h>
#include <asm/mipsregs.h>
#ifdef <API key>
/* copy stuff from MIPS64 */
.macro fpu_save_16even thread tmp=t0
cfc1 \tmp, fcr31
sdc1 $f0, THREAD_FPR0(\thread)
sdc1 $f2, THREAD_FPR2(\thread)
sdc1 $f4, THREAD_FPR4(\thread)
sdc1 $f6, THREAD_FPR6(\thread)
sdc1 $f8, THREAD_FPR8(\thread)
sdc1 $f10, THREAD_FPR10(\thread)
sdc1 $f12, THREAD_FPR12(\thread)
sdc1 $f14, THREAD_FPR14(\thread)
sdc1 $f16, THREAD_FPR16(\thread)
sdc1 $f18, THREAD_FPR18(\thread)
sdc1 $f20, THREAD_FPR20(\thread)
sdc1 $f22, THREAD_FPR22(\thread)
sdc1 $f24, THREAD_FPR24(\thread)
sdc1 $f26, THREAD_FPR26(\thread)
sdc1 $f28, THREAD_FPR28(\thread)
sdc1 $f30, THREAD_FPR30(\thread)
sw \tmp, THREAD_FCR31(\thread)
.endm
.macro fpu_save_16odd thread
.set push
.set mips64r2
sdc1 $f1, THREAD_FPR1(\thread)
sdc1 $f3, THREAD_FPR3(\thread)
sdc1 $f5, THREAD_FPR5(\thread)
sdc1 $f7, THREAD_FPR7(\thread)
sdc1 $f9, THREAD_FPR9(\thread)
sdc1 $f11, THREAD_FPR11(\thread)
sdc1 $f13, THREAD_FPR13(\thread)
sdc1 $f15, THREAD_FPR15(\thread)
sdc1 $f17, THREAD_FPR17(\thread)
sdc1 $f19, THREAD_FPR19(\thread)
sdc1 $f21, THREAD_FPR21(\thread)
sdc1 $f23, THREAD_FPR23(\thread)
sdc1 $f25, THREAD_FPR25(\thread)
sdc1 $f27, THREAD_FPR27(\thread)
sdc1 $f29, THREAD_FPR29(\thread)
sdc1 $f31, THREAD_FPR31(\thread)
.set pop
.endm
.macro fpu_save_double thread status tmp
.set push
.set noreorder
sll \tmp, \status, 31 - _ST0_FR
bgez \tmp, 2f
nop
fpu_save_16odd \thread
2:
fpu_save_16even \thread \tmp
.set pop
.endm
.macro fpu_restore_16even thread tmp=t0
lw \tmp, THREAD_FCR31(\thread)
ldc1 $f0, THREAD_FPR0(\thread)
ldc1 $f2, THREAD_FPR2(\thread)
ldc1 $f4, THREAD_FPR4(\thread)
ldc1 $f6, THREAD_FPR6(\thread)
ldc1 $f8, THREAD_FPR8(\thread)
ldc1 $f10, THREAD_FPR10(\thread)
ldc1 $f12, THREAD_FPR12(\thread)
ldc1 $f14, THREAD_FPR14(\thread)
ldc1 $f16, THREAD_FPR16(\thread)
ldc1 $f18, THREAD_FPR18(\thread)
ldc1 $f20, THREAD_FPR20(\thread)
ldc1 $f22, THREAD_FPR22(\thread)
ldc1 $f24, THREAD_FPR24(\thread)
ldc1 $f26, THREAD_FPR26(\thread)
ldc1 $f28, THREAD_FPR28(\thread)
ldc1 $f30, THREAD_FPR30(\thread)
ctc1 \tmp, fcr31
.endm
.macro fpu_restore_16odd thread
.set push
.set mips64r2
ldc1 $f1, THREAD_FPR1(\thread)
ldc1 $f3, THREAD_FPR3(\thread)
ldc1 $f5, THREAD_FPR5(\thread)
ldc1 $f7, THREAD_FPR7(\thread)
ldc1 $f9, THREAD_FPR9(\thread)
ldc1 $f11, THREAD_FPR11(\thread)
ldc1 $f13, THREAD_FPR13(\thread)
ldc1 $f15, THREAD_FPR15(\thread)
ldc1 $f17, THREAD_FPR17(\thread)
ldc1 $f19, THREAD_FPR19(\thread)
ldc1 $f21, THREAD_FPR21(\thread)
ldc1 $f23, THREAD_FPR23(\thread)
ldc1 $f25, THREAD_FPR25(\thread)
ldc1 $f27, THREAD_FPR27(\thread)
ldc1 $f29, THREAD_FPR29(\thread)
ldc1 $f31, THREAD_FPR31(\thread)
.set pop
.endm
.macro fpu_restore_double thread status tmp
.set push
.set noreorder
sll \tmp, \status, 31 - _ST0_FR
bgez \tmp, 1f # 16 register mode?
nop
fpu_restore_16odd \thread
1: fpu_restore_16even \thread \tmp
.set pop
.endm
#else
.macro fpu_save_double thread status tmp1=t0
cfc1 \tmp1, fcr31
sdc1 $f0, THREAD_FPR0(\thread)
sdc1 $f2, THREAD_FPR2(\thread)
sdc1 $f4, THREAD_FPR4(\thread)
sdc1 $f6, THREAD_FPR6(\thread)
sdc1 $f8, THREAD_FPR8(\thread)
sdc1 $f10, THREAD_FPR10(\thread)
sdc1 $f12, THREAD_FPR12(\thread)
sdc1 $f14, THREAD_FPR14(\thread)
sdc1 $f16, THREAD_FPR16(\thread)
sdc1 $f18, THREAD_FPR18(\thread)
sdc1 $f20, THREAD_FPR20(\thread)
sdc1 $f22, THREAD_FPR22(\thread)
sdc1 $f24, THREAD_FPR24(\thread)
sdc1 $f26, THREAD_FPR26(\thread)
sdc1 $f28, THREAD_FPR28(\thread)
sdc1 $f30, THREAD_FPR30(\thread)
sw \tmp1, THREAD_FCR31(\thread)
.endm
.macro fpu_save_single thread tmp=t0
cfc1 \tmp, fcr31
swc1 $f0, THREAD_FPR0(\thread)
swc1 $f1, THREAD_FPR1(\thread)
swc1 $f2, THREAD_FPR2(\thread)
swc1 $f3, THREAD_FPR3(\thread)
swc1 $f4, THREAD_FPR4(\thread)
swc1 $f5, THREAD_FPR5(\thread)
swc1 $f6, THREAD_FPR6(\thread)
swc1 $f7, THREAD_FPR7(\thread)
swc1 $f8, THREAD_FPR8(\thread)
swc1 $f9, THREAD_FPR9(\thread)
swc1 $f10, THREAD_FPR10(\thread)
swc1 $f11, THREAD_FPR11(\thread)
swc1 $f12, THREAD_FPR12(\thread)
swc1 $f13, THREAD_FPR13(\thread)
swc1 $f14, THREAD_FPR14(\thread)
swc1 $f15, THREAD_FPR15(\thread)
swc1 $f16, THREAD_FPR16(\thread)
swc1 $f17, THREAD_FPR17(\thread)
swc1 $f18, THREAD_FPR18(\thread)
swc1 $f19, THREAD_FPR19(\thread)
swc1 $f20, THREAD_FPR20(\thread)
swc1 $f21, THREAD_FPR21(\thread)
swc1 $f22, THREAD_FPR22(\thread)
swc1 $f23, THREAD_FPR23(\thread)
swc1 $f24, THREAD_FPR24(\thread)
swc1 $f25, THREAD_FPR25(\thread)
swc1 $f26, THREAD_FPR26(\thread)
swc1 $f27, THREAD_FPR27(\thread)
swc1 $f28, THREAD_FPR28(\thread)
swc1 $f29, THREAD_FPR29(\thread)
swc1 $f30, THREAD_FPR30(\thread)
swc1 $f31, THREAD_FPR31(\thread)
sw \tmp, THREAD_FCR31(\thread)
.endm
.macro fpu_restore_double thread status tmp=t0
lw \tmp, THREAD_FCR31(\thread)
ldc1 $f0, THREAD_FPR0(\thread)
ldc1 $f2, THREAD_FPR2(\thread)
ldc1 $f4, THREAD_FPR4(\thread)
ldc1 $f6, THREAD_FPR6(\thread)
ldc1 $f8, THREAD_FPR8(\thread)
ldc1 $f10, THREAD_FPR10(\thread)
ldc1 $f12, THREAD_FPR12(\thread)
ldc1 $f14, THREAD_FPR14(\thread)
ldc1 $f16, THREAD_FPR16(\thread)
ldc1 $f18, THREAD_FPR18(\thread)
ldc1 $f20, THREAD_FPR20(\thread)
ldc1 $f22, THREAD_FPR22(\thread)
ldc1 $f24, THREAD_FPR24(\thread)
ldc1 $f26, THREAD_FPR26(\thread)
ldc1 $f28, THREAD_FPR28(\thread)
ldc1 $f30, THREAD_FPR30(\thread)
ctc1 \tmp, fcr31
.endm
.macro fpu_restore_single thread tmp=t0
lw \tmp, THREAD_FCR31(\thread)
lwc1 $f0, THREAD_FPR0(\thread)
lwc1 $f1, THREAD_FPR1(\thread)
lwc1 $f2, THREAD_FPR2(\thread)
lwc1 $f3, THREAD_FPR3(\thread)
lwc1 $f4, THREAD_FPR4(\thread)
lwc1 $f5, THREAD_FPR5(\thread)
lwc1 $f6, THREAD_FPR6(\thread)
lwc1 $f7, THREAD_FPR7(\thread)
lwc1 $f8, THREAD_FPR8(\thread)
lwc1 $f9, THREAD_FPR9(\thread)
lwc1 $f10, THREAD_FPR10(\thread)
lwc1 $f11, THREAD_FPR11(\thread)
lwc1 $f12, THREAD_FPR12(\thread)
lwc1 $f13, THREAD_FPR13(\thread)
lwc1 $f14, THREAD_FPR14(\thread)
lwc1 $f15, THREAD_FPR15(\thread)
lwc1 $f16, THREAD_FPR16(\thread)
lwc1 $f17, THREAD_FPR17(\thread)
lwc1 $f18, THREAD_FPR18(\thread)
lwc1 $f19, THREAD_FPR19(\thread)
lwc1 $f20, THREAD_FPR20(\thread)
lwc1 $f21, THREAD_FPR21(\thread)
lwc1 $f22, THREAD_FPR22(\thread)
lwc1 $f23, THREAD_FPR23(\thread)
lwc1 $f24, THREAD_FPR24(\thread)
lwc1 $f25, THREAD_FPR25(\thread)
lwc1 $f26, THREAD_FPR26(\thread)
lwc1 $f27, THREAD_FPR27(\thread)
lwc1 $f28, THREAD_FPR28(\thread)
lwc1 $f29, THREAD_FPR29(\thread)
lwc1 $f30, THREAD_FPR30(\thread)
lwc1 $f31, THREAD_FPR31(\thread)
ctc1 \tmp, fcr31
.endm
#endif // <API key>
.macro cpu_save_nonscratch thread
LONG_S s0, THREAD_REG16(\thread)
LONG_S s1, THREAD_REG17(\thread)
LONG_S s2, THREAD_REG18(\thread)
LONG_S s3, THREAD_REG19(\thread)
LONG_S s4, THREAD_REG20(\thread)
LONG_S s5, THREAD_REG21(\thread)
LONG_S s6, THREAD_REG22(\thread)
LONG_S s7, THREAD_REG23(\thread)
LONG_S sp, THREAD_REG29(\thread)
LONG_S fp, THREAD_REG30(\thread)
.endm
.macro <API key> thread
LONG_L s0, THREAD_REG16(\thread)
LONG_L s1, THREAD_REG17(\thread)
LONG_L s2, THREAD_REG18(\thread)
LONG_L s3, THREAD_REG19(\thread)
LONG_L s4, THREAD_REG20(\thread)
LONG_L s5, THREAD_REG21(\thread)
LONG_L s6, THREAD_REG22(\thread)
LONG_L s7, THREAD_REG23(\thread)
LONG_L sp, THREAD_REG29(\thread)
LONG_L fp, THREAD_REG30(\thread)
LONG_L ra, THREAD_REG31(\thread)
.endm
#endif /* _ASM_ASMMACRO_32_H */ |
#include <console/console.h>
#include <device/device.h>
#include <device/pci.h>
#include <arch/io.h>
#include <cpu/x86/msr.h>
#include <cpu/amd/mtrr.h>
#include <device/pci_def.h>
#include "SBPLATFORM.h"
u8 is_dev3_present(void);
void set_pcie_dereset(void);
void set_pcie_reset(void);
void enable_int_gfx(void);
/* GPIO6. */
void enable_int_gfx(void)
{
volatile u8 *gpio_reg;
/* make sure the Acpi MMIO(fed80000) is accessible */
RWPMIO(SB_PMIOA_REG24, AccWidthUint8, ~(BIT0), BIT0);
gpio_reg = (volatile u8 *)ACPI_MMIO_BASE + 0xD00; /* IoMux Register */
*(gpio_reg + 0x6) = 0x1; /* Int_vga_en */
*(gpio_reg + 170) = 0x1; /* gpio_gate */
gpio_reg = (volatile u8 *)ACPI_MMIO_BASE + 0x100; /* GPIO Registers */
*(gpio_reg + 0x6) = 0x8;
*(gpio_reg + 170) = 0x0;
}
void set_pcie_dereset()
{
}
void set_pcie_reset(void)
{
}
u8 is_dev3_present(void)
{
return 1;
}
static void mainboard_enable(device_t dev)
{
printk(BIOS_INFO, "Mainboard " <API key> " Enable.\n");
set_pcie_dereset();
enable_int_gfx();
}
struct chip_operations mainboard_ops = {
.enable_dev = mainboard_enable,
}; |
#include "config.h"
#include "wtf/Platform.h"
#if ENABLE(SVG)
#include "<API key>.h"
#include "FloatConversion.h"
#include "FloatPoint.h"
#include "FloatSize.h"
#include "SVGTransform.h"
#include <math.h>
namespace WebCore {
<API key>::<API key>()
: m_type(SVGTransform::<API key>)
, m_angle(0)
{
}
<API key>::<API key>(SVGTransform::SVGTransformType type, float angle, float cx, float cy, const AffineTransform& transform)
: m_type(type)
, m_angle(angle)
, m_cx(cx)
, m_cy(cy)
, m_transform(transform)
{
}
<API key>::<API key>(const SVGTransform& fromSVGTransform, const SVGTransform& toSVGTransform)
: m_type(fromSVGTransform.type())
, m_angle(0)
, m_cx(0)
, m_cy(0)
{
ASSERT(m_type == toSVGTransform.type());
switch (m_type) {
case SVGTransform::<API key>:
return;
case SVGTransform::<API key>:
// FIXME: need to be able to subtract to matrices
return;
case SVGTransform::<API key>:
{
FloatSize centerDistance = toSVGTransform.rotationCenter() - fromSVGTransform.rotationCenter();
m_angle = toSVGTransform.angle() - fromSVGTransform.angle();
m_cx = centerDistance.width();
m_cy = centerDistance.height();
return;
}
case SVGTransform::<API key>:
{
FloatSize translationDistance = toSVGTransform.translate() - fromSVGTransform.translate();
m_transform.translate(translationDistance.width(), translationDistance.height());
return;
}
case SVGTransform::SVG_TRANSFORM_SCALE:
{
float scaleX = toSVGTransform.scale().width() - fromSVGTransform.scale().width();
float scaleY = toSVGTransform.scale().height() - fromSVGTransform.scale().height();
m_transform.scale(scaleX, scaleY);
return;
}
case SVGTransform::SVG_TRANSFORM_SKEWX:
case SVGTransform::SVG_TRANSFORM_SKEWY:
m_angle = toSVGTransform.angle() - fromSVGTransform.angle();
return;
}
}
<API key> <API key>::scaledDistance(float scaleFactor) const
{
switch (m_type) {
case SVGTransform::<API key>:
return <API key>();
case SVGTransform::<API key>:
return <API key>(m_type, m_angle * scaleFactor, m_cx * scaleFactor, m_cy * scaleFactor, AffineTransform());
case SVGTransform::SVG_TRANSFORM_SCALE:
case SVGTransform::<API key>:
return <API key>(m_type, m_angle * scaleFactor, m_cx * scaleFactor, m_cy * scaleFactor, AffineTransform(m_transform).scale(scaleFactor));
case SVGTransform::<API key>:
{
AffineTransform newTransform(m_transform);
newTransform.setE(m_transform.e() * scaleFactor);
newTransform.setF(m_transform.f() * scaleFactor);
return <API key>(m_type, 0, 0, 0, newTransform);
}
case SVGTransform::SVG_TRANSFORM_SKEWX:
case SVGTransform::SVG_TRANSFORM_SKEWY:
return <API key>(m_type, m_angle * scaleFactor, m_cx * scaleFactor, m_cy * scaleFactor, AffineTransform());
}
ASSERT_NOT_REACHED();
return <API key>();
}
SVGTransform <API key>::addSVGTransforms(const SVGTransform& first, const SVGTransform& second)
{
ASSERT(first.type() == second.type());
SVGTransform transform;
switch (first.type()) {
case SVGTransform::<API key>:
return SVGTransform();
case SVGTransform::<API key>:
{
transform.setRotate(first.angle() + second.angle(), first.rotationCenter().x() + second.rotationCenter().x(),
first.rotationCenter().y() + second.rotationCenter().y());
return transform;
}
case SVGTransform::<API key>:
transform.setMatrix(first.matrix() * second.matrix());
return transform;
case SVGTransform::<API key>:
{
float dx = first.translate().x() + second.translate().x();
float dy = first.translate().y() + second.translate().y();
transform.setTranslate(dx, dy);
return transform;
}
case SVGTransform::SVG_TRANSFORM_SCALE:
{
FloatSize scale = first.scale() + second.scale();
transform.setScale(scale.width(), scale.height());
return transform;
}
case SVGTransform::SVG_TRANSFORM_SKEWX:
transform.setSkewX(first.angle() + second.angle());
return transform;
case SVGTransform::SVG_TRANSFORM_SKEWY:
transform.setSkewY(first.angle() + second.angle());
return transform;
}
ASSERT_NOT_REACHED();
return SVGTransform();
}
void <API key>::addSVGTransform(const SVGTransform& transform, bool absoluteValue)
{
// If this is the first add, set the type for this <API key>
if (m_type == SVGTransform::<API key>)
m_type = transform.type();
ASSERT(m_type == transform.type());
switch (m_type) {
case SVGTransform::<API key>:
return;
case SVGTransform::<API key>:
m_transform *= transform.matrix(); // FIXME: what does 'distance' between two transforms mean? how should we respect 'absoluteValue' here?
return;
case SVGTransform::<API key>:
m_angle += absoluteValue ? fabsf(transform.angle()) : transform.angle();
m_cx += absoluteValue ? fabsf(transform.rotationCenter().x()) : transform.rotationCenter().x();
m_cy += absoluteValue ? fabsf(transform.rotationCenter().y()) : transform.rotationCenter().y();
// fall through
case SVGTransform::<API key>:
{
float dx = absoluteValue ? fabsf(transform.translate().x()) : transform.translate().x();
float dy = absoluteValue ? fabsf(transform.translate().y()) : transform.translate().y();
m_transform.translate(dx, dy);
return;
}
case SVGTransform::SVG_TRANSFORM_SCALE:
{
float scaleX = absoluteValue ? fabsf(transform.scale().width()) : transform.scale().width();
float scaleY = absoluteValue ? fabsf(transform.scale().height()) : transform.scale().height();
m_transform.scale(scaleX, scaleY);
return;
}
case SVGTransform::SVG_TRANSFORM_SKEWX:
case SVGTransform::SVG_TRANSFORM_SKEWY:
m_angle += absoluteValue ? fabsf(transform.angle()) : transform.angle();
return;
}
ASSERT_NOT_REACHED();
return;
}
SVGTransform <API key>::addToSVGTransform(const SVGTransform& transform) const
{
ASSERT(m_type == transform.type() || transform == SVGTransform());
SVGTransform newTransform(transform);
switch (m_type) {
case SVGTransform::<API key>:
return SVGTransform();
case SVGTransform::<API key>:
return SVGTransform(transform.matrix() * m_transform);
case SVGTransform::<API key>:
{
FloatPoint translation = transform.translate();
translation += FloatSize::narrowPrecision(m_transform.e(), m_transform.f());
newTransform.setTranslate(translation.x(), translation.y());
return newTransform;
}
case SVGTransform::SVG_TRANSFORM_SCALE:
{
FloatSize scale = transform.scale();
scale += FloatSize::narrowPrecision(m_transform.a(), m_transform.d());
newTransform.setScale(scale.width(), scale.height());
return newTransform;
}
case SVGTransform::<API key>:
{
// FIXME: I'm not certain the translation is calculated correctly here
FloatPoint center = transform.rotationCenter();
newTransform.setRotate(transform.angle() + m_angle,
center.x() + m_cx,
center.y() + m_cy);
return newTransform;
}
case SVGTransform::SVG_TRANSFORM_SKEWX:
newTransform.setSkewX(transform.angle() + m_angle);
return newTransform;
case SVGTransform::SVG_TRANSFORM_SKEWY:
newTransform.setSkewY(transform.angle() + m_angle);
return newTransform;
}
ASSERT_NOT_REACHED();
return SVGTransform();
}
bool <API key>::isZero() const
{
return (m_transform == AffineTransform() && m_angle == 0);
}
float <API key>::distance() const
{
switch (m_type) {
case SVGTransform::<API key>:
return 0.0f;
case SVGTransform::<API key>:
return sqrtf(m_angle * m_angle + m_cx * m_cx + m_cy * m_cy);
case SVGTransform::<API key>:
return 0.0f; // I'm not quite sure yet what distance between two matrices means.
case SVGTransform::SVG_TRANSFORM_SCALE:
return static_cast<float>(sqrt(m_transform.a() * m_transform.a() + m_transform.d() * m_transform.d()));
case SVGTransform::<API key>:
return static_cast<float>(sqrt(m_transform.e() * m_transform.e() + m_transform.f() * m_transform.f()));
case SVGTransform::SVG_TRANSFORM_SKEWX:
case SVGTransform::SVG_TRANSFORM_SKEWY:
return m_angle;
}
ASSERT_NOT_REACHED();
return 0.0f;
}
}
#endif |
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <linux/bio.h>
#include <linux/interrupt.h>
#include <linux/buffer_head.h>
#include <linux/kthread.h>
#include <asm/uaccess.h>
#include <linux/ploop/ploop.h>
struct delta_sysfs_entry {
struct attribute attr;
ssize_t (*show)(struct ploop_delta *, char *);
ssize_t (*store)(struct ploop_delta *, const char *, size_t);
};
static ssize_t
delta_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
{
struct delta_sysfs_entry *entry = container_of(attr, struct delta_sysfs_entry, attr);
struct ploop_delta *delta = container_of(kobj, struct ploop_delta, kobj);
if (!entry->show)
return -EIO;
return entry->show(delta, page);
}
static ssize_t
delta_attr_store(struct kobject *kobj, struct attribute *attr,
const char *page, size_t length)
{
struct delta_sysfs_entry *entry = container_of(attr, struct delta_sysfs_entry, attr);
struct ploop_delta *delta = container_of(kobj, struct ploop_delta, kobj);
if (!entry->store)
return -EIO;
return entry->store(delta, page, length);
}
static struct sysfs_ops delta_sysfs_ops = {
.show = delta_attr_show,
.store = delta_attr_store,
};
static void release_delta(struct kobject *kobj)
{
struct ploop_delta *delta = container_of(kobj, struct ploop_delta, kobj);
if (delta->ops)
ploop_format_put(delta->ops);
module_put(THIS_MODULE);
kfree(delta);
}
static ssize_t
delta_var_show(unsigned int var, char *page)
{
return sprintf(page, "%d\n", var);
}
static ssize_t
delta_string_show(char * str, char *page)
{
return sprintf(page, "%s\n", str);
}
static ssize_t delta_level_show(struct ploop_delta *delta, char *page)
{
return delta_var_show(delta->level, page);
}
static ssize_t delta_image_show(struct ploop_delta *delta, char *page)
{
char * res;
int len = -ENOENT;
mutex_lock(&delta->plo->sysfs_mutex);
if (delta->io.files.file) {
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
res = d_path(delta->io.files.file->f_dentry,
delta->io.files.file->f_vfsmnt,
page, PAGE_SIZE-1);
#else
res = d_path(&delta->io.files.file->f_path, page, PAGE_SIZE-1);
#endif
len = PTR_ERR(res);
if (!IS_ERR(res)) {
len = strlen(res);
if (res != page)
memmove(page, res, len);
page[len] = '\n';
len++;
}
}
mutex_unlock(&delta->plo->sysfs_mutex);
return len;
}
static ssize_t delta_format_show(struct ploop_delta *delta, char *page)
{
return delta_string_show(delta->ops->name, page);
}
static ssize_t delta_io_show(struct ploop_delta *delta, char *page)
{
return delta_string_show(delta->io.ops->name, page);
}
static ssize_t delta_ro_show(struct ploop_delta *delta, char *page)
{
return sprintf(page, "%d\n", !!(delta->flags & PLOOP_FMT_RDONLY));
}
static ssize_t delta_trans_show(struct ploop_delta *delta, char *page)
{
struct ploop_device * plo = delta->plo;
int trans = 0;
mutex_lock(&delta->plo->sysfs_mutex);
if (plo->trans_map && map_top_delta(plo->trans_map) == delta)
trans = 1;
mutex_unlock(&delta->plo->sysfs_mutex);
return sprintf(page, "%d\n", trans);
}
static ssize_t delta_dump(struct ploop_delta *delta, char *page)
{
int ret = delta->io.ops->dump ? delta->io.ops->dump(&delta->io) : -1;
return sprintf(page, "%d\n", ret);
}
static struct delta_sysfs_entry delta_level_entry = {
.attr = {.name = "level", .mode = S_IRUGO },
.show = delta_level_show,
.store = NULL,
};
static struct delta_sysfs_entry delta_image_entry = {
.attr = {.name = "image", .mode = S_IRUGO },
.show = delta_image_show,
.store = NULL,
};
static struct delta_sysfs_entry delta_format_entry = {
.attr = {.name = "format", .mode = S_IRUGO },
.show = delta_format_show,
.store = NULL,
};
static struct delta_sysfs_entry delta_io_entry = {
.attr = {.name = "io", .mode = S_IRUGO },
.show = delta_io_show,
.store = NULL,
};
static struct delta_sysfs_entry delta_ro_entry = {
.attr = {.name = "ro", .mode = S_IRUGO },
.show = delta_ro_show,
.store = NULL,
};
static struct delta_sysfs_entry delta_trans_entry = {
.attr = {.name = "transparent", .mode = S_IRUGO },
.show = delta_trans_show,
.store = NULL,
};
static struct delta_sysfs_entry delta_dump_entry = {
.attr = {.name = "dump", .mode = S_IRUGO },
.show = delta_dump,
};
static struct attribute *default_attrs[] = {
&delta_level_entry.attr,
&delta_image_entry.attr,
&delta_format_entry.attr,
&delta_io_entry.attr,
&delta_ro_entry.attr,
&delta_trans_entry.attr,
&delta_dump_entry.attr,
NULL,
};
struct kobj_type ploop_delta_ktype = {
.sysfs_ops = &delta_sysfs_ops,
.default_attrs = default_attrs,
.release = release_delta,
};
static struct {
#define __DO(_at) struct attribute _at;
#include <linux/ploop/ploop_stat.h>
#undef __DO
} _attr_arr = {
#define __DO(_at) ._at = { .name = __stringify(_at), .mode = S_IRUGO|S_IWUSR, },
#include <linux/ploop/ploop_stat.h>
#undef __DO
};
static struct attribute *stats_attributes[] = {
#define __DO(_at) &_attr_arr._at,
#include <linux/ploop/ploop_stat.h>
#undef __DO
NULL
};
static const struct attribute_group stats_group = {
.attrs = stats_attributes,
};
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
#define to_disk(obj) dev_to_disk(container_of(obj,struct device,kobj))
#else
#define to_disk(obj) container_of(obj,struct gendisk,kobj)
#endif
static ssize_t pstat_show(struct kobject *kobj, struct attribute *attr,
char *page)
{
struct gendisk *disk = to_disk(kobj->parent);
struct ploop_device * plo = disk->private_data;
int n;
n = attr - (struct attribute *)&_attr_arr;
return sprintf(page, "%u\n", ((u32*)&plo->st)[n]);
}
static ssize_t pstat_store(struct kobject * kobj, struct attribute * attr,
const char *page, size_t count)
{
struct gendisk *disk = to_disk(kobj->parent);
struct ploop_device * plo = disk->private_data;
char *p = (char *) page;
unsigned long var;
int n;
var = simple_strtoul(p, &p, 10);
n = attr - (struct attribute *)&_attr_arr;
((u32*)&plo->st)[n] = var;
return count;
}
static u32 show_block_size(struct ploop_device * plo)
{
return 1 << plo->cluster_log;
}
static u32 show_fmt_version(struct ploop_device * plo)
{
return plo->fmt_version;
}
static u32 show_total_bios(struct ploop_device * plo)
{
return plo->bio_total;
}
static u32 show_queued_bios(struct ploop_device * plo)
{
return plo->bio_qlen;
}
static u32 show_discard_bios(struct ploop_device * plo)
{
return plo->bio_discard_qlen;
}
static u32 show_active_reqs(struct ploop_device * plo)
{
return plo->active_reqs;
}
static u32 <API key>(struct ploop_device * plo)
{
return plo->read_sync_reqs;
}
static u32 show_entry_reqs(struct ploop_device * plo)
{
return plo->entry_qlen;
}
static u32 show_barrier_reqs(struct ploop_device * plo)
{
return plo->barrier_reqs;
}
static u32 show_fsync_reqs(struct ploop_device * plo)
{
u32 qlen = 0;
mutex_lock(&plo->sysfs_mutex);
if (!list_empty(&plo->map.delta_list))
qlen = ploop_top_delta(plo)->io.fsync_qlen;
mutex_unlock(&plo->sysfs_mutex);
return qlen;
}
static u32 show_fastpath_reqs(struct ploop_device * plo)
{
return plo->fastpath_reqs;
}
static u32 show_map_pages(struct ploop_device * plo)
{
return plo->map.pages;
}
static u32 show_running(struct ploop_device * plo)
{
return test_bit(PLOOP_S_RUNNING, &plo->state);
}
static u32 show_locked(struct ploop_device * plo)
{
return test_bit(PLOOP_S_LOCKED, &plo->locking_state);
}
static u32 show_aborted(struct ploop_device * plo)
{
return test_bit(PLOOP_S_ABORT, &plo->state);
}
static int store_aborted(struct ploop_device * plo, u32 val)
{
printk(KERN_INFO "ploop: Force %s aborted state for ploop%d\n",
val ? "set" : "clear", plo->index);
if (val)
set_bit(PLOOP_S_ABORT, &plo->state);
else
clear_bit(PLOOP_S_ABORT, &plo->state);
return 0;
}
static u32 show_top(struct ploop_device * plo)
{
int top = -1;
mutex_lock(&plo->sysfs_mutex);
if (!list_empty(&plo->map.delta_list))
top = ploop_top_delta(plo)->level;
if (plo->trans_map)
top++;
mutex_unlock(&plo->sysfs_mutex);
return (u32)top;
}
static inline u32 get_event_locked(struct ploop_device * plo)
{
if (test_and_clear_bit(<API key>, &plo->state))
return PLOOP_EVENT_ENOSPC;
else if (test_bit(PLOOP_S_ABORT, &plo->state))
return PLOOP_EVENT_ABORTED;
else if (!test_bit(PLOOP_S_RUNNING, &plo->state))
return PLOOP_EVENT_STOPPED;
return 0;
}
static u32 show_event(struct ploop_device * plo)
{
u32 ret;
DEFINE_WAIT(_wait);
spin_lock_irq(&plo->lock);
ret = get_event_locked(plo);
if (ret) {
spin_unlock_irq(&plo->lock);
return ret;
}
prepare_to_wait(&plo->event_waitq, &_wait, TASK_INTERRUPTIBLE);
spin_unlock_irq(&plo->lock);
schedule();
spin_lock_irq(&plo->lock);
finish_wait(&plo->event_waitq, &_wait);
ret = get_event_locked(plo);
spin_unlock_irq(&plo->lock);
return ret;
}
static u32 show_open_count(struct ploop_device * plo)
{
return atomic_read(&plo->open_count);
}
static ssize_t print_cookie(struct ploop_device * plo, char * page)
{
return sprintf(page, "%s\n", plo->cookie);
}
#define _TUNE_U32(_name) \
static u32 show_##_name(struct ploop_device * plo) \
{ \
return plo->tune._name; \
} \
\
static int store_##_name(struct ploop_device * plo, u32 val) \
{ \
plo->tune._name = val; \
return 0; \
}
#define _TUNE_JIFFIES(_name) \
static u32 show_##_name(struct ploop_device * plo) \
{ \
return (plo->tune._name * 1000) / HZ; \
} \
\
static int store_##_name(struct ploop_device * plo, u32 val) \
{ \
plo->tune._name = (val * HZ) / 1000; \
return 0; \
}
#define _TUNE_BOOL _TUNE_U32
_TUNE_U32(max_requests);
_TUNE_U32(batch_entry_qlen);
_TUNE_JIFFIES(batch_entry_delay);
_TUNE_U32(fsync_max);
_TUNE_JIFFIES(fsync_delay);
_TUNE_BOOL(pass_flushes);
_TUNE_BOOL(pass_fuas);
_TUNE_BOOL(<API key>);
_TUNE_BOOL(check_zeros);
_TUNE_U32(min_map_pages);
_TUNE_JIFFIES(max_map_inactivity);
_TUNE_BOOL(<API key>);
_TUNE_BOOL(<API key>);
_TUNE_U32(<API key>);
_TUNE_U32(<API key>);
_TUNE_U32(max_active_requests);
struct pattr_sysfs_entry {
struct attribute attr;
u32 (*show)(struct ploop_device *);
int (*store)(struct ploop_device *, __u32 val);
ssize_t (*print)(struct ploop_device *, char *page);
};
#define _A(_name) \
&((struct pattr_sysfs_entry){ .attr = { .name = __stringify(_name), .mode = S_IRUGO }, .show = show_##_name, }).attr
#define _A2(_name) \
&((struct pattr_sysfs_entry){ .attr = { .name = __stringify(_name), .mode = S_IRUGO|S_IWUSR }, .show = show_##_name, .store = store_##_name, }).attr
#define _A3(_name) \
&((struct pattr_sysfs_entry){ .attr = { .name = __stringify(_name), .mode = S_IRUGO }, .print = print_##_name, }).attr
static struct attribute *state_attributes[] = {
_A(block_size),
_A(fmt_version),
_A(total_bios),
_A(queued_bios),
_A(discard_bios),
_A(active_reqs),
_A(entry_reqs),
_A(<API key>),
_A(barrier_reqs),
_A(fastpath_reqs),
_A(fsync_reqs),
_A(map_pages),
_A(running),
_A(locked),
_A2(aborted),
_A(top),
_A(event),
_A3(cookie),
_A(open_count),
NULL
};
static struct attribute *tune_attributes[] = {
_A2(max_requests),
_A2(batch_entry_qlen),
_A2(batch_entry_delay),
_A2(fsync_max),
_A2(fsync_delay),
_A2(min_map_pages),
_A2(max_map_inactivity),
_A2(pass_flushes),
_A2(pass_fuas),
_A2(<API key>),
_A2(check_zeros),
_A2(<API key>),
_A2(<API key>),
_A2(<API key>),
_A2(<API key>),
_A2(max_active_requests),
NULL
};
static const struct attribute_group state_group = {
.attrs = state_attributes,
};
static const struct attribute_group tune_group = {
.attrs = tune_attributes,
};
static ssize_t
pattr_show(struct kobject *kobj, struct attribute *attr, char *page)
{
struct pattr_sysfs_entry *entry = container_of(attr, struct pattr_sysfs_entry, attr);
struct gendisk *disk = to_disk(kobj->parent);
struct ploop_device * plo = disk->private_data;
u32 val;
if (entry->print)
return entry->print(plo, page);
if (!entry->show)
return -EIO;
val = entry->show(plo);
return sprintf(page, "%u\n", val);
}
static ssize_t
pattr_store(struct kobject *kobj, struct attribute *attr,
const char *page, size_t length)
{
struct pattr_sysfs_entry *entry = container_of(attr, struct pattr_sysfs_entry, attr);
struct gendisk *disk = to_disk(kobj->parent);
struct ploop_device * plo = disk->private_data;
char *p = (char *) page;
unsigned long var;
int err;
if (!entry->store)
return -EIO;
var = simple_strtoul(p, &p, 10);
err = entry->store(plo, var);
return err ? : length;
}
static struct sysfs_ops pattr_sysfs_ops = {
.show = &pattr_show,
.store = &pattr_store,
};
static struct sysfs_ops pstat_sysfs_ops = {
.show = &pstat_show,
.store = &pstat_store,
};
static void pattr_release(struct kobject *kobj)
{
kfree(kobj);
}
static struct kobj_type pattr_ktype = {
.release = pattr_release,
.sysfs_ops = &pattr_sysfs_ops,
};
static struct kobj_type pstat_ktype = {
.release = pattr_release,
.sysfs_ops = &pstat_sysfs_ops,
};
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
struct kobject *kobject_add_attr(struct gendisk *gd, const char *name,
struct kobj_type * type)
{
struct kobject *k;
int err;
struct kobject * parent = &disk_to_dev(gd)->kobj;
k = kzalloc(sizeof(*k), GFP_KERNEL);
if (!k)
return NULL;
kobject_init(k, type);
err = kobject_add(k, parent, "%s", name);
if (err) {
kobject_put(k);
return NULL;
}
return k;
}
#else
struct kobject *kobject_add_attr(struct gendisk *gd, const char *name,
struct kobj_type * type)
{
struct kobject *k;
int err;
struct kobject * parent = &gd->kobj;
k = kzalloc(sizeof(*k), GFP_KERNEL);
if (!k)
return NULL;
snprintf(k->name, KOBJ_NAME_LEN, "%s", name);
k->ktype = type;
kobject_init(k);
k->parent = parent;
err = kobject_add(k);
if (err) {
kobject_put(k);
return NULL;
}
return k;
}
#endif
void ploop_sysfs_init(struct ploop_device * plo)
{
plo->pstat_dir = kobject_add_attr(plo->disk, "pstat", &pstat_ktype);
if (plo->pstat_dir) {
if (sysfs_create_group(plo->pstat_dir, &stats_group))
printk("ploop: were not able to create pstat dir\n");
}
plo->pstate_dir = kobject_add_attr(plo->disk, "pstate", &pattr_ktype);
if (plo->pstate_dir) {
if (sysfs_create_group(plo->pstate_dir, &state_group))
printk("ploop: were not able to create pstate dir\n");
}
plo->ptune_dir = kobject_add_attr(plo->disk, "ptune", &pattr_ktype);
if (plo->ptune_dir) {
if (sysfs_create_group(plo->ptune_dir, &tune_group))
printk("ploop: were not able to create ptune dir\n");
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
if (kobject_add(&plo->kobj, kobject_get(&disk_to_dev(plo->disk)->kobj), "%s", "pdelta"))
printk("ploop: were not able to create pdelta dir\n");
#else
plo->kobj.parent = kobject_get(&plo->disk->kobj);
if (kobject_add(&plo->kobj))
printk("ploop: were not able to create pdelta dir\n");
#endif
}
void ploop_sysfs_uninit(struct ploop_device * plo)
{
if (plo->pstat_dir) {
sysfs_remove_group(plo->pstat_dir, &stats_group);
kobject_del(plo->pstat_dir);
kobject_put(plo->pstat_dir);
plo->pstat_dir = NULL;
}
if (plo->pstate_dir) {
sysfs_remove_group(plo->pstate_dir, &state_group);
kobject_del(plo->pstate_dir);
kobject_put(plo->pstate_dir);
plo->pstate_dir = NULL;
}
if (plo->ptune_dir) {
sysfs_remove_group(plo->ptune_dir, &tune_group);
kobject_del(plo->ptune_dir);
kobject_put(plo->ptune_dir);
plo->ptune_dir = NULL;
}
kobject_del(&plo->kobj);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
kobject_put(&disk_to_dev(plo->disk)->kobj);
#else
kobject_put(&plo->disk->kobj);
#endif
} |
<?php
defined('_JEXEC') or die;
/**
* Registration view class for Users.
*
* @since 1.6
*/
class <API key> extends JViewLegacy
{
protected $data;
protected $form;
protected $params;
protected $state;
public $document;
/**
* Method to display the view.
*
* @param string $tpl The template file to include
*
* @return mixed
*
* @since 1.6
*/
public function display($tpl = null)
{
// Get the view data.
$this->form = $this->get('Form');
$this->data = $this->get('Data');
$this->state = $this->get('State');
$this->params = $this->state->get('params');
// Check for errors.
if (count($errors = $this->get('Errors')))
{
JError::raiseError(500, implode('<br />', $errors));
return false;
}
// Check for layout override
$active = JFactory::getApplication()->getMenu()->getActive();
if (isset($active->query['layout']))
{
$this->setLayout($active->query['layout']);
}
// Escape strings for HTML output
$this->pageclass_sfx = htmlspecialchars($this->params->get('pageclass_sfx', ''), ENT_COMPAT, 'UTF-8');
$this->prepareDocument();
return parent::display($tpl);
}
/**
* Prepares the document.
*
* @return void
*
* @since 1.6
*/
protected function prepareDocument()
{
$app = JFactory::getApplication();
$menus = $app->getMenu();
$title = null;
// Because the application sets a default page title,
// we need to get it from the menu item itself
$menu = $menus->getActive();
if ($menu)
{
$this->params->def('page_heading', $this->params->get('page_title', $menu->title));
}
else
{
$this->params->def('page_heading', JText::_('<API key>'));
}
$title = $this->params->get('page_title', '');
if (empty($title))
{
$title = $app->get('sitename');
}
elseif ($app->get('sitename_pagetitles', 0) == 1)
{
$title = JText::sprintf('JPAGETITLE', $app->get('sitename'), $title);
}
elseif ($app->get('sitename_pagetitles', 0) == 2)
{
$title = JText::sprintf('JPAGETITLE', $title, $app->get('sitename'));
}
$this->document->setTitle($title);
if ($this->params->get('<API key>'))
{
$this->document->setDescription($this->params->get('<API key>'));
}
if ($this->params->get('menu-meta_keywords'))
{
$this->document->setMetadata('keywords', $this->params->get('menu-meta_keywords'));
}
if ($this->params->get('robots'))
{
$this->document->setMetadata('robots', $this->params->get('robots'));
}
}
} |
#ifndef _DISPLAY_DRV_H_
#define _DISPLAY_DRV_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "dsi_timing.h"
typedef void *DISPDRV_HANDLE_T;
typedef enum {
CTRL_MIN,
CTRL_PWR_OFF, /* PWR Off : in reset */
CTRL_PWR_ON, ///< PWR On : not in reset, init, screen off
CTRL_SLEEP_IN, ///< Sleep-in : Screen Off, low power mode
CTRL_SLEEP_OUT, ///< Sleep-out: full power, screen Off
CTRL_SCREEN_ON, /* Sleep-out: full power, screen On */
CTRL_SCREEN_OFF, ///< Sleep-out: full power, screen Off
CTRL_MAX,
} <API key>;
typedef enum {
<API key>, ///< Min Number
<API key>, ///< RG5565 2Bpp
<API key>, /* xRGB8888 4Bpp */
<API key>, /* xBGR8888 4Bpp */
<API key>, ///< MAX Number
} DISPDRV_FB_FORMAT_T;
typedef enum {
DISPDRV_CB_RES_MIN, ///< Min Number
DISPDRV_CB_RES_OK, ///< No Errors
DISPDRV_CB_RES_ERR, ///< Error During Update
DISPDRV_CB_RES_MAX, ///< Max Number
} DISPDRV_CB_RES_T;
typedef struct {
u32 l;
u32 t;
u32 r;
u32 b;
u32 w;
u32 h;
u32 mode; /*0=android use case, !=0 win has 0 offset in fb */
} DISPDRV_WIN_t;
#define dispdrv2cmIn(p) p == KONA_CM_I_RGB565 ? LCD_IF_CM_I_RGB565P : \
p == KONA_CM_I_XRGB888 ? LCD_IF_CM_I_RGB888U : \
LCD_IF_CM_I_INV
#define dispdrv2cmOut(p) p ==KONA_CM_O_RGB565 ? LCD_IF_CM_O_RGB565 : \
p ==<API key> ? <API key>:\
p ==KONA_CM_O_RGB666 ? LCD_IF_CM_O_RGB666 : \
p ==KONA_CM_O_RGB888 ? LCD_IF_CM_O_RGB888 : \
LCD_IF_CM_O_INV
typedef struct {
char *name;
char *reg_name;
struct hw_rst_info *rst;
bool vmode;
bool vburst;
bool vid_cmnds;
bool cmnd_LP;
bool te_ctrl;
uint16_t width;
uint16_t height;
uint8_t lanes;
uint8_t phys_width;
uint8_t phys_height;
uint8_t fps;
DISPDRV_FB_FORMAT_T in_fmt;
DISPDRV_FB_FORMAT_T out_fmt;
uint8_t Bpp;
char *init_seq;
char *slp_in_seq;
char *slp_out_seq;
char *scrn_on_seq;
char *scrn_off_seq;
char *id_seq;
char *win_seq;
void (*updt_win_fn)(char *buff, DISPDRV_WIN_t *p_win);
uint8_t updt_win_seq_len;
struct DSI_COUNTER phy_timing[18];
uint8_t hs, hbp, hfp;
uint8_t vs, vbp, vfp;
uint32_t hs_bps;
uint32_t lp_bps;
int desense_offset;
void (*vsync_cb)(void);
bool cont_clk;
} DISPDRV_INFO_T;
typedef void (*DISPDRV_CB_T) (DISPDRV_CB_RES_T res);
typedef struct {
Int32(*init) (DISPDRV_INFO_T *display_info,
DISPDRV_HANDLE_T *handle);
Int32(*exit) (DISPDRV_HANDLE_T handle);
Int32(*open) (DISPDRV_HANDLE_T handle);
Int32(*close) (DISPDRV_HANDLE_T handle);
Int32(*start) (DISPDRV_HANDLE_T handle,
struct pi_mgr_dfs_node *dfs_node);
Int32(*stop) (DISPDRV_HANDLE_T handle,
struct pi_mgr_dfs_node *dfs_node);
Int32(*power_control) (DISPDRV_HANDLE_T handle,
<API key> powerState);
Int32(*update_no_os) (DISPDRV_HANDLE_T handle, void *buff,
DISPDRV_WIN_t *p_win);
Int32(*update) (DISPDRV_HANDLE_T handle, void *buff,
DISPDRV_WIN_t *p_win, DISPDRV_CB_T apiCb);
Int32(*reset_win) (DISPDRV_HANDLE_T handle);
} DISPDRV_T;
#ifdef __cplusplus
}
#endif
#endif //_DISPLAY_DRV_H_ |
#include <linux/kernel.h>
#include <linux/rwsem.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/bitops.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/user.h>
#include <linux/signal.h>
#include <linux/syscalls.h>
#include <linux/audit.h>
#include <linux/seccomp.h>
#include <linux/tracehook.h>
#include <linux/elf.h>
#include <linux/regset.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/pgtable.h>
#include <asm/system.h>
#include <asm/processor.h>
#include <asm/mmu_context.h>
#include <asm/syscalls.h>
#include <asm/fpu.h>
#define CREATE_TRACE_POINTS
#include <trace/events/syscalls.h>
/* This mask defines the bits of the SR which the user is not allowed to
change, which are everything except S, Q, M, PR, SZ, FR. */
#define SR_MASK (0xffff8cfd)
/*
* does not yet catch signals sent when the child dies.
* in exit.c or in signal.c.
*/
/*
* This routine will get a word from the user area in the process kernel stack.
*/
static inline int get_stack_long(struct task_struct *task, int offset)
{
unsigned char *stack;
stack = (unsigned char *)(task->thread.uregs);
stack += offset;
return (*((int *)stack));
}
static inline unsigned long
get_fpu_long(struct task_struct *task, unsigned long addr)
{
unsigned long tmp;
struct pt_regs *regs;
regs = (struct pt_regs*)((unsigned char *)task + THREAD_SIZE) - 1;
if (!tsk_used_math(task)) {
if (addr == offsetof(struct user_fpu_struct, fpscr)) {
tmp = FPSCR_INIT;
} else {
tmp = 0xffffffffUL; /* matches initial value in fpu.c */
}
return tmp;
}
if (last_task_used_math == task) {
enable_fpu();
save_fpu(task);
disable_fpu();
last_task_used_math = 0;
regs->sr |= SR_FD;
}
tmp = ((long *)task->thread.xstate)[addr / sizeof(unsigned long)];
return tmp;
}
/*
* This routine will put a word into the user area in the process kernel stack.
*/
static inline int put_stack_long(struct task_struct *task, int offset,
unsigned long data)
{
unsigned char *stack;
stack = (unsigned char *)(task->thread.uregs);
stack += offset;
*(unsigned long *) stack = data;
return 0;
}
static inline int
put_fpu_long(struct task_struct *task, unsigned long addr, unsigned long data)
{
struct pt_regs *regs;
regs = (struct pt_regs*)((unsigned char *)task + THREAD_SIZE) - 1;
if (!tsk_used_math(task)) {
init_fpu(task);
} else if (last_task_used_math == task) {
enable_fpu();
save_fpu(task);
disable_fpu();
last_task_used_math = 0;
regs->sr |= SR_FD;
}
((long *)task->thread.xstate)[addr / sizeof(unsigned long)] = data;
return 0;
}
void <API key>(struct task_struct *child)
{
struct pt_regs *regs = child->thread.uregs;
regs->sr |= SR_SSTEP; /* auto-resetting upon exception */
set_tsk_thread_flag(child, TIF_SINGLESTEP);
}
void <API key>(struct task_struct *child)
{
struct pt_regs *regs = child->thread.uregs;
regs->sr &= ~SR_SSTEP;
<API key>(child, TIF_SINGLESTEP);
}
static int genregs_get(struct task_struct *target,
const struct user_regset *regset,
unsigned int pos, unsigned int count,
void *kbuf, void __user *ubuf)
{
const struct pt_regs *regs = task_pt_regs(target);
int ret;
/* PC, SR, SYSCALL */
ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
®s->pc,
0, 3 * sizeof(unsigned long long));
/* R1 -> R63 */
if (!ret)
ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
regs->regs,
offsetof(struct pt_regs, regs[0]),
63 * sizeof(unsigned long long));
/* TR0 -> TR7 */
if (!ret)
ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
regs->tregs,
offsetof(struct pt_regs, tregs[0]),
8 * sizeof(unsigned long long));
if (!ret)
ret = <API key>(&pos, &count, &kbuf, &ubuf,
sizeof(struct pt_regs), -1);
return ret;
}
static int genregs_set(struct task_struct *target,
const struct user_regset *regset,
unsigned int pos, unsigned int count,
const void *kbuf, const void __user *ubuf)
{
struct pt_regs *regs = task_pt_regs(target);
int ret;
/* PC, SR, SYSCALL */
ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
®s->pc,
0, 3 * sizeof(unsigned long long));
/* R1 -> R63 */
if (!ret && count > 0)
ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
regs->regs,
offsetof(struct pt_regs, regs[0]),
63 * sizeof(unsigned long long));
/* TR0 -> TR7 */
if (!ret && count > 0)
ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
regs->tregs,
offsetof(struct pt_regs, tregs[0]),
8 * sizeof(unsigned long long));
if (!ret)
ret = <API key>(&pos, &count, &kbuf, &ubuf,
sizeof(struct pt_regs), -1);
return ret;
}
#ifdef CONFIG_SH_FPU
int fpregs_get(struct task_struct *target,
const struct user_regset *regset,
unsigned int pos, unsigned int count,
void *kbuf, void __user *ubuf)
{
int ret;
ret = init_fpu(target);
if (ret)
return ret;
return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
&target->thread.xstate->hardfpu, 0, -1);
}
static int fpregs_set(struct task_struct *target,
const struct user_regset *regset,
unsigned int pos, unsigned int count,
const void *kbuf, const void __user *ubuf)
{
int ret;
ret = init_fpu(target);
if (ret)
return ret;
<API key>(target);
return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
&target->thread.xstate->hardfpu, 0, -1);
}
static int fpregs_active(struct task_struct *target,
const struct user_regset *regset)
{
return tsk_used_math(target) ? regset->n : 0;
}
#endif
const struct pt_regs_offset regoffset_table[] = {
REG_OFFSET_NAME(pc),
REG_OFFSET_NAME(sr),
REG_OFFSET_NAME(syscall_nr),
REGS_OFFSET_NAME(0),
REGS_OFFSET_NAME(1),
REGS_OFFSET_NAME(2),
REGS_OFFSET_NAME(3),
REGS_OFFSET_NAME(4),
REGS_OFFSET_NAME(5),
REGS_OFFSET_NAME(6),
REGS_OFFSET_NAME(7),
REGS_OFFSET_NAME(8),
REGS_OFFSET_NAME(9),
REGS_OFFSET_NAME(10),
REGS_OFFSET_NAME(11),
REGS_OFFSET_NAME(12),
REGS_OFFSET_NAME(13),
REGS_OFFSET_NAME(14),
REGS_OFFSET_NAME(15),
REGS_OFFSET_NAME(16),
REGS_OFFSET_NAME(17),
REGS_OFFSET_NAME(18),
REGS_OFFSET_NAME(19),
REGS_OFFSET_NAME(20),
REGS_OFFSET_NAME(21),
REGS_OFFSET_NAME(22),
REGS_OFFSET_NAME(23),
REGS_OFFSET_NAME(24),
REGS_OFFSET_NAME(25),
REGS_OFFSET_NAME(26),
REGS_OFFSET_NAME(27),
REGS_OFFSET_NAME(28),
REGS_OFFSET_NAME(29),
REGS_OFFSET_NAME(30),
REGS_OFFSET_NAME(31),
REGS_OFFSET_NAME(32),
REGS_OFFSET_NAME(33),
REGS_OFFSET_NAME(34),
REGS_OFFSET_NAME(35),
REGS_OFFSET_NAME(36),
REGS_OFFSET_NAME(37),
REGS_OFFSET_NAME(38),
REGS_OFFSET_NAME(39),
REGS_OFFSET_NAME(40),
REGS_OFFSET_NAME(41),
REGS_OFFSET_NAME(42),
REGS_OFFSET_NAME(43),
REGS_OFFSET_NAME(44),
REGS_OFFSET_NAME(45),
REGS_OFFSET_NAME(46),
REGS_OFFSET_NAME(47),
REGS_OFFSET_NAME(48),
REGS_OFFSET_NAME(49),
REGS_OFFSET_NAME(50),
REGS_OFFSET_NAME(51),
REGS_OFFSET_NAME(52),
REGS_OFFSET_NAME(53),
REGS_OFFSET_NAME(54),
REGS_OFFSET_NAME(55),
REGS_OFFSET_NAME(56),
REGS_OFFSET_NAME(57),
REGS_OFFSET_NAME(58),
REGS_OFFSET_NAME(59),
REGS_OFFSET_NAME(60),
REGS_OFFSET_NAME(61),
REGS_OFFSET_NAME(62),
REGS_OFFSET_NAME(63),
TREGS_OFFSET_NAME(0),
TREGS_OFFSET_NAME(1),
TREGS_OFFSET_NAME(2),
TREGS_OFFSET_NAME(3),
TREGS_OFFSET_NAME(4),
TREGS_OFFSET_NAME(5),
TREGS_OFFSET_NAME(6),
TREGS_OFFSET_NAME(7),
REG_OFFSET_END,
};
/*
* These are our native regset flavours.
*/
enum sh_regset {
REGSET_GENERAL,
#ifdef CONFIG_SH_FPU
REGSET_FPU,
#endif
};
static const struct user_regset sh_regsets[] = {
/*
* Format is:
* PC, SR, SYSCALL,
* R1 --> R63,
* TR0 --> TR7,
*/
[REGSET_GENERAL] = {
.core_note_type = NT_PRSTATUS,
.n = ELF_NGREG,
.size = sizeof(long long),
.align = sizeof(long long),
.get = genregs_get,
.set = genregs_set,
},
#ifdef CONFIG_SH_FPU
[REGSET_FPU] = {
.core_note_type = NT_PRFPREG,
.n = sizeof(struct user_fpu_struct) /
sizeof(long long),
.size = sizeof(long long),
.align = sizeof(long long),
.get = fpregs_get,
.set = fpregs_set,
.active = fpregs_active,
},
#endif
};
static const struct user_regset_view <API key> = {
.name = "sh64",
.e_machine = EM_SH,
.regsets = sh_regsets,
.n = ARRAY_SIZE(sh_regsets),
};
const struct user_regset_view *<API key>(struct task_struct *task)
{
return &<API key>;
}
long arch_ptrace(struct task_struct *child, long request,
unsigned long addr, unsigned long data)
{
int ret;
unsigned long __user *datap = (unsigned long __user *) data;
switch (request) {
/* read the word at location addr in the USER area. */
case PTRACE_PEEKUSR: {
unsigned long tmp;
ret = -EIO;
if ((addr & 3) || addr < 0)
break;
if (addr < sizeof(struct pt_regs))
tmp = get_stack_long(child, addr);
else if ((addr >= offsetof(struct user, fpu)) &&
(addr < offsetof(struct user, u_fpvalid))) {
unsigned long index;
ret = init_fpu(child);
if (ret)
break;
index = addr - offsetof(struct user, fpu);
tmp = get_fpu_long(child, index);
} else if (addr == offsetof(struct user, u_fpvalid)) {
tmp = !!tsk_used_math(child);
} else {
break;
}
ret = put_user(tmp, datap);
break;
}
case PTRACE_POKEUSR:
/* write the word at location addr in the USER area. We must
disallow any changes to certain SR bits or u_fpvalid, since
this could crash the kernel or result in a security
loophole. */
ret = -EIO;
if ((addr & 3) || addr < 0)
break;
if (addr < sizeof(struct pt_regs)) {
/* Ignore change of top 32 bits of SR */
if (addr == offsetof (struct pt_regs, sr)+4)
{
ret = 0;
break;
}
/* If lower 32 bits of SR, ignore non-user bits */
if (addr == offsetof (struct pt_regs, sr))
{
long cursr = get_stack_long(child, addr);
data &= ~(SR_MASK);
data |= (cursr & SR_MASK);
}
ret = put_stack_long(child, addr, data);
}
else if ((addr >= offsetof(struct user, fpu)) &&
(addr < offsetof(struct user, u_fpvalid))) {
unsigned long index;
ret = init_fpu(child);
if (ret)
break;
index = addr - offsetof(struct user, fpu);
ret = put_fpu_long(child, index, data);
}
break;
case PTRACE_GETREGS:
return copy_regset_to_user(child, &<API key>,
REGSET_GENERAL,
0, sizeof(struct pt_regs),
datap);
case PTRACE_SETREGS:
return <API key>(child, &<API key>,
REGSET_GENERAL,
0, sizeof(struct pt_regs),
datap);
#ifdef CONFIG_SH_FPU
case PTRACE_GETFPREGS:
return copy_regset_to_user(child, &<API key>,
REGSET_FPU,
0, sizeof(struct user_fpu_struct),
datap);
case PTRACE_SETFPREGS:
return <API key>(child, &<API key>,
REGSET_FPU,
0, sizeof(struct user_fpu_struct),
datap);
#endif
default:
ret = ptrace_request(child, request, addr, data);
break;
}
return ret;
}
asmlinkage int sh64_ptrace(long request, long pid,
unsigned long addr, unsigned long data)
{
#define WPC_DBRMODE 0x0d104008
static unsigned long first_call;
if (!test_and_set_bit(0, &first_call)) {
/* Set WPC.DBRMODE to 0. This makes all debug events get
* delivered through RESVEC, i.e. into the handlers in entry.S.
* (If the kernel was downloaded using a remote gdb, WPC.DBRMODE
* would normally be left set to 1, which makes debug events get
* delivered through DBRVEC, i.e. into the remote gdb's
* handlers. This prevents ptrace getting them, and confuses
* the remote gdb.) */
printk("DBRMODE set to 0 to permit native debugging\n");
poke_real_address_q(WPC_DBRMODE, 0);
}
return sys_ptrace(request, pid, addr, data);
}
static inline int audit_arch(void)
{
int arch = EM_SH;
#ifdef CONFIG_64BIT
arch |= __AUDIT_ARCH_64BIT;
#endif
#ifdef <API key>
arch |= __AUDIT_ARCH_LE;
#endif
return arch;
}
asmlinkage long long <API key>(struct pt_regs *regs)
{
long long ret = 0;
<API key>(regs->regs[9]);
if (test_thread_flag(TIF_SYSCALL_TRACE) &&
<API key>(regs))
/*
* Tracing decided this syscall should not happen.
* We'll return a bogus call number to get an ENOSYS
* error, but leave the original number in regs->regs[0].
*/
ret = -1LL;
if (unlikely(test_thread_flag(<API key>)))
trace_sys_enter(regs, regs->regs[9]);
if (unlikely(current->audit_context))
audit_syscall_entry(audit_arch(), regs->regs[1],
regs->regs[2], regs->regs[3],
regs->regs[4], regs->regs[5]);
return ret ?: regs->regs[9];
}
asmlinkage void <API key>(struct pt_regs *regs)
{
int step;
audit_syscall_exit(regs);
if (unlikely(test_thread_flag(<API key>)))
trace_sys_exit(regs, regs->regs[9]);
step = test_thread_flag(TIF_SINGLESTEP);
if (step || test_thread_flag(TIF_SYSCALL_TRACE))
<API key>(regs, step);
}
/* Called with interrupts disabled */
asmlinkage void do_single_step(unsigned long long vec, struct pt_regs *regs)
{
/* This is called after a single step exception (DEBUGSS).
There is no need to change the PC, as it is a post-execution
exception, as entry.S does not do anything to the PC for DEBUGSS.
We need to clear the Single Step setting in SR to avoid
continually stepping. */
local_irq_enable();
regs->sr &= ~SR_SSTEP;
force_sig(SIGTRAP, current);
}
/* Called with interrupts disabled */
BUILD_TRAP_HANDLER(breakpoint)
{
TRAP_HANDLER_DECL;
/* We need to forward step the PC, to counteract the backstep done
in signal.c. */
local_irq_enable();
force_sig(SIGTRAP, current);
regs->pc += 4;
}
/*
* Called by kernel/ptrace.c when detaching..
*
* Make sure single step bits etc are not set.
*/
void ptrace_disable(struct task_struct *child)
{
<API key>(child);
} |
#include <linux/init.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/platform_device.h>
#include <linux/sysdev.h>
#include <linux/interrupt.h>
#include <linux/amba/bus.h>
#include <linux/amba/clcd.h>
#include <linux/clocksource.h>
#include <linux/clockchips.h>
#include <linux/cnt32_to_63.h>
#include <linux/io.h>
#include <linux/clkdev.h>
#include <asm/sched_clock.h>
#include <asm/smp_twd.h>
#include <asm/system.h>
#include <asm/irq.h>
#include <linux/leds.h>
#include <asm/hardware/arm_timer.h>
#include <asm/hardware/gic.h>
#include <asm/hardware/vic.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/flash.h>
#include <asm/mach/irq.h>
#include <asm/mach/time.h>
#include <asm/mach/map.h>
#include <mach/time.h>
#include <mach/hardware.h>
#include <mach/early-debug.h>
#include <mach/irqs.h>
#include "clock.h"
#include <linux/bootmem.h>
static struct map_desc hi3520d_io_desc[] __initdata = {
{
.virtual = HI3520D_IOCH1_VIRT,
.pfn = __phys_to_pfn(HI3520D_IOCH1_PHYS),
.length = HI3520D_IOCH1_SIZE,
.type = <API key>
},
{
.virtual = HI3520D_IOCH2_VIRT,
.pfn = __phys_to_pfn(HI3520D_IOCH2_PHYS),
.length = HI3520D_IOCH2_SIZE,
.type = MT_DEVICE
}
};
static unsigned long <API key>, timer0_clk_hz, timer0_clk_khz;
static unsigned long timer1_clk_hz, timer1_clk_khz;
/*#define HW_REG(a) (*(volatile unsigned int *)(a))*/
#define HW_REG(a) readl(a)
#define A9_AXI_SCALE_REG IO_ADDRESS(CRG_REG_BASE + 0x28)
#define TXIN_OSC_FRE 24000000
#define REG_CRG0_OFFSET IO_ADDRESS(CRG_REG_BASE + 0x0)
#define REG_CRG1_OFFSET IO_ADDRESS(CRG_REG_BASE + 0x4)
#define REG_PERI_CRG57 IO_ADDRESS(CRG_REG_BASE + 0xe4)
#define get_bus_clk()({\
unsigned long fbdiv, pstdiv1, pstdiv2, refdiv;\
unsigned long tmp_reg, foutvco, busclk;\
tmp_reg = HW_REG(REG_CRG0_OFFSET);\
pstdiv1 = (tmp_reg >> 24) & 0x7;\
pstdiv2 = (tmp_reg >> 27) & 0x7;\
tmp_reg = HW_REG(REG_CRG1_OFFSET);\
refdiv = (tmp_reg >> 12) & 0x3f;\
fbdiv = tmp_reg & 0xfff;\
foutvco = TXIN_OSC_FRE / refdiv;\
foutvco *= fbdiv;\
tmp_reg = HW_REG(A9_AXI_SCALE_REG);\
if ((tmp_reg & 0xc) == 0xc)\
busclk = foutvco / 2;\
else\
busclk = foutvco / 4;\
busclk;\
})
static void early_init(void)
{
unsigned long busclk;
edb_trace();
busclk = get_bus_clk();
<API key> = <API key>(busclk);
timer0_clk_hz = <API key>(busclk);
timer0_clk_khz = <API key>(busclk);
timer1_clk_hz = <API key>(busclk);
timer1_clk_khz = <API key>(busclk);
}
void __init hi3520d_map_io(void)
{
int i;
iotable_init(hi3520d_io_desc, ARRAY_SIZE(hi3520d_io_desc));
for (i = 0; i < ARRAY_SIZE(hi3520d_io_desc); i++) {
edb_putstr(" V: "); edb_puthex(hi3520d_io_desc[i].virtual);
edb_putstr(" P: "); edb_puthex(hi3520d_io_desc[i].pfn);
edb_putstr(" S: "); edb_puthex(hi3520d_io_desc[i].length);
edb_putstr(" T: "); edb_putul(hi3520d_io_desc[i].type);
edb_putstr("\n");
}
early_init();
edb_trace();
}
void __iomem *<API key>;
void __init <API key>(void)
{
edb_trace();
<API key> = (void __iomem *)CFG_GIC_CPU_BASE;
gic_init(0, HI3520D_IRQ_START, (void __iomem *)CFG_GIC_DIST_BASE,
(void __iomem *)CFG_GIC_CPU_BASE);
}
static unsigned long <API key>;
static DEFINE_CLOCK_DATA(cd);
static void notrace <API key>(void)
{
u32 cyc = ~readl(CFG_TIMER_VABASE + REG_TIMER1_VALUE);
update_sched_clock(&cd, cyc, (u32)~0);
}
unsigned long long notrace sched_clock(void)
{
u32 cyc = ~readl(CFG_TIMER_VABASE + REG_TIMER1_VALUE);
return cyc_to_sched_clock(&cd, cyc, (u32)~0);
}
static struct clocksource hi3520d_clocksource;
unsigned long long hi_sched_clock(void)
{
return sched_clock();
}
EXPORT_SYMBOL(hi_sched_clock);
static void timer_set_mode(enum clock_event_mode mode,
struct clock_event_device *clk)
{
unsigned long ctrl;
switch (mode) {
case <API key>:
writel(0, CFG_TIMER_VABASE + REG_TIMER_CONTROL);
writel(<API key>,
CFG_TIMER_VABASE + REG_TIMER_RELOAD);
writel(CFG_TIMER_CONTROL,
CFG_TIMER_VABASE + REG_TIMER_CONTROL);
edb_trace();
break;
case <API key>:
writel((CFG_TIMER_32BIT | CFG_TIMER_ONESHOT),
CFG_TIMER_VABASE + REG_TIMER_CONTROL);
break;
case <API key>:
case <API key>:
default:
ctrl = readl(CFG_TIMER_VABASE + REG_TIMER_CONTROL);
ctrl &= ~CFG_TIMER_ENABLE;
writel(ctrl, CFG_TIMER_VABASE + REG_TIMER_CONTROL);
}
}
static int <API key>(unsigned long evt,
struct clock_event_device *unused)
{
unsigned long ctrl;
ctrl = readl(CFG_TIMER_VABASE + REG_TIMER_CONTROL);
ctrl &= ~(CFG_TIMER_ENABLE | CFG_TIMER_INTMASK);
writel(ctrl, CFG_TIMER_VABASE + REG_TIMER_CONTROL);
writel(evt, CFG_TIMER_VABASE + REG_TIMER_RELOAD);
writel(<API key>, CFG_TIMER_VABASE + REG_TIMER_CONTROL);
return 0;
}
static struct clock_event_device timer0_clockevent = {
.name = "timer0",
.shift = 32,
.features = <API key> | <API key>,
.set_mode = timer_set_mode,
.set_next_event = <API key>,
};
/*
* IRQ handler for the timer
*/
static irqreturn_t <API key>(int irq, void *dev_id)
{
if ((readl(CFG_TIMER_VABASE+REG_TIMER_RIS)) & 0x1) {
writel(~0, CFG_TIMER_VABASE + REG_TIMER_INTCLR);
timer0_clockevent.event_handler(&timer0_clockevent);
}
return IRQ_HANDLED;
}
static irqreturn_t <API key>(int irq, void *dev_id)
{
if ((readl(CFG_TIMER_VABASE+REG_TIMER1_RIS)) & 0x1) {
<API key>++;
writel(~0, CFG_TIMER_VABASE + REG_TIMER1_INTCLR);
}
return IRQ_HANDLED;
}
static struct irqaction hi3520d_timer_irq = {
.name = "System Timer Tick",
.flags = IRQF_SHARED | IRQF_DISABLED | IRQF_TIMER,
.handler = <API key>,
};
static struct irqaction <API key> = {
.name = "Free Timer",
.flags = IRQF_SHARED | IRQF_TIMER,
.handler = <API key>,
};
static cycle_t hi3520d_get_cycles(struct clocksource *cs)
{
return ~readl(CFG_TIMER_VABASE + REG_TIMER1_VALUE);
}
static struct clocksource hi3520d_clocksource = {
.name = "timer1",
.rating = 200,
.read = hi3520d_get_cycles,
.mask = CLOCKSOURCE_MASK(32),
.flags = <API key>,
};
static int __init <API key>(void)
{
unsigned long rate = timer1_clk_khz * 1000;
writel(0, CFG_TIMER_VABASE + REG_TIMER1_CONTROL);
writel(0xffffffff, CFG_TIMER_VABASE + REG_TIMER1_RELOAD);
writel(0xffffffff, CFG_TIMER_VABASE + REG_TIMER1_VALUE);
writel(CFG_TIMER_CONTROL, CFG_TIMER_VABASE + REG_TIMER1_CONTROL);
/* caculate the mult/shift by clock rate to gain more accratury */
if (<API key>(&hi3520d_clocksource, rate))
panic("register clocksouce :%s error\n",
hi3520d_clocksource.name);
/* force check the mult/shift of clocksource */
<API key>(&cd, <API key>, 32, rate,
hi3520d_clocksource.mult, hi3520d_clocksource.shift);
return 0;
}
static void __init hi3520d_timer_init(void){
edb_trace();
setup_irq(TIMER01_IRQ, &hi3520d_timer_irq);
setup_irq(TIMER01_IRQ, &<API key>);
<API key>();
timer0_clockevent.mult =
div_sc(timer0_clk_hz, NSEC_PER_SEC, timer0_clockevent.shift);
timer0_clockevent.max_delta_ns =
clockevent_delta2ns(0xffffffff, &timer0_clockevent);
timer0_clockevent.min_delta_ns =
clockevent_delta2ns(0xf, &timer0_clockevent);
timer0_clockevent.cpumask = cpumask_of(0);
<API key>(&timer0_clockevent);
edb_trace();
}
struct sys_timer hi3520d_timer = {
.init = hi3520d_timer_init,
};
#define HIL_AMBADEV_NAME(name) hil_ambadevice_##name
#define HIL_AMBA_DEVICE(name, busid, base, platdata) \
static struct amba_device HIL_AMBADEV_NAME(name) = \
{ .dev = { \
.coherent_dma_mask = ~0, \
.init_name = busid, \
.platform_data = platdata, \
}, \
.res = { \
.start = base##_BASE, \
.end = base##_BASE + 0x10000 - 1, \
.flags = IORESOURCE_IO, \
}, \
.dma_mask = ~0, \
.irq = { base##_IRQ, NO_IRQ } \
}
HIL_AMBA_DEVICE(uart0, "uart:0", UART0, NULL);
HIL_AMBA_DEVICE(uart1, "uart:1", UART1, NULL);
static struct amba_device *amba_devs[] __initdata = {
&HIL_AMBADEV_NAME(uart0),
&HIL_AMBADEV_NAME(uart1),
};
static struct clk uart_clk;
static struct clk_lookup lookups[2];
static void uart_clk_init(unsigned long clk)
{
uart_clk.rate = clk;
lookups[0].dev_id = "uart:0";
lookups[0].clk = &uart_clk;
lookups[1].dev_id = "uart:1";
lookups[1].clk = &uart_clk;
}
void __init hi3520d_init(void)
{
unsigned long i = 0;
unsigned long reg = 0, busclk = 0;
edb_trace();
/* hi3520d uart use apb bus clk */
reg = readl(REG_PERI_CRG57);
reg &= ~UART_CKSEL_APB;
writel(reg, REG_PERI_CRG57);
busclk = get_bus_clk();
busclk = busclk / 4;
uart_clk_init(busclk);
clkdev_add_table(lookups, ARRAY_SIZE(lookups));
for (i = 0; i < ARRAY_SIZE(amba_devs); i++) {
edb_trace();
<API key>(amba_devs[i], &iomem_resource);
}
}
MACHINE_START(HI3520D, "hi3520d")
.boot_params = PHYS_OFFSET+0x100,
.map_io = hi3520d_map_io,
.init_irq = <API key>,
.timer = &hi3520d_timer,
.init_machine = hi3520d_init,
MACHINE_END |
<?php if(VPRO || (!VPRO && $o['version'] != 'pro')):?>
<div class="page_option">
<?php if($o['type']=='check'):?>
<p style="">
<label for="<?php echo $optionid;?>">
<input class="admin_checkbox" type="checkbox" id="<?php echo $optionid;?>" name="<?php echo $optionid;?>" <?php if(pagelines($optionid, $post_ID)) echo 'checked'; else echo 'unchecked';?> /><strong><?php echo $o['inputlabel'];?></strong>
</label>
</p>
<p><?php echo $o['exp'];?></p>
<?php elseif($o['type'] == 'textarea'):?>
<div class="<API key>">
<p>
<label for="<?php echo $optionid;?>"><strong><?php echo $o['inputlabel'];?></strong></label><br/>
<small><?php echo $o['exp'];?></small>
</p>
</div>
<textarea class="html-textarea" id="<?php echo $optionid;?>" name="<?php echo $optionid;?>" /><?php em_pagelines($optionid, $post_ID); ?></textarea>
<?php elseif($o['type'] == 'text'):?>
<p>
<label for="<?php echo $optionid;?>"><strong><?php echo $o['inputlabel'];?></strong></label><br/>
<small><?php echo $o['exp'];?></small><br/>
<input type="text" class="html-text" id="<?php echo $optionid;?>" name="<?php echo $optionid;?>" value="<?php em_pagelines($optionid, $post_ID); ?>" />
</p>
<?php elseif($o['type'] == 'select'):?>
<p>
<label for="<?php echo $optionid;?>" class="context"><?php echo $o['inputlabel'];?></label><br/>
<small><?php echo $o['exp'];?></small>
</p>
<p>
<select id="<?php echo $optionid;?>" name="<?php echo $optionid;?>">
<option value="">—SELECT—</option>
<?php foreach($o['selectvalues'] as $sval => $stext):?>
<?php if($o['type']=='select_same'):?>
<option value="<?php echo $stext;?>" <?php if(m_pagelines($optionid, $post_ID)==$stext) echo 'selected';?>><?php echo $stext;?></option>
<?php else:?>
<option value="<?php echo $sval;?>" <?php if(m_pagelines($optionid, $post_ID)==$sval) echo 'selected';?>><?php echo $stext;?></option>
<?php endif;?>
<?php endforeach;?>
</select>
</p>
<?php endif;?>
<div class="clear"></div>
</div>
<?php endif; ?> |
//file: <API key>.c
//op=213
#include <stdio.h>
#include <stdlib.h>
void func_exit(void) {
printf("%s\n", __func__);
exit(0);
}
void func_call(void) {
printf("%s\n", __func__);
exit(0);
}
unsigned long mem[2] = { 0xb47fef7957f607a6, 0x8f11359b0d4a2989 };
int main(void) {
unsigned long a[4] = { 0, 0 };
asm __volatile__ (
"moveli r29, -13060\n"
"shl16insli r29, r29, 30193\n"
"shl16insli r29, r29, -17572\n"
"shl16insli r29, r29, -9789\n"
"moveli r42, 27632\n"
"shl16insli r42, r42, 12264\n"
"shl16insli r42, r42, 18107\n"
"shl16insli r42, r42, 1639\n"
"move r29, %2\n"
"{ fnop ; st_add r29, r42, 41 }\n"
"move %0, r29\n"
"move %1, r42\n"
:"=r"(a[0]),"=r"(a[1]) : "r"(mem));
printf("%016lx %016lx\n", mem[0], mem[1]);
printf("%016lx\n", a[0]);
printf("%016lx\n", a[1]);
return 0;
} |
<!DOCTYPE html PUBLIC "-
<html><head><title></title>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<link rel="stylesheet" type="text/css" href="search.css"/>
<script type="text/javascript" src="search.js"></script>
</head>
<body class="SRPage">
<div id="SRIndex">
<div class="SRStatus" id="Loading">Loading...</div>
<div class="SRResult" id="SR_adjlinearop">
<div class="SREntry">
<a id="Item0" onkeydown="return searchResults.Nav(event,0)" onkeypress="return searchResults.Nav(event,0)" onkeyup="return searchResults.Nav(event,0)" class="SRSymbol" href="../<API key>.html" target="_parent">AdjLinearOp</a>
<span class="SRScope">RVL</span>
</div>
</div>
<div class="SRResult" id="SR_anloperator">
<div class="SREntry">
<a id="Item1" onkeydown="return searchResults.Nav(event,1)" onkeypress="return searchResults.Nav(event,1)" onkeyup="return searchResults.Nav(event,1)" class="SRSymbol" href="../<API key>.html" target="_parent">ANLOperator</a>
<span class="SRScope">RVL</span>
</div>
</div>
<div class="SRStatus" id="Searching">Searching...</div>
<div class="SRStatus" id="NoMatches">No Matches</div>
<script type="text/javascript"><!
document.getElementById("Loading").style.display="none";
document.getElementById("NoMatches").style.display="none";
var searchResults = new SearchResults("searchResults");
searchResults.Search();
--></script>
</div>
</body>
</html> |
<?php
/**
* WP_Importer base class
*/
class WP_Importer {
/**
* Class Constructor
*
* @return void
*/
function __construct() {}
/**
* Returns array with imported permalinks from WordPress database
*
* @param string $bid
* @return array
*/
function get_imported_posts( $importer_name, $bid ) {
global $wpdb;
$hashtable = array();
$limit = 100;
$offset = 0;
// Grab all posts in chunks
do {
$meta_key = $importer_name . '_' . $bid . '_permalink';
$sql = $wpdb->prepare( "SELECT post_id, meta_value FROM $wpdb->postmeta WHERE meta_key = '%s' LIMIT %d,%d", $meta_key, $offset, $limit );
$results = $wpdb->get_results( $sql );
// Increment offset
$offset = ( $limit + $offset );
if ( !empty( $results ) ) {
foreach ( $results as $r ) {
// Set permalinks into array
$hashtable[$r->meta_value] = intval( $r->post_id );
}
}
} while ( count( $results ) == $limit );
// unset to save memory
unset( $results, $r );
return $hashtable;
}
/**
* Return count of imported permalinks from WordPress database
*
* @param string $bid
* @return int
*/
function <API key>( $importer_name, $bid ) {
global $wpdb;
$count = 0;
// Get count of permalinks
$meta_key = $importer_name . '_' . $bid . '_permalink';
$sql = $wpdb->prepare( "SELECT COUNT( post_id ) AS cnt FROM $wpdb->postmeta WHERE meta_key = '%s'", $meta_key );
$result = $wpdb->get_results( $sql );
if ( !empty( $result ) )
$count = intval( $result[0]->cnt );
// unset to save memory
unset( $results );
return $count;
}
/**
* Set array with imported comments from WordPress database
*
* @param string $bid
* @return array
*/
function <API key>( $bid ) {
global $wpdb;
$hashtable = array();
$limit = 100;
$offset = 0;
// Grab all comments in chunks
do {
$sql = $wpdb->prepare( "SELECT comment_ID, comment_agent FROM $wpdb->comments LIMIT %d,%d", $offset, $limit );
$results = $wpdb->get_results( $sql );
// Increment offset
$offset = ( $limit + $offset );
if ( !empty( $results ) ) {
foreach ( $results as $r ) {
// Explode comment_agent key
list ( $ca_bid, $source_comment_id ) = explode( '-', $r->comment_agent );
$source_comment_id = intval( $source_comment_id );
// Check if this comment came from this blog
if ( $bid == $ca_bid ) {
$hashtable[$source_comment_id] = intval( $r->comment_ID );
}
}
}
} while ( count( $results ) == $limit );
// unset to save memory
unset( $results, $r );
return $hashtable;
}
function set_blog( $blog_id ) {
if ( is_numeric( $blog_id ) ) {
$blog_id = (int) $blog_id;
} else {
$blog = 'http://' . preg_replace( '#^https?://#', '', $blog_id );
if ( ( !$parsed = parse_url( $blog ) ) || empty( $parsed['host'] ) ) {
fwrite( STDERR, "Error: can not determine blog_id from $blog_id\n" );
exit();
}
if ( empty( $parsed['path'] ) )
$parsed['path'] = '/';
$blog = get_blog_details( array( 'domain' => $parsed['host'], 'path' => $parsed['path'] ) );
if ( !$blog ) {
fwrite( STDERR, "Error: Could not find blog\n" );
exit();
}
$blog_id = (int) $blog->blog_id;
}
if ( function_exists( 'is_multisite' ) ) {
if ( is_multisite() )
switch_to_blog( $blog_id );
}
return $blog_id;
}
function set_user( $user_id ) {
if ( is_numeric( $user_id ) ) {
$user_id = (int) $user_id;
} else {
$user_id = (int) username_exists( $user_id );
}
if ( !$user_id || !wp_set_current_user( $user_id ) ) {
fwrite( STDERR, "Error: can not find user\n" );
exit();
}
return $user_id;
}
/**
* Sort by strlen, longest string first
*
* @param string $a
* @param string $b
* @return int
*/
function cmpr_strlen( $a, $b ) {
return strlen( $b ) - strlen( $a );
}
/**
* GET URL
*
* @param string $url
* @param string $username
* @param string $password
* @param bool $head
* @return array
*/
function get_page( $url, $username = '', $password = '', $head = false ) {
// Increase the timeout
add_filter( '<API key>', array( &$this, '<API key>' ) );
$headers = array();
$args = array();
if ( true === $head )
$args['method'] = 'HEAD';
if ( !empty( $username ) && !empty( $password ) )
$headers['Authorization'] = 'Basic ' . base64_encode( "$username:$password" );
$args['headers'] = $headers;
return <API key>( $url, $args );
}
/**
* Bump up the request timeout for http requests
*
* @param int $val
* @return int
*/
function <API key>( $val ) {
return 60;
}
/**
* Check if user has exceeded disk quota
*
* @return bool
*/
function is_user_over_quota() {
if ( function_exists( '<API key>' ) ) {
if ( <API key>( 1 ) ) {
echo "Sorry, you have used your upload quota.\n";
return true;
}
}
return false;
}
/**
* Replace newlines, tabs, and multiple spaces with a single space
*
* @param string $string
* @return string
*/
function min_whitespace( $string ) {
return preg_replace( '|[\r\n\t ]+|', ' ', $string );
}
/**
* Reset global variables that grow out of control during imports
*
* @return void
*/
function stop_the_insanity() {
global $wpdb, $wp_actions;
// Or define( 'WP_IMPORTING', true );
$wpdb->queries = array();
// Reset $wp_actions to keep it from growing out of control
$wp_actions = array();
}
}
/**
* Returns value of command line params.
* Exits when a required param is not set.
*
* @param string $param
* @param bool $required
* @return mixed
*/
function get_cli_args( $param, $required = false ) {
$args = $_SERVER['argv'];
$out = array();
$last_arg = null;
$return = null;
$il = sizeof( $args );
for ( $i = 1, $il; $i < $il; $i++ ) {
if ( (bool) preg_match( "/^--(.+)/", $args[$i], $match ) ) {
$parts = explode( "=", $match[1] );
$key = preg_replace( "/[^a-z0-9]+/", "", $parts[0] );
if ( isset( $parts[1] ) ) {
$out[$key] = $parts[1];
} else {
$out[$key] = true;
}
$last_arg = $key;
} else if ( (bool) preg_match( "/^-([a-zA-Z0-9]+)/", $args[$i], $match ) ) {
for ( $j = 0, $jl = strlen( $match[1] ); $j < $jl; $j++ ) {
$key = $match[1]{$j};
$out[$key] = true;
}
$last_arg = $key;
} else if ( $last_arg !== null ) {
$out[$last_arg] = $args[$i];
}
}
// Check array for specified param
if ( isset( $out[$param] ) ) {
// Set return value
$return = $out[$param];
}
// Check for missing required param
if ( !isset( $out[$param] ) && $required ) {
// Display message and exit
echo "\"$param\" parameter is required but was not specified\n";
exit();
}
return $return;
} |
jQuery(document).ready( function($) {
var item_path = new Object;
var all_exceptiondata = [];
var xid = -1;
$('.add-to-menu .waiting').hide();
$("#pp_save_exceptions input.button-primary").click( function() {
$('input[name="member_csv"]').val( $("input#member_csv").val() );
$('input[name="group_name"]').val( $("input#group_name").val() );
$('input[name="description"]').val( $("input#description").val() );
$("#<API key>").html(ppRestrict.submissionMsg);
$("#<API key>").show();
});
$('#agent-profile #submit').click( function(e) {
// no need to submit selection inputs
$('#<API key>').hide();
$('#pp_add_exception').remove();
});
//$("#<API key> .pp_clear").live( 'click', function(e) {
$(document).on( 'click', "#<API key> .pp_clear", function(e) {
var xid = $(this).closest('tr').find('input[name="pp_xid[]"]').val();
if ( typeof all_exceptiondata[xid] != 'undefined' ) {
delete all_exceptiondata[xid];
}
$(this).closest('tr').remove();
e.stopPropagation();
});
$(".menu-item-checkbox").click( function() {
item_checkbox_click( 'menu-item', $(this) );
});
// for group management exceptions
$(".<API key>").click( function() {
item_checkbox_click( 'pp_group-item', $(this) );
});
// for net group management exceptions
$(".<API key>").click( function() {
item_checkbox_click( 'pp_net_group-item', $(this) );
});
var item_checkbox_click = function( data_var, t ) {
var expr = data_var + '\\[(\[^\\]\]*)';
var re = new RegExp(expr);
var listItemDBIDMatch = re.exec( t.attr('name') );
var listItemDBID = 'undefined' == typeof listItemDBIDMatch[1] ? 0 : parseInt(listItemDBIDMatch[1], 10);
itemdata = t.closest('li').getItemData( 'add-menu-item', listItemDBID );
x_ajax_ui('get_item_path',x_update_item_path,itemdata['menu-item-object-id']);
}
var x_update_item_path = function(data,txtStatus) {
var item_info = data.split('\r');
item_path[ item_info[0] ] = item_info[1];
}
//$('.<API key>').live('click', function(e) {
$(document).on('click', '.<API key>', function(e) {
<API key>('menu-item');
return false;
});
// group management exceptions
//$('.<API key>').live('click', function(e) {
$(document).on('click', '.<API key>', function(e) {
<API key>('pp_group-item');
return false;
});
// net group management exceptions
$(document).on('click', '.<API key>', function(e) {
<API key>('pp_net_group-item');
return false;
});
var <API key> = function(data_var) {
$('div.pp-ext-promo').hide();
var items = $('#<API key>').find('.tabs-panel-active .categorychecklist li input:checked');
if ( ! $('select[name="<API key>"]').val() ) {
$('#<API key>').html( ppRestrict.noOp );
$('#<API key>').addClass('pp-error-note');
$('#<API key>').show();
return false;
}
if ( items.length == 0 ) {
$('#<API key>').html( ppRestrict.noItems );
$('#<API key>').addClass('pp-error-note');
$('#<API key>').show();
return false;
}
var newrow = '', trackdata = '', hier_type = false, assign_mode_inputs = '', item_caption = '', any_added = false, duplicate = false, child_assign = 0, item_assign = 1;
if ( $('#<API key> div').children().length > 1 )
hier_type = true;
if ( hier_type ) {
if ( ! $('#<API key>').is(':checked') )
item_assign = 0;
if ( $('#<API key>').is(':checked') )
child_assign = 1;
}
if ( child_assign ) {
if ( item_assign ) {
var item_lbl = jQuery.trim( $('#<API key>').html() );
item_lbl = item_lbl.replace( ':', '' );
scope_caption = item_lbl + ', ' + jQuery.trim( $('#<API key>').html() );
} else
scope_caption = jQuery.trim( $('#<API key>').html() );
} else {
if ( item_assign ) {
scope_caption = jQuery.trim( $('#<API key>').html() );
} else {
$('#<API key>').html( ppRestrict.noMode );
$('#<API key>').addClass('pp-error-note');
$('#<API key>').show();
return false;
}
}
var for_type = $('select[name="<API key>"]').val();
var op = $('select[name="<API key>"]').val();
var via_type = $('select[name="<API key>"]').val();
var mod_type = $('select[name="<API key>"]').val();
var for_type_caption = $('select[name="<API key>"] option:selected').html()
var op_caption = $('select[name="<API key>"] option:selected').html()
var via_type_caption = $('select[name="<API key>"] option:selected').html()
var mod_type_caption = $('select[name="<API key>"] option:selected').html();
var assign_for_captions = $('select[name="<API key>"] option:selected').html()
var conds = $('td.pp-select-x-status').find('input[name="pp_select_x_cond[]"]:checked');
if ( conds.length == 0 ) {
//conds = [];
//conds[0] = '';
$('#<API key>').html( ppCred.noConditions );
$('#<API key>').addClass('pp-error-note');
$('#<API key>').show();
return false;
}
$('.pp-save-exceptions').show();
$(items).each(function(item_index){
//var t = $(this), re = new RegExp('menu-item\\[(\[^\\]\]*)');
var t = $(this);
var expr = data_var + '\\[(\[^\\]\]*)';
var re = new RegExp(expr);
//var re = new RegExp('menu-item\\[(\[^\\]\]*)');
var listItemDBIDMatch = re.exec( t.attr('name') );
var listItemDBID = 'undefined' == typeof listItemDBIDMatch[1] ? 0 : parseInt(listItemDBIDMatch[1], 10);
// menu-item-title, menu-item-object-id, menu-item-parent-id (post_type: menu-item-object)
//itemdata = t.closest('li').getItemData( 'add-menu-item', listItemDBID );
if ( 'menu-item' == data_var )
itemdata = t.closest('li').getItemData( 'add-'+data_var, listItemDBID );
else
itemdata = t.closest('li').getItemData( data_var, listItemDBID );
if ( typeof( itemdata['menu-item-object-id'] != 'undefined' ) ) {
item_caption = itemdata['menu-item-title'];
if ( hier_type ) {
if ( typeof(item_path[ itemdata['menu-item-object-id'] ]) != 'undefined' )
item_caption = item_path[ itemdata['menu-item-object-id'] ];
}
if ( child_assign ) {
if ( item_assign ) {
var item_lbl = jQuery.trim( $('#<API key>').html() );
item_lbl = item_lbl.replace( ':', '' );
selected_caption = item_lbl + ', ' + jQuery.trim( $('#<API key>').html() );
} else
selected_caption = jQuery.trim( $('#<API key>').html() );
} else {
if ( item_assign ) {
selected_caption = jQuery.trim( $('#<API key>').html() );
} else {
$('#<API key>').html( ppRestrict.noMode );
$('#<API key>').addClass('pp-error-note');
$('#<API key>').show();
return false;
}
}
$(conds).each(function(){
id = agp_escape_id(this.id);
var lbl = $('#pp_add_exception label[for="' + id + '"]');
/*
if ( typeof this == 'Object' ) {
status_id = agp_escape_id(this.id);
status_val = $('#pp_add_exception label[for="' + status_id + '"]').val();
status_caption = $('#pp_add_exception label[for="' + status_id + '"]').html();
} else {
status_val = 'post_status:';
status_caption = '(all)';
}
*/
trackdata = for_type
+ '|' + op
+ '|' + via_type
+ '|' + mod_type
/*+ '|' + status_val*/
+ '|' + $('#' + id).val()
+ '|' + itemdata['menu-item-object-id'];
if ( $.inArray( trackdata, all_exceptiondata ) != -1 ) {
duplicate = true;
} else {
xid++;
all_exceptiondata[xid]=trackdata;
if ( hier_type ) {
assign_mode_inputs = '<input type="hidden" name="pp_add_exception[' + xid + '][for_item]" value="' + item_assign + '" />'
+ '<input type="hidden" name="pp_add_exception[' + xid + '][for_children]" value="' + child_assign + '" />';
} else
assign_mode_inputs = '';
newrow = '<tr>'
+ '<td>' + for_type_caption + '</td>'
+ '<td>' + op_caption + '</td>'
+ '<td>' + mod_type_caption + '</td>'
+ '<td>' + selected_caption + '</td>'
+ '<td>' + item_caption + '</td>'
/*+ '<td>' + status_caption + '</td>'*/
+ '<td>' + lbl.html() + '</td>'
+ '<td><div class="pp_clear">' + ' <a href="javascript:void(0)" class="pp_clear">' + ppRestrict.clearException + '</a></div>'
+ '<input type="hidden" name="pp_xid[]" value="' + xid + '" />'
+ '<input type="hidden" name="pp_add_exception[' + xid + '][for_type]" value="' + for_type + '" />'
+ '<input type="hidden" name="pp_add_exception[' + xid + '][operation]" value="' + op + '" />'
+ '<input type="hidden" name="pp_add_exception[' + xid + '][via_type]" value="' + via_type + '" />'
+ '<input type="hidden" name="pp_add_exception[' + xid + '][mod_type]" value="' + mod_type + '" />'
/*+ '<input type="hidden" name="pp_add_exception[' + xid + '][attrib_cond]" value="' + status_val + '" />'*/
+ '<input type="hidden" name="pp_add_exception[' + xid + '][attrib_cond]" value="' + $('#' + id).val() + '" />'
+ '<input type="hidden" name="pp_add_exception[' + xid + '][item_id]" value="' + itemdata['menu-item-object-id'] + '" />'
+ assign_mode_inputs
+ '</td>'
+ '</tr>';
$('#<API key> tbody').append(newrow);
any_added = true;
}
});
}
});
$("#pp_add_exception .menu-item-checkbox").prop('checked',false);
if ( duplicate && ! any_added ) {
$('#<API key>').html( ppRestrict.alreadyException );
$('#<API key>').addClass('pp-error-note');
$('#<API key>').show();
} else {
$('#<API key>').html(ppRestrict.pleaseReview);
$('#<API key>').removeClass('pp-error-note');
$('#<API key>').show();
}
return false;
}
var reload_operation = function() {
if ( $('select[name="<API key>"]').val() ) {
$('select[name="<API key>"] option.pp-opt-none').remove(); // @todo: review this
x_ajax_ui('<API key>',draw_operations);
} else
$('.<API key>').hide();
}
var reload_via_type = function() {
if ( $('select[name="<API key>"]').val() )
x_ajax_ui('<API key>',draw_via_types);
else
$('.<API key>').hide();
}
var reload_mod_type = function() {
if ( $('select[name="<API key>"]').val() ) {
x_ajax_ui('get_mod_options',draw_mod_types);
} else
$('.<API key>').hide();
}
var reload_assign_for = function() {
if ( $('select[name="<API key>"]').val() )
x_ajax_ui('get_assign_for_ui',draw_assign_for);
else
$('.<API key>').hide();
}
var reload_status = function() {
var op = $('select[name="<API key>"]').val();
var mod_type = $('select[name="<API key>"]').val();
if ( mod_type && op ) {
x_ajax_ui('get_status_ui',draw_status);
if ( 'include' == mod_type ) {
$('input.add-to-top').show();
$('input.add-to-top').parent().show();
} else {
$('input.add-to-top').hide();
$('input.add-to-top').parent().hide();
}
} else
$('.pp-select-x-status').hide();
if ( 'include' == mod_type ) {
$('td.pp-select-items input.menu-item-checkbox[value="0"]').closest('li').show();
} else {
$('td.pp-select-items input.menu-item-checkbox[value="0"]').closest('li').hide();
}
}
$('select[name="<API key>"]').bind( 'change', reload_operation );
$('select[name="<API key>"]').change( function() {
$('.pp-select-items').hide();
$('.<API key>').hide();
$('.<API key>').hide();
$('.pp-select-x-status').hide();
});
$('select[name="<API key>"]').bind( 'change', reload_via_type );
$('select[name="<API key>"]').bind( 'change', reload_mod_type );
$('select[name="<API key>"]').bind( 'change', reload_status );
$('select[name="<API key>"]').bind( 'change', reload_status );
$('select[name="<API key>"]').bind( 'change', reload_status );
$('select[name="<API key>"]').bind( 'change', reload_assign_for );
$('select[name="<API key>"]').change( function() {
$('#pp_add_exception .postbox').hide(); // @todo: review this
if ( $(this).val() ) {
var pp_via_type = $(this).val();
$('#select-exception-' + pp_via_type).show();
$('.pp-select-items').show();
} else
$('.pp-select-items').hide();
$('input.menu-item-checkbox').prop('checked', false);
});
var draw_operations = function(data,txtStatus) {
sel = $('select[name="<API key>"]');
sel.html(data);
sel.triggerHandler('change');
$('.<API key>').show();
x_ajax_ui_done();
}
var draw_via_types = function(data,txtStatus) {
sel = $('select[name="<API key>"]');
sel.html(data);
sel.triggerHandler('change');
$('.<API key>').show();
x_ajax_ui_done();
}
var draw_mod_types = function(data,txtStatus) {
sel = $('select[name="<API key>"]');
sel.html(data);
sel.triggerHandler('change');
$('.<API key>').show();
x_ajax_ui_done();
}
var draw_assign_for = function(data,txtStatus) {
dv = $('#<API key>');
dv.html(data);
if ( dv.children().length > 1 )
$('.<API key>').show();
else
$('.<API key>').hide();
x_ajax_ui_done();
}
var draw_status = function(data,txtStatus) {
dv = $('td.pp-select-x-status');
dv.html(data);
if ( dv.children().length > 1 )
$('.pp-select-x-status').show();
else
$('.pp-select-x-status').hide();
if ( $('.pp-select-x-status input:checkbox').length == 1 ) {
$('.pp-select-x-status input:checkbox').prop('checked', true);
}
x_ajax_ui_done();
}
var x_ajax_ui = function(op,handler,item_id) {
if ( 'get_item_path' != op ) {
$('#pp_add_exception select').prop('disabled',true);
$('#<API key>').show();
}
if ( typeof item_id == 'undefined' )
item_id = 0;
var data = { '<API key>': op, 'pp_for_type' : $('select[name="<API key>"]').val(), 'pp_operation': $('select[name="<API key>"]').val(), 'pp_via_type': $('select[name="<API key>"]').val(), 'pp_mod_type': $('select[name="<API key>"]').val(), 'pp_agent_id' : ppRestrict.agentID, 'pp_agent_type' : ppRestrict.agentType, 'pp_item_id' : item_id };
$.ajax({url:ppRestrict.ajaxurl, data:data, dataType:"html", success:handler, error:x_ajax_ui_failure});
}
var x_ajax_ui_done = function() {
$('#pp_add_exception select').prop('disabled',false);
$('#<API key>').hide();
$.event.trigger({type: "pp_exceptions_ui"});
}
var x_ajax_ui_failure = function(data,txtStatus) {
$('#pp_add_exception .waiting').hide();
return;
}
var PPsearchTimer;
$('.pp-quick-search').keypress(function(e){
var t = $(this);
if( 13 == e.which ) {
<API key>( t );
return false;
}
if( PPsearchTimer ) clearTimeout(PPsearchTimer);
PPsearchTimer = setTimeout(function(){
<API key>( t );
}, 400);
}).attr('autocomplete','off');
var <API key> = function(input) {
var panel, params,
minSearchLength = 2,
q = input.val();
if( q.length < minSearchLength ) return;
panel = input.parents('.tabs-panel');
params = {
'action': '<API key>',
'response-format': 'markup',
'menu': $('#menu').val(),
'<API key>': $('#<API key>').val(),
'q': q,
'type': input.attr('name')
};
$('img.waiting', panel).show();
$.post( ajaxurl, params, function(menuMarkup) {
<API key>(menuMarkup, params, panel);
});
}
/**
* Process the quick search response into a search result
*
* @param string resp The server response to the query.
* @param object req The request arguments.
* @param jQuery panel The tabs panel we're searching in.
*/
var <API key> = function(resp, req, panel) {
var matched, newID,
takenIDs = {},
form = document.getElementById('nav-menu-meta'),
pattern = new RegExp('menu-item\\[(\[^\\]\]*)', 'g'),
$items = $('<div>').html(resp).find('li'),
$item;
if( ! $items.length ) {
$('.categorychecklist', panel).html( '<li><p>' + ppItems.noResultsFound + '</p></li>' );
$('img.waiting', panel).hide();
return;
}
$items.each(function(){
$item = $(this);
// make a unique DB ID number
matched = pattern.exec($item.html());
if ( matched && matched[1] ) {
newID = matched[1];
while( form.elements['menu-item[' + newID + '][menu-item-type]'] || takenIDs[ newID ] ) {
newID
}
takenIDs[newID] = true;
if ( newID != matched[1] ) {
$item.html( $item.html().replace(new RegExp(
'menu-item\\[' + matched[1] + '\\]', 'g'),
'menu-item[' + newID + ']'
) );
}
}
});
$('.categorychecklist', panel).html( $items );
$('img.waiting', panel).hide();
}
$('#<API key> input').click( function(e) {
$(this).closest('div.<API key>').find('div.<API key>').show();
});
$('#<API key> .pp_check_all').click( function(e) {
$(this).closest('td').find('input[name="pp_edit_exception[]"][disabled!="true"]').prop('checked', $(this).is(':checked') );
});
var <API key> = function() {
$('#<API key> input.<API key>').prop('disabled',false);
$('#<API key> .waiting').hide();
}
var <API key> = function(data,txtStatus) {
<API key>();
if ( ! data )
return;
var startpos = data.indexOf('<!--ppResponse
var endpos = data.indexOf('<--ppResponse
if ( ( startpos == -1 ) || ( endpos <= startpos ) )
return;
data = data.substr(startpos+17,endpos-startpos-17);
var deleted_ass_ids = data.split('|');
$.each(deleted_ass_ids, function(index, value) {
cbid = $('#<API key> input[name="pp_edit_exception[]"][value="' + value + '"]').attr('id');
$('#' + cbid).closest('label').parent().remove();
var ass_ids = value.split(','); // some checkboxes represent both an item and child exception_item
for (i = 0; i < ass_ids.length; ++i) {
$('#<API key> label[class~="from_' + ass_ids[i] + '"]').parent().remove();
}
});
}
var <API key> = function(data,txtStatus) {
<API key>();
if ( ! data )
return;
var startpos = data.indexOf('<!--ppResponse
var endpos = data.indexOf('<--ppResponse
if ( ( startpos == -1 ) || ( endpos <= startpos ) )
return;
data = data.substr(startpos+17,endpos-startpos-17);
var edit_data = data.split('~');
var operation = edit_data[0];
var set_class = '';
switch(operation) {
case '<API key>':
set_class = 'role_both';
break;
case '<API key>':
set_class = '';
break;
case '<API key>':
set_class = 'role_ch';
break;
default:
return;
}
var edited_eitem_ids = edit_data[1].split('|');
$.each(edited_eitem_ids, function(index, value) {
cbid = $('#<API key> input[name="pp_edit_exception[]"][value="' + value + '"]').attr('id');
$('#' + cbid).closest('div').find('label').attr('class',set_class);
// temp workaround for Ajax UI limitation
if ( ( '<API key>' == operation ) || ( '<API key>' == operation ) ) {
$('#' + cbid).closest('div').find('input').prop('checked',false);
$('#' + cbid).closest('div').find('input').prop('disabled',true);
$('#' + cbid).closest('div').find('label').attr('title',ppRestrict.reloadRequired);
}
});
}
$('#<API key> input.<API key>').click( function(e) {
var action = $(this).closest('div.<API key>').find('div.<API key> select').first().val();
if ( ! action ) {
alert(ppRestrict.noAction);
return false;
}
var selected_ids = new Array();
$(this).closest('div.<API key>').find('input[type="checkbox"]:checked').each(function(){
selected_ids.push( $(this).attr('value') );
});
$(this).prop('disabled',true);
$(this).closest('div').find('.waiting').show();
switch( action ) {
case 'remove':
ajax_submit('exceptions_remove',<API key>,selected_ids.join('|'));
break
default:
ajax_submit('exceptions_' + action,<API key>,selected_ids.join('|'));
break
}
return false;
});
var ajax_submit = function(op,handler,rids) {
if ( ! rids )
return;
var data = { 'pp_ajax_submission': op, 'agent_type': ppRestrict.agentType, 'agent_id': ppRestrict.agentID, 'pp_eitem_ids' : rids };
$.ajax({url:ppRestrict.ajaxurl, data:data, dataType:"html", success:handler, error:ajax_submit_failure});
}
var ajax_submit_failure = function(data,txtStatus) {
return;
}
$(document).on('mouseenter', 'div.<API key> label', function() {
var func = function(lbl) {
$(lbl).parent().find('a').show();
}
window.setTimeout( func, 300, $(this) );
});
}); |
#pragma once
/**
* Rev B 16 JAN 2017
*
* Added pointers to currently available Arduino IDE extensions that will
* allow this board to use the latest Marlin software
*
*
* Rev C 2 JUN 2017
*
* Converted to Arduino pin numbering
*/
/**
* To burn the bootloader that comes with Printrboard:
*
* 1. Connect your programmer to the board.
* 2. In the Arduino IDE select "Printrboard" and then select the programmer.
* 3. In the Arduino IDE click on "burn bootloader". Don't worry about the "verify failed at 1F000" error message.
* 4. The programmer is no longer needed. Remove it.
*/
#if NOT_TARGET(__AVR_AT90USB1286__)
#error "Oops! Select 'Teensy++ 2.0' or 'Printrboard' in 'Tools > Board.'"
#endif
#define BOARD_INFO_NAME "Brainwave Pro"
// Limit Switches
#define X_STOP_PIN 45
#define Y_STOP_PIN 12
#define Z_STOP_PIN 36
// Z Probe (when not Z_MIN_PIN)
#ifndef Z_MIN_PROBE_PIN
#define Z_MIN_PROBE_PIN 11
#endif
// Steppers
#define X_STEP_PIN 9
#define X_DIR_PIN 8
#define X_ENABLE_PIN 23
#define Y_STEP_PIN 7
#define Y_DIR_PIN 6
#define Y_ENABLE_PIN 20
#define Z_STEP_PIN 5
#define Z_DIR_PIN 4
#define Z_ENABLE_PIN 37
#define E0_STEP_PIN 47
#define E0_DIR_PIN 46
#define E0_ENABLE_PIN 25
// Temperature Sensors
#define TEMP_0_PIN 2 // F2 Analog Input
#define TEMP_1_PIN 1 // F1 Analog Input
#define TEMP_BED_PIN 0 // F0 Analog Input
// Heaters / Fans
#define HEATER_0_PIN 27
#define HEATER_BED_PIN 26 // B6 Bed
#ifndef FAN_PIN
#define FAN_PIN 16 // C6 Fan, PWM3A
#endif
// Misc. Functions
#define SDSS 20
#define SD_DETECT_PIN 24
#define LED_PIN 13 |
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/smp.h>
#include <linux/io.h>
#include <linux/mfd/dbx500-prcmu.h>
#include <asm/cacheflush.h>
#include <asm/hardware/gic.h>
#include <asm/smp_plat.h>
#include <asm/smp_scu.h>
#include <mach/hardware.h>
#include <mach/setup.h>
#include "id.h"
/* This is called from headsmp.S to wakeup the secondary core */
extern void <API key>(void);
/*
* control for which core is the next to come out of the secondary
* boot "holding pen"
*/
volatile int pen_release = -1;
/*
* Write pen_release in a way that is guaranteed to be visible to all
* observers, irrespective of whether they're taking part in coherency
* or not. This is necessary for the hotplug code to work reliably.
*/
static void write_pen_release(int val)
{
pen_release = val;
smp_wmb();
<API key>((void *)&pen_release, sizeof(pen_release));
outer_clean_range(__pa(&pen_release), __pa(&pen_release + 1));
}
static void __iomem *scu_base_addr(void)
{
if (cpu_is_u8500_family() || cpu_is_ux540_family())
return __io_address(U8500_SCU_BASE);
else
ux500_unknown_soc();
return NULL;
}
static DEFINE_SPINLOCK(boot_lock);
void __cpuinit <API key>(unsigned int cpu)
{
/*
* if any interrupts are already enabled for the primary
* core (e.g. timer irq), then they will not have been enabled
* for us: do so
*/
gic_secondary_init(0);
/*
* let the primary processor know we're out of the
* pen, then head off into the C entry point
*/
write_pen_release(-1);
/*
* Synchronise with the boot thread.
*/
spin_lock(&boot_lock);
spin_unlock(&boot_lock);
}
int __cpuinit boot_secondary(unsigned int cpu, struct task_struct *idle)
{
unsigned long timeout;
int ret;
ret = prcmu_replug_cpu1();
/* if CPU1 not switch on Abort sequence */
if (ret != 0)
return ret;
/*
* set synchronisation state between this boot processor
* and the secondary one
*/
spin_lock(&boot_lock);
/*
* The secondary processor is waiting to be released from
* the holding pen - release it, then wait for it to flag
* that it has been released by resetting pen_release.
*/
write_pen_release(cpu_logical_map(cpu));
smp_send_reschedule(cpu);
timeout = jiffies + (1 * HZ);
while (time_before(jiffies, timeout)) {
if (pen_release == -1)
break;
}
/*
* now the secondary core is starting up let it run its
* calibrations, then wait for it to finish
*/
spin_unlock(&boot_lock);
return pen_release != -1 ? -ENOSYS : 0;
}
static void __init wakeup_secondary(void)
{
void __iomem *backupram;
if (cpu_is_u8500_family() || cpu_is_ux540_family())
backupram = __io_address(<API key>);
else
ux500_unknown_soc();
/*
* write the address of secondary startup into the backup ram register
* at offset 0x1FF4, then write the magic number 0xA1FEED01 to the
* backup ram register at offset 0x1FF0, which is what boot rom code
* is waiting for. This would wake up the secondary core from WFE
*/
#define <API key> 0x1FF4
__raw_writel(virt_to_phys(<API key>),
backupram + <API key>);
#define <API key> 0x1FF0
__raw_writel(0xA1FEED01,
backupram + <API key>);
/* make sure write buffer is drained */
mb();
}
/*
* Initialise the CPU possible map early - this describes the CPUs
* which may be present or become present in the system.
*/
void __init smp_init_cpus(void)
{
void __iomem *scu_base = scu_base_addr();
unsigned int i, ncores;
ncores = scu_base ? scu_get_core_count(scu_base) : 1;
/* sanity check */
if (ncores > NR_CPUS) {
printk(KERN_WARNING
"U8500: no. of cores (%d) greater than configured "
"maximum of %d - clipping\n",
ncores, NR_CPUS);
ncores = NR_CPUS;
}
for (i = 0; i < ncores; i++)
set_cpu_possible(i, true);
set_smp_cross_call(gic_raise_softirq);
}
void __init <API key>(unsigned int max_cpus)
{
int i;
/*
* Initialise the present map, which describes the set of CPUs
* actually populated at the present time.
*/
for (i = 0; i < max_cpus; i++)
set_cpu_present(i, true);
scu_enable(scu_base_addr());
wakeup_secondary();
} |
#ifndef <API key>
#define <API key>
#include "ardour/filter.h"
#include "ardour/timefx_request.h"
namespace ARDOUR {
class LIBARDOUR_API MidiStretch : public Filter {
public:
MidiStretch (ARDOUR::Session&, const TimeFXRequest&);
~MidiStretch ();
int run (boost::shared_ptr<ARDOUR::Region>, Progress* progress = 0);
private:
const TimeFXRequest& _request;
};
} /* namespace ARDOUR */
#endif /* <API key> */ |
#ifndef <API key>
#define <API key>
#include <string>
#include "ardour/export_format_base.h"
namespace ARDOUR
{
Allows adding to all sets. A format should be able to test if it is compatible with this
class LIBARDOUR_API <API key> : public ExportFormatBase, public ExportFormatBase::<API key> {
private:
public:
<API key> (std::string name)
{
set_name (name);
sample_formats.insert (SF_None);
sample_rates.insert (SR_None);
format_ids.insert (F_None);
qualities.insert (Q_None);
}
~<API key> () {};
<API key> (ExportFormatBase const & other)
: ExportFormatBase (other) {}
void add_endianness (Endianness endianness) { endiannesses.insert (endianness); }
void add_sample_format (SampleFormat format) { sample_formats.insert (format); }
void add_sample_rate (SampleRate rate) { sample_rates.insert (rate); }
void add_format_id (FormatId id) { format_ids.insert (id); }
void add_quality (Quality quality) { qualities.insert (quality); }
};
} // namespace ARDOUR
#endif /* <API key> */ |
#undef DEBUG
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/list.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/limits.h>
#include <linux/bitops.h>
#include <linux/err.h>
#include <linux/cpufreq.h>
#include <linux/i2c/twl4030.h>
#include <mach/clock.h>
#include <mach/sram.h>
#include <asm/div64.h>
#include <mach/sdrc.h>
#include "clock.h"
#include "clock34xx.h"
#include "prm.h"
#include "prm-regbits-34xx.h"
#include "cm.h"
#include "cm-regbits-34xx.h"
#include "pm.h"
/* CM_AUTOIDLE_PLL*.AUTO_* bit values */
#define <API key> 0x0
#define <API key> 0x1
#define MAX_DPLL_WAIT_TRIES 1000000
#define <API key> 83000000
#define CYCLES_PER_MHZ 1000000
/* Scale factor for fixed-point arith in <API key>() */
#define SDRC_MPURATE_SCALE 8
/* 2^<API key>: MPU MHz that SDRC_MPURATE_LOOPS is defined for */
#define <API key> 9
/*
* SDRC_MPURATE_LOOPS: Number of MPU loops to execute at
* 2^MPURATE_BASE_SHIFT MHz for SDRC to stabilize
*/
#define SDRC_MPURATE_LOOPS 24
/**
* omap3_dpll_recalc - recalculate DPLL rate
* @clk: DPLL struct clk
* @parent_rate: rate of the DPLL's parent clock
* @rate_storage: flag indicating whether current or temporary rate is changing
*
* Recalculate and propagate the DPLL rate.
*/
static void omap3_dpll_recalc(struct clk *clk, unsigned long parent_rate,
u8 rate_storage)
{
unsigned long rate;
rate = omap2_get_dpll_rate(clk, parent_rate);
if (rate_storage == CURRENT_RATE)
clk->rate = rate;
else if (rate_storage == TEMP_RATE)
clk->temp_rate = rate;
}
/* <API key> - write clken_bits arg to a DPLL's enable bits */
static void <API key>(struct clk *clk, u8 clken_bits)
{
const struct dpll_data *dd;
u32 v;
dd = clk->dpll_data;
v = cm_read_mod_reg(clk->prcm_mod, dd->control_reg);
v &= ~dd->enable_mask;
v |= clken_bits << __ffs(dd->enable_mask);
cm_write_mod_reg(v, clk->prcm_mod, dd->control_reg);
}
/* <API key>: wait for a DPLL to enter a specific state */
static int <API key>(struct clk *clk, u8 state)
{
const struct dpll_data *dd;
int i = 0;
int ret = -EINVAL;
dd = clk->dpll_data;
state <<= __ffs(dd->idlest_mask);
while (((cm_read_mod_reg(clk->prcm_mod, dd->idlest_reg)
& dd->idlest_mask) != state) &&
i < MAX_DPLL_WAIT_TRIES) {
i++;
udelay(1);
}
if (i == MAX_DPLL_WAIT_TRIES) {
printk(KERN_ERR "clock: %s failed transition to '%s'\n",
clk->name, (state) ? "locked" : "bypassed");
} else {
pr_debug("clock: %s transition to '%s' in %d loops\n",
clk->name, (state) ? "locked" : "bypassed", i);
ret = 0;
}
return ret;
}
/* From 3430 TRM ES2 4.7.6.2 */
static u16 <API key>(struct clk *clk, u8 n)
{
unsigned long fint;
u16 f = 0;
fint = clk->parent->rate / (n + 1);
pr_debug("clock: fint is %lu\n", fint);
if (fint >= 750000 && fint <= 1000000)
f = 0x3;
else if (fint > 1000000 && fint <= 1250000)
f = 0x4;
else if (fint > 1250000 && fint <= 1500000)
f = 0x5;
else if (fint > 1500000 && fint <= 1750000)
f = 0x6;
else if (fint > 1750000 && fint <= 2100000)
f = 0x7;
else if (fint > 7500000 && fint <= 10000000)
f = 0xB;
else if (fint > 10000000 && fint <= 12500000)
f = 0xC;
else if (fint > 12500000 && fint <= 15000000)
f = 0xD;
else if (fint > 15000000 && fint <= 17500000)
f = 0xE;
else if (fint > 17500000 && fint <= 21000000)
f = 0xF;
else
pr_debug("clock: unknown freqsel setting for %d\n", n);
return f;
}
/* Non-CORE DPLL (e.g., DPLLs that do not control SDRC) clock functions */
/*
* <API key> - instruct a DPLL to lock and wait for readiness
* @clk: pointer to a DPLL struct clk
*
* Instructs a non-CORE DPLL to lock. Waits for the DPLL to report
* readiness before returning. Will save and restore the DPLL's
* autoidle state across the enable, per the CDP code. If the DPLL
* locked successfully, return 0; if the DPLL did not lock in the time
* allotted, or DPLL3 was passed in, return -EINVAL.
*/
static int <API key>(struct clk *clk)
{
u8 ai;
int r;
if (clk == &dpll3_ck)
return -EINVAL;
pr_debug("clock: locking DPLL %s\n", clk->name);
ai = <API key>(clk);
<API key>(clk);
<API key>(clk, DPLL_LOCKED);
r = <API key>(clk, 1);
if (ai)
<API key>(clk);
return r;
}
/*
* <API key> - instruct a DPLL to bypass and wait for readiness
* @clk: pointer to a DPLL struct clk
*
* Instructs a non-CORE DPLL to enter low-power bypass mode. In
* bypass mode, the DPLL's rate is set equal to its parent clock's
* rate. Waits for the DPLL to report readiness before returning.
* Will save and restore the DPLL's autoidle state across the enable,
* per the CDP code. If the DPLL entered bypass mode successfully,
* return 0; if the DPLL did not enter bypass in the time allotted, or
* DPLL3 was passed in, or the DPLL does not support low-power bypass,
* return -EINVAL.
*/
static int <API key>(struct clk *clk)
{
int r;
u8 ai;
if (clk == &dpll3_ck)
return -EINVAL;
if (!(clk->dpll_data->modes & (1 << <API key>)))
return -EINVAL;
pr_debug("clock: configuring DPLL %s for low-power bypass\n",
clk->name);
ai = <API key>(clk);
<API key>(clk, <API key>);
r = <API key>(clk, 0);
if (ai)
<API key>(clk);
else
<API key>(clk);
return r;
}
/*
* <API key> - instruct a DPLL to stop
* @clk: pointer to a DPLL struct clk
*
* Instructs a non-CORE DPLL to enter low-power stop. Will save and
* restore the DPLL's autoidle state across the stop, per the CDP
* code. If DPLL3 was passed in, or the DPLL does not support
* low-power stop, return -EINVAL; otherwise, return 0.
*/
static int <API key>(struct clk *clk)
{
u8 ai;
if (clk == &dpll3_ck)
return -EINVAL;
if (!(clk->dpll_data->modes & (1 << DPLL_LOW_POWER_STOP)))
return -EINVAL;
pr_debug("clock: stopping DPLL %s\n", clk->name);
ai = <API key>(clk);
<API key>(clk, DPLL_LOW_POWER_STOP);
if (ai)
<API key>(clk);
else
<API key>(clk);
return 0;
}
/**
* <API key> - instruct a DPLL to enter bypass or lock mode
* @clk: pointer to a DPLL struct clk
*
* Instructs a non-CORE DPLL to enable, e.g., to enter bypass or lock.
* The choice of modes depends on the DPLL's programmed rate: if it is
* the same as the DPLL's parent clock, it will enter bypass;
* otherwise, it will enter lock. This code will wait for the DPLL to
* indicate readiness before returning, unless the DPLL takes too long
* to enter the target state. Intended to be used as the struct clk's
* enable function. If DPLL3 was passed in, or the DPLL does not
* support low-power stop, or if the DPLL took too long to enter
* bypass or lock, return -EINVAL; otherwise, return 0.
*/
static int <API key>(struct clk *clk)
{
int r;
struct dpll_data *dd;
if (clk == &dpll3_ck)
return -EINVAL;
dd = clk->dpll_data;
if (!dd)
return -EINVAL;
if (clk->rate == dd->bypass_clk->rate)
r = <API key>(clk);
else
r = <API key>(clk);
return r;
}
/**
* <API key> - instruct a DPLL to enter bypass or lock mode
* @clk: pointer to a DPLL struct clk
*
* Instructs a non-CORE DPLL to enable, e.g., to enter bypass or lock.
* The choice of modes depends on the DPLL's programmed rate: if it is
* the same as the DPLL's parent clock, it will enter bypass;
* otherwise, it will enter lock. This code will wait for the DPLL to
* indicate readiness before returning, unless the DPLL takes too long
* to enter the target state. Intended to be used as the struct clk's
* enable function. If DPLL3 was passed in, or the DPLL does not
* support low-power stop, or if the DPLL took too long to enter
* bypass or lock, return -EINVAL; otherwise, return 0.
*/
static void <API key>(struct clk *clk)
{
if (clk == &dpll3_ck)
return;
<API key>(clk);
}
/* OMAP3630 j-type DPLL4 compensation variables */
void lookup_dco_sddiv(struct clk *clk, u8 *dco, u8 *sd_div, u16 m, u8 n)
{
unsigned long fint, clkinp, sd; /* watch out for overflow */
int mod1, mod2;
++n; /* always n+1 below */
clkinp = clk->parent->rate;
fint = (clkinp / n) * m;
if (fint < 1000000000)
*dco = 2;
else
*dco = 4;
/*
* target sigma-delta to near 250MHz
* sd = ceil[(m/(n+1)) * (clkinp_MHz / 250)]
*/
clkinp /= 100000; /* shift from MHz to 10*Hz for 38.4 and 19.2*/
mod1 = (clkinp * m) % (250 * n);
sd = (clkinp * m) / (250 * n);
mod2 = sd % 10;
sd /= 10;
if (mod1 + mod2)
++sd;
*sd_div = sd;
}
/*
* <API key> - set non-core DPLL M,N values directly
* @clk: struct clk * of DPLL to set
* @m: DPLL multiplier to set
* @n: DPLL divider to set
* @freqsel: FREQSEL value to set
*
* Program the DPLL with the supplied M, N values, and wait for the DPLL to
* lock.. Returns -EINVAL upon error, or 0 upon success.
*/
static int <API key>(struct clk *clk, u16 m, u8 n, u16 freqsel)
{
struct dpll_data *dd;
u32 v;
if (!clk)
return -EINVAL;
dd = clk->dpll_data;
if (!dd)
return -EINVAL;
/*
* According to the 12-5 CDP code from TI, "Limitation 2.5"
* on 3430ES1 prevents us from changing DPLL multipliers or dividers
* on DPLL4.
*/
if (omap_rev() == OMAP3430_REV_ES1_0 &&
!strcmp("dpll4_ck", clk->name)) {
printk(KERN_ERR "clock: DPLL4 cannot change rate due to "
"silicon 'Limitation 2.5' on 3430ES1.\n");
return -EINVAL;
}
/* 3430 ES2 TRM: 4.7.6.9 DPLL Programming Sequence */
<API key>(clk);
/* Set jitter correction */
v = cm_read_mod_reg(clk->prcm_mod, dd->control_reg);
v &= ~dd->freqsel_mask;
v |= freqsel << __ffs(dd->freqsel_mask);
cm_write_mod_reg(v, clk->prcm_mod, dd->control_reg);
/* Set DPLL multiplier, divider */
v = cm_read_mod_reg(clk->prcm_mod, dd->mult_div1_reg);
v &= ~(dd->mult_mask | dd->div1_mask);
v |= m << __ffs(dd->mult_mask);
v |= (n - 1) << __ffs(dd->div1_mask);
if (dd->jtype) {
u8 dco, sd_div;
lookup_dco_sddiv(clk, &dco, &sd_div, m, n);
v &= ~(dd->dco_sel_mask | dd->sd_div_mask);
v |= dco << __ffs(dd->dco_sel_mask);
v |= sd_div << __ffs(dd->sd_div_mask);
}
cm_write_mod_reg(v, clk->prcm_mod, dd->mult_div1_reg);
/* We let the clock framework set the other output dividers later */
/* REVISIT: Set ramp-up delay? */
<API key>(clk);
return 0;
}
/**
* <API key> - set non-core DPLL rate
* @clk: struct clk * of DPLL to set
* @rate: rounded target rate
*
* Set the DPLL CLKOUT to the target rate. If the DPLL can enter
* low-power bypass, and the target rate is the bypass source clock
* rate, then configure the DPLL for bypass. Otherwise, round the
* target rate if it hasn't been done already, then program and lock
* the DPLL. Returns -EINVAL upon error, or 0 upon success.
*/
static int <API key>(struct clk *clk, unsigned long rate)
{
u16 freqsel;
struct dpll_data *dd;
int ret;
if (!clk || !rate)
return -EINVAL;
dd = clk->dpll_data;
if (!dd)
return -EINVAL;
if (rate == omap2_get_dpll_rate(clk, clk->parent->rate))
return 0;
if (dd->bypass_clk->rate == rate &&
(clk->dpll_data->modes & (1 << <API key>))) {
pr_debug("clock: %s: set rate: entering bypass.\n", clk->name);
ret = <API key>(clk);
if (!ret)
clk->rate = rate;
} else {
if (dd->last_rounded_rate != rate)
<API key>(clk, rate);
if (dd->last_rounded_rate == 0)
return -EINVAL;
freqsel = <API key>(clk, dd->last_rounded_n);
if (!freqsel)
WARN_ON(1);
pr_debug("clock: %s: set rate: locking rate to %lu.\n",
clk->name, rate);
ret = <API key>(clk, dd->last_rounded_m,
dd->last_rounded_n, freqsel);
if (!ret)
clk->rate = rate;
}
return 0;
}
/*
* CORE DPLL (DPLL3) rate programming functions
*
* These call into SRAM code to do the actual CM writes, since the SDRAM
* is clocked from DPLL3.
*/
/**
* <API key> - set CORE DPLL M2 divider
* @clk: struct clk * of DPLL to set
* @rate: rounded target rate
*
* Program the DPLL M2 divider with the rounded target rate. Returns
* -EINVAL upon error, or 0 upon success.
*/
static int <API key>(struct clk *clk, unsigned long rate)
{
u32 new_div = 0;
u32 unlock_dll = 0;
u32 c;
unsigned long validrate, sdrcrate, mpurate;
struct omap_sdrc_params *sp;
if (!clk || !rate)
return -EINVAL;
if (clk != &dpll3_m2_ck)
return -EINVAL;
validrate = <API key>(clk, rate, &new_div);
if (validrate != rate)
return -EINVAL;
sdrcrate = sdrc_ick.rate;
if (rate > clk->rate)
sdrcrate <<= ((rate / clk->rate) >> 1);
else
sdrcrate >>= ((clk->rate / rate) >> 1);
sp = <API key>(sdrcrate);
if (!sp)
return -EINVAL;
if (sdrcrate < <API key>) {
pr_debug("clock: will unlock SDRC DLL\n");
unlock_dll = 1;
}
/*
* XXX This only needs to be done when the CPU frequency changes
*/
mpurate = arm_fck.rate / CYCLES_PER_MHZ;
c = (mpurate << SDRC_MPURATE_SCALE) >> <API key>;
c += 1; /* for safety */
c *= SDRC_MPURATE_LOOPS;
c >>= SDRC_MPURATE_SCALE;
if (c == 0)
c = 1;
pr_debug("clock: changing CORE DPLL rate from %lu to %lu\n", clk->rate,
validrate);
pr_debug("clock: SDRC timing params used: %08x %08x %08x\n",
sp->rfr_ctrl, sp->actim_ctrla, sp->actim_ctrlb);
<API key>(sp->rfr_ctrl, sp->actim_ctrla,
sp->actim_ctrlb, new_div, unlock_dll, c,
sp->mr, rate > clk->rate);
return 0;
}
/* DPLL autoidle read/set code */
/**
* <API key> - read a DPLL's autoidle bits
* @clk: struct clk * of the DPLL to read
*
* Return the DPLL's autoidle bits, shifted down to bit 0. Returns
* -EINVAL if passed a null pointer or if the struct clk does not
* appear to refer to a DPLL.
*/
static u32 <API key>(struct clk *clk)
{
const struct dpll_data *dd;
u32 v;
if (!clk || !clk->dpll_data)
return -EINVAL;
dd = clk->dpll_data;
v = cm_read_mod_reg(clk->prcm_mod, dd->autoidle_reg);
v &= dd->autoidle_mask;
v >>= __ffs(dd->autoidle_mask);
return v;
}
/**
* <API key> - enable DPLL autoidle bits
* @clk: struct clk * of the DPLL to operate on
*
* Enable DPLL automatic idle control. This automatic idle mode
* switching takes effect only when the DPLL is locked, at least on
* OMAP3430. The DPLL will enter low-power stop when its downstream
* clocks are gated. No return value.
*/
static void <API key>(struct clk *clk)
{
const struct dpll_data *dd;
u32 v;
if (!clk || !clk->dpll_data)
return;
dd = clk->dpll_data;
/*
* REVISIT: CORE DPLL can optionally enter low-power bypass
* by writing 0x5 instead of 0x1. Add some mechanism to
* optionally enter this mode.
*/
v = cm_read_mod_reg(clk->prcm_mod, dd->autoidle_reg);
v &= ~dd->autoidle_mask;
v |= <API key> << __ffs(dd->autoidle_mask);
cm_write_mod_reg(v, clk->prcm_mod, dd->autoidle_reg);
}
/**
* <API key> - prevent DPLL from automatically idling
* @clk: struct clk * of the DPLL to operate on
*
* Disable DPLL automatic idle control. No return value.
*/
static void <API key>(struct clk *clk)
{
const struct dpll_data *dd;
u32 v;
if (!clk || !clk->dpll_data)
return;
dd = clk->dpll_data;
v = cm_read_mod_reg(clk->prcm_mod, dd->autoidle_reg);
v &= ~dd->autoidle_mask;
v |= <API key> << __ffs(dd->autoidle_mask);
cm_write_mod_reg(v, clk->prcm_mod, dd->autoidle_reg);
}
/* Clock control for DPLL outputs */
/**
* <API key> - recalculate DPLL X2 output virtual clock rate
* @clk: DPLL output struct clk
* @parent_rate: rate of the parent clock of @clk
* @rate_storage: flag indicating whether current or temporary rate is changing
*
* Using parent clock DPLL data, look up DPLL state. If locked, set our
* rate to the dpll_clk * 2; otherwise, just use dpll_clk.
*/
static void <API key>(struct clk *clk, unsigned long parent_rate,
u8 rate_storage)
{
const struct dpll_data *dd;
u32 v;
unsigned long rate;
struct clk *pclk;
/* Walk up the parents of clk, looking for a DPLL */
pclk = clk->parent;
while (pclk && !pclk->dpll_data)
pclk = pclk->parent;
/* clk does not have a DPLL as a parent? */
WARN_ON(!pclk);
dd = pclk->dpll_data;
WARN_ON(!dd->enable_mask);
rate = parent_rate;
v = cm_read_mod_reg(pclk->prcm_mod, dd->control_reg) & dd->enable_mask;
v >>= __ffs(dd->enable_mask);
if (v == <API key> && (!dd->jtype))
rate *= 2;
if (rate_storage == CURRENT_RATE)
clk->rate = rate;
else if (rate_storage == TEMP_RATE)
clk->temp_rate = rate;
}
/* Common clock code */
/*
* As it is structured now, this will prevent an OMAP2/3 multiboot
* kernel from compiling. This will need further attention.
*/
#if defined(CONFIG_ARCH_OMAP3)
#ifdef CONFIG_CPU_FREQ
static struct <API key> freq_table[VDD1_OPP6+1];
void <API key>(struct <API key> **table)
{
struct omap_opp *prcm;
int i = 0;
if (!mpu_opps)
return;
prcm = mpu_opps + MAX_VDD1_OPP;
for (; prcm->rate; prcm
freq_table[i].index = i;
freq_table[i].frequency = prcm->rate / 1000;
i++;
}
if (i == 0) {
printk(KERN_WARNING "%s: failed to initialize frequency \
table\n",
__func__);
return;
}
freq_table[i].index = i;
freq_table[i].frequency = CPUFREQ_TABLE_END;
*table = &freq_table[0];
}
#endif
static struct clk_functions omap2_clk_functions = {
.clk_register = omap2_clk_register,
.clk_enable = omap2_clk_enable,
.clk_disable = omap2_clk_disable,
.clk_round_rate = <API key>,
.<API key> = <API key>,
.clk_set_rate = omap2_clk_set_rate,
.clk_set_parent = <API key>,
.clk_get_parent = <API key>,
.clk_disable_unused = <API key>,
#ifdef CONFIG_CPU_FREQ
.<API key> = <API key>,
#endif
};
/*
* Set clocks for bypass mode for reboot to work.
*/
void <API key>(void)
{
int err = 0;
/* REVISIT: Not ready for 343x */
#if 0
u32 rate;
if (vclk == NULL || sclk == NULL)
return;
rate = clk_get_rate(sclk);
clk_set_rate(vclk, rate);
#endif
/*
* PRCM on OMAP3 will drive SYS_OFFMODE low during DPLL3 warm reset.
* This causes Gaia sleep script to execute, usually killing VDD1 and
* VDD2 while code is running. WA is to disable the sleep script
* before warm reset.
*/
#ifdef <API key>
err = <API key>(TRITON_SLEEP_SCRIPT);
if (err)
pr_err("twl4030: error trying to disable sleep script!\n");
#endif
}
void omap3_lock_dpll5(void)
{
struct clk *dpll5_clk;
struct clk *dpll5_m2_clk;
dpll5_clk = clk_get(NULL, "dpll5_ck");
clk_set_rate(dpll5_clk, 120000000);
clk_enable(dpll5_clk);
/* Enable autoidle to allow it to enter low power bypass */
<API key>(dpll5_clk);
/* Program dpll5_m2_clk divider for no division */
dpll5_m2_clk = clk_get(NULL, "dpll5_m2_ck");
clk_enable(dpll5_m2_clk);
clk_set_rate(dpll5_m2_clk, 120000000);
return;
}
/* REVISIT: Move this init stuff out into clock.c */
/*
* Switch the MPU rate if specified on cmdline.
* We cannot do this early until cmdline is parsed.
*/
static int __init omap2_clk_arch_init(void)
{
if (!mpurate)
return -EINVAL;
/* REVISIT: not yet ready for 343x */
#if 0
if (clk_set_rate(&virt_prcm_set, mpurate))
printk(KERN_ERR "Could not find matching MPU rate\n");
#endif
<API key>();
printk(KERN_INFO "Switched to new clocking rate (Crystal/DPLL3/MPU): "
"%ld.%01ld/%ld/%ld MHz\n",
(osc_sys_ck.rate / 1000000), (osc_sys_ck.rate / 100000) % 10,
(core_ck.rate / 1000000), (dpll1_fck.rate / 1000000)) ;
return 0;
}
arch_initcall(omap2_clk_arch_init);
int __init omap2_clk_init(void)
{
/* struct prcm_config *prcm; */
struct clk **clkp;
/* u32 clkrate; */
u32 cpu_clkflg;
/* REVISIT: Ultimately this will be used for multiboot */
#if 0
if (cpu_is_omap242x()) {
cpu_mask = RATE_IN_242X;
cpu_clkflg = CLOCK_IN_OMAP242X;
clkp = onchip_24xx_clks;
} else if (cpu_is_omap2430()) {
cpu_mask = RATE_IN_243X;
cpu_clkflg = CLOCK_IN_OMAP243X;
clkp = onchip_24xx_clks;
}
#endif
if (cpu_is_omap34xx()) {
cpu_mask = RATE_IN_343X;
cpu_clkflg = CLOCK_IN_OMAP343X;
clkp = onchip_34xx_clks;
/*
* Update this if there are further clock changes between ES2
* and production parts
*/
if (omap_rev() == OMAP3430_REV_ES1_0) {
/* No 3430ES1-only rates exist, so no RATE_IN_3430ES1 */
cpu_clkflg |= <API key>;
} else {
cpu_mask |= RATE_IN_3430ES2;
cpu_clkflg |= <API key>;
}
if (cpu_is_omap3630()) {
dpll4_ck.dpll_data->jtype = 1;
dpll4_dd.mult_mask =
<API key>;
dpll4_dd.dco_sel_mask =
<API key>;
dpll4_dd.sd_div_mask =
<API key>;
dpll3_m3x2_ck.enable =
&<API key>;
dpll4_m2x2_ck.enable =
&<API key>;
dpll4_m3x2_ck.enable =
&<API key>;
dpll4_m4x2_ck.enable =
&<API key>;
dpll4_m5x2_ck.enable =
&<API key>;
dpll4_m6x2_ck.enable =
&<API key>;
cpu_clkflg |= CLOCK_IN_OMAP363X;
cpu_mask |= RATE_IN_363X;
omap_96m_alwon_fck.parent = &omap_192m_alwon_ck;
omap_96m_alwon_fck.init = &<API key>;
omap_96m_alwon_fck.clksel_reg = CM_CLKSEL;
omap_96m_alwon_fck.prcm_mod = CORE_MOD;
omap_96m_alwon_fck.clksel_mask =
<API key>;
omap_96m_alwon_fck.clksel = <API key>;
omap_96m_alwon_fck.recalc = &omap2_clksel_recalc;
omap_96m_alwon_fck.set_rate = &<API key>;
}
}
clk_init(&omap2_clk_functions);
for (clkp = onchip_34xx_clks;
clkp < onchip_34xx_clks + ARRAY_SIZE(onchip_34xx_clks);
clkp++) {
if (cpu_is_omap3630()) {
if ((*clkp)->flags & CLOCK_IN_OMAP363X)
(*clkp)->clksel_mask = (*clkp)->clksel_mask2;
}
if ((*clkp)->flags & cpu_clkflg)
clk_register(*clkp);
}
/* REVISIT: Not yet ready for OMAP3 */
#if 0
/* Check the MPU rate set by bootloader */
clkrate = <API key>(&dpll_ck);
for (prcm = rate_table; prcm->mpu_speed; prcm++) {
if (!(prcm->flags & cpu_mask))
continue;
if (prcm->xtal_speed != sys_ck.rate)
continue;
if (prcm->dpll_speed <= clkrate)
break;
}
curr_prcm_set = prcm;
#endif
<API key>();
printk(KERN_INFO "Clocking rate (Crystal/DPLL/ARM core): "
"%ld.%01ld/%ld/%ld MHz\n",
(osc_sys_ck.rate / 1000000), (osc_sys_ck.rate / 100000) % 10,
(core_ck.rate / 1000000), (arm_fck.rate / 1000000));
/*
* Only enable those clocks we will need, let the drivers
* enable other clocks as necessary
*/
<API key>();
/*
* Lock DPLL5 and put it in autoidle.
*/
if (omap_rev() >= OMAP3430_REV_ES2_0)
omap3_lock_dpll5();
return 0;
}
#endif /* CONFIG_ARCH_OMAP3 */ |
<?php
/**
* Varint type
* @author Nikolai Kordulla
*/
class <API key> extends <API key>
{
protected $wired_type = <API key>::WIRED_VARINT;
/**
* Parses the message for this type
*
* @param array
*/
public function ParseFromArray()
{
$this->value = $this->reader->next();
$this->clean();
}
/**
* Serializes type
*/
public function SerializeToString($rec=-1)
{
// first byte is length byte
$string = '';
if ($rec > -1)
{
$string .= $this->base128->set_value($rec << 3 | $this->wired_type);
}
$value = $this->base128->set_value($this->value);
$string .= $value;
return $string;
}
public function toJson($fieldName = "")
{
if ($fieldName == "")
return (int)$this->value;
else
return '"' . $fieldName . '":' . (int)$this->value;
}
} |
#ifndef <API key>
#define <API key>
#include "gc/g1/g1OopClosures.hpp"
#include "gc/g1/heapRegionManager.hpp"
#include "gc/shared/workgroup.hpp"
#include "utilities/globalDefinitions.hpp"
class G1CollectedHeap;
// Task to fixup self-forwarding pointers
// installed as a result of an evacuation failure.
class <API key>: public AbstractGangTask {
protected:
G1CollectedHeap* _g1h;
HeapRegionClaimer _hrclaimer;
public:
<API key>();
void work(uint worker_id);
};
#endif // <API key> |
/*
* linux/arch/arm/mach-sa1100/huw_webpanel.c
*
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/tty.h>
#include <asm/hardware.h>
#include <asm/mach-types.h>
#include <asm/setup.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/serial_sa1100.h>
#include "generic.h"
unsigned long BCR_value;
EXPORT_SYMBOL(BCR_value);
static void huw_lcd_power(int on)
{
if (on)
BCR_clear(BCR_TFT_NPWR);
else
BCR_set(BCR_TFT_NPWR);
}
static void huw_backlight_power(int on)
{
#error FIXME
if (on) {
BCR_set(BCR_CCFL_POW | BCR_PWM_BACKLIGHT);
set_current_state(<API key>);
schedule_task(200 * HZ / 1000);
BCR_set(BCR_TFT_ENA);
}
}
static int __init init_huw_cs3(void)
{
// here we can place some initcode
/**
memory information (JOR):
32 MByte - 256KByte bootloader (init at boot time) - 32 kByte save area
area size = 288 kByte (0x48000 Bytes)
**/
static struct map_desc <API key>[] __initdata = {
/* virtual physical length type */
{ 0xf0000000, 0xc1fb8000, 0x00048000, MT_DEVICE }, /* Parameter */
{ 0xf1000000, 0x18000000, 0x00100000, MT_DEVICE } /* Paules CS3, write only */
};
static void __init huw_webpanel_map_io(void)
{
sa1100_map_io();
iotable_init(<API key>, ARRAY_SIZE(<API key>));
<API key>(0, 3);
<API key>(1, 1);
}
MACHINE_START(HUW_WEBPANEL, "HuW-Webpanel")
MAINTAINER("Roman Jordan")
BOOT_MEM(0xc0000000, 0x80000000, 0xf8000000)
MAPIO(huw_webpanel_map_io)
INITIRQ(sa1100_init_irq)
INITTIME(sa1100_init_time)
MACHINE_END |
/*
* Internal event machinery for use by other parts of libxl
*/
#include <poll.h>
#include "libxl_internal.h"
//#define DEBUG 1
#ifdef DEBUG
# define LIBXL__DBG_LOG(ctx, args, ...) \
LIBXL__LOG((ctx), XTL_DEBUG, args, __VA_ARGS__)
#else
# define LIBXL__DBG_LOG(ctx, args, ...) ((void)0)
#endif
#define DBG(args, ...) LIBXL__DBG_LOG(CTX, args, __VA_ARGS__)
static libxl__ao *ao_nested_root(libxl__ao *ao);
static void ao__check_destroy(libxl_ctx *ctx, libxl__ao *ao);
/*
* The counter osevent_in_hook is used to ensure that the application
* honours the reentrancy restriction documented in libxl_event.h.
*
* The application's registration hooks should be called ONLY via
* these macros, with the ctx locked. Likewise all the "occurred"
* entrypoints from the application should assert(!in_hook);
*
* During the hook call - including while the arguments are being
* evaluated - ev->nexus is guaranteed to be valid and refer to the
* nexus which is being used for this event registration. The
* arguments should specify ev->nexus for the for_libxl argument and
* ev->nexus->for_app_reg (or a pointer to it) for for_app_reg.
*/
#define OSEVENT_HOOK_INTERN(retval, failedp, evkind, hookop, nexusop, ...) do { \
if (CTX->osevent_hooks) { \
CTX->osevent_in_hook++; \
<API key> *nexi = &CTX->hook_##evkind##_nexi_idle; \
osevent_hook_pre_##nexusop(gc, ev, nexi, &ev->nexus); \
retval CTX->osevent_hooks->evkind##_##hookop \
(CTX->osevent_user, __VA_ARGS__); \
if ((failedp)) \
<API key>##nexusop(gc, ev, nexi, &ev->nexus); \
CTX->osevent_in_hook
} \
} while (0)
#define OSEVENT_HOOK(evkind, hookop, nexusop, ...) ({ \
int osevent_hook_rc = 0; \
OSEVENT_HOOK_INTERN(osevent_hook_rc =, !!osevent_hook_rc, \
evkind, hookop, nexusop, __VA_ARGS__); \
osevent_hook_rc; \
})
#define OSEVENT_HOOK_VOID(evkind, hookop, nexusop, ...) \
OSEVENT_HOOK_INTERN(/* void */, 0, evkind, hookop, nexusop, __VA_ARGS__)
/*
* The application's calls to <API key>... may be
* indefinitely delayed with respect to the rest of the program (since
* they are not necessarily called with any lock held). So the
* for_libxl value we receive may be (almost) arbitrarily old. All we
* know is that it came from this ctx.
*
* Therefore we may not free the object referred to by any for_libxl
* value until we free the whole libxl_ctx. And if we reuse it we
* must be able to tell when an old use turns up, and discard the
* stale event.
*
* Thus we cannot use the ev directly as the for_libxl value - we need
* a layer of indirection.
*
* We do this by keeping a pool of <API key> structs,
* and use pointers to them as for_libxl values. In fact, there are
* two pools: one for fds and one for timeouts. This ensures that we
* don't risk a type error when we upcast nexus->ev. In each nexus
* the ev is either null or points to a valid libxl__ev_time or
* libxl__ev_fd, as applicable.
*
* We /do/ allow ourselves to reassociate an old nexus with a new ev
* as otherwise we would have to leak nexi. (This reassociation
* might, of course, be an old ev being reused for a new purpose so
* simply comparing the ev pointer is not sufficient.) Thus the
* <API key> functions need to check that the condition
* allegedly signalled by this event actually exists.
*
* The nexi and the lists are all protected by the ctx lock.
*/
struct <API key> {
void *ev;
void *for_app_reg;
LIBXL_SLIST_ENTRY(<API key>) next;
};
static void *<API key>(libxl_ctx *ctx,
<API key> *nexus /* pass void *for_libxl */)
{
return nexus->ev;
}
static void <API key>(libxl__gc *gc,
<API key> *nexi_idle,
<API key> *nexus)
{
nexus->ev = 0;
<API key>(nexi_idle, nexus, next);
}
static void <API key>(libxl__gc *gc, void *ev,
<API key> *nexi_idle,
<API key> **nexus_r)
{
<API key> *nexus = LIBXL_SLIST_FIRST(nexi_idle);
if (nexus) {
<API key>(nexi_idle, next);
} else {
nexus = libxl__zalloc(NOGC, sizeof(*nexus));
}
nexus->ev = ev;
*nexus_r = nexus;
}
static void <API key>(libxl__gc *gc, void *ev,
<API key> *nexi_idle,
<API key> **nexus)
{
<API key>(gc, nexi_idle, *nexus);
}
static void <API key>(libxl__gc *gc, void *ev,
<API key> *nexi_idle,
<API key> **nexus)
{
<API key>(gc, nexi_idle, *nexus);
}
static void <API key>(libxl__gc *gc, void *ev,
<API key> *nexi_idle,
<API key> **nexus)
{
abort();
}
static void <API key>(libxl__gc *gc, void *ev,
<API key> *nexi_idle,
<API key> **nexus) { }
static void <API key>(libxl__gc *gc, void *ev,
<API key> *nexi_idle,
<API key> **nexus) { }
/*
* fd events
*/
int <API key>(libxl__gc *gc, libxl__ev_fd *ev,
<API key> *func,
int fd, short events)
{
int rc;
assert(fd >= 0);
CTX_LOCK;
DBG("ev_fd=%p register fd=%d events=%x", ev, fd, events);
rc = OSEVENT_HOOK(fd,register, alloc, fd, &ev->nexus->for_app_reg,
events, ev->nexus);
if (rc) goto out;
ev->fd = fd;
ev->events = events;
ev->func = func;
<API key>(&CTX->efds, ev, entry);
rc = 0;
out:
CTX_UNLOCK;
return rc;
}
int libxl__ev_fd_modify(libxl__gc *gc, libxl__ev_fd *ev, short events)
{
int rc;
CTX_LOCK;
assert(<API key>(ev));
DBG("ev_fd=%p modify fd=%d events=%x", ev, ev->fd, events);
rc = OSEVENT_HOOK(fd,modify, noop, ev->fd, &ev->nexus->for_app_reg, events);
if (rc) goto out;
ev->events = events;
rc = 0;
out:
CTX_UNLOCK;
return rc;
}
void <API key>(libxl__gc *gc, libxl__ev_fd *ev)
{
CTX_LOCK;
libxl__poller *poller;
if (!<API key>(ev)) {
DBG("ev_fd=%p deregister unregistered",ev);
goto out;
}
DBG("ev_fd=%p deregister fd=%d", ev, ev->fd);
OSEVENT_HOOK_VOID(fd,deregister, release, ev->fd, ev->nexus->for_app_reg);
LIBXL_LIST_REMOVE(ev, entry);
ev->fd = -1;
LIBXL_LIST_FOREACH(poller, &CTX->pollers_fds_changed, fds_changed_entry)
poller->fds_changed = 1;
out:
CTX_UNLOCK;
}
short <API key>(libxl__egc *egc, int fd, short events) {
struct pollfd check;
int r;
for (;;) {
check.fd = fd;
check.events = events;
r = poll(&check, 1, 0);
DBG("poll recheck fd=%d r=%d revents=%#x", fd, r, check.revents);
if (!r)
break;
if (r==1)
break;
assert(r<0);
if (errno != EINTR) {
<API key>(egc, "failed poll to check for fd", errno, 0);
return 0;
}
}
assert(!!r == !!check.revents);
return check.revents;
}
/*
* timeouts
*/
int libxl__gettimeofday(libxl__gc *gc, struct timeval *now_r)
{
int rc = gettimeofday(now_r, 0);
if (rc) {
LIBXL__LOG_ERRNO(CTX, LIBXL__LOG_ERROR, "gettimeofday failed");
return ERROR_FAIL;
}
return 0;
}
static int time_rel_to_abs(libxl__gc *gc, int ms, struct timeval *abs_out)
{
int rc;
struct timeval additional = {
.tv_sec = ms / 1000,
.tv_usec = (ms % 1000) * 1000
};
struct timeval now;
rc = libxl__gettimeofday(gc, &now);
if (rc) return rc;
timeradd(&now, &additional, abs_out);
return 0;
}
static int <API key>(libxl__gc *gc, libxl__ev_time *ev,
struct timeval absolute)
{
int rc;
libxl__ev_time *evsearch;
rc = OSEVENT_HOOK(timeout,register, alloc, &ev->nexus->for_app_reg,
absolute, ev->nexus);
if (rc) return rc;
ev->infinite = 0;
ev->abs = absolute;
<API key>(&CTX->etimes, entry, ev, evsearch, /*empty*/,
timercmp(&ev->abs, &evsearch->abs, >));
return 0;
}
static void time_deregister(libxl__gc *gc, libxl__ev_time *ev)
{
<API key>(&ev->abrt);
if (!ev->infinite) {
struct timeval right_away = { 0, 0 };
if (ev->nexus) /* only set if app provided hooks */
ev->nexus->ev = 0;
OSEVENT_HOOK_VOID(timeout,modify,
noop /* release nexus in _occurred_ */,
&ev->nexus->for_app_reg, right_away);
LIBXL_TAILQ_REMOVE(&CTX->etimes, ev, entry);
}
}
static void time_done_debug(libxl__gc *gc, const char *func,
libxl__ev_time *ev, int rc)
{
#ifdef DEBUG
libxl__log(CTX, XTL_DEBUG, -1,__FILE__,0,func,
"ev_time=%p done rc=%d .func=%p infinite=%d abs=%lu.%06lu",
ev, rc, ev->func, ev->infinite,
(unsigned long)ev->abs.tv_sec, (unsigned long)ev->abs.tv_usec);
#endif
}
static void time_aborted(libxl__egc *egc, libxl__ao_abortable *abrt, int rc)
{
libxl__ev_time *ev = CONTAINER_OF(abrt, *ev, abrt);
EGC_GC;
time_deregister(gc, ev);
DBG("ev_time=%p aborted", ev);
ev->func(egc, ev, &ev->abs, rc);
}
static int <API key>(libxl__ao *ao, libxl__ev_time *ev)
{
ev->abrt.ao = ao;
ev->abrt.callback = time_aborted;
return <API key>(&ev->abrt);
}
int <API key>(libxl__ao *ao, libxl__ev_time *ev,
<API key> *func,
struct timeval absolute)
{
AO_GC;
int rc;
CTX_LOCK;
DBG("ev_time=%p register abs=%lu.%06lu",
ev, (unsigned long)absolute.tv_sec, (unsigned long)absolute.tv_usec);
rc = <API key>(ao, ev);
if (rc) goto out;
rc = <API key>(gc, ev, absolute);
if (rc) goto out;
ev->func = func;
rc = 0;
out:
<API key>(&ev->abrt);
time_done_debug(gc,__func__,ev,rc);
CTX_UNLOCK;
return rc;
}
int <API key>(libxl__ao *ao, libxl__ev_time *ev,
<API key> *func,
int milliseconds /* as for poll(2) */)
{
AO_GC;
struct timeval absolute;
int rc;
CTX_LOCK;
DBG("ev_time=%p register ms=%d", ev, milliseconds);
rc = <API key>(ao, ev);
if (rc) goto out;
if (milliseconds < 0) {
ev->infinite = 1;
} else {
rc = time_rel_to_abs(gc, milliseconds, &absolute);
if (rc) goto out;
rc = <API key>(gc, ev, absolute);
if (rc) goto out;
}
ev->func = func;
rc = 0;
out:
if (!<API key>(ev))
<API key>(&ev->abrt);
time_done_debug(gc,__func__,ev,rc);
CTX_UNLOCK;
return rc;
}
void <API key>(libxl__gc *gc, libxl__ev_time *ev)
{
CTX_LOCK;
DBG("ev_time=%p deregister", ev);
if (!<API key>(ev))
goto out;
time_deregister(gc, ev);
ev->func = 0;
out:
time_done_debug(gc,__func__,ev,0);
CTX_UNLOCK;
return;
}
static void time_occurs(libxl__egc *egc, libxl__ev_time *etime, int rc)
{
DBG("ev_time=%p occurs abs=%lu.%06lu",
etime, (unsigned long)etime->abs.tv_sec,
(unsigned long)etime->abs.tv_usec);
<API key> *func = etime->func;
etime->func = 0;
func(egc, etime, &etime->abs, rc);
}
/*
* xenstore watches
*/
libxl__ev_xswatch *<API key>(libxl__gc *gc, int slotnum)
{
<API key> *slot = &CTX->watch_slots[slotnum];
<API key> *slotcontents = LIBXL_SLIST_NEXT(slot, empty);
if (slotcontents == NULL ||
((uintptr_t)slotcontents >= (uintptr_t)CTX->watch_slots &&
(uintptr_t)slotcontents < (uintptr_t)(CTX->watch_slots +
CTX->watch_nslots)))
/* An empty slot has either a NULL pointer (end of the
* free list), or a pointer to another entry in the array.
* So we can do a bounds check to distinguish empty from
* full slots.
*/
return NULL;
/* see comment near <API key> definition */
return (void*)slotcontents;
}
static void <API key>(<API key> *slot,
libxl__ev_xswatch *w)
{
/* we look a bit behind the curtain of LIBXL_SLIST, to explicitly
* assign to the pointer that's the next link. See the comment
* by the definition of <API key> */
slot->empty.sle_next = (void*)w;
}
static void watchfd_callback(libxl__egc *egc, libxl__ev_fd *ev,
int fd, short events, short revents)
{
EGC_GC;
if (revents & (POLLERR|POLLHUP))
<API key>(egc, "unexpected poll event on watch fd", 0, 0);
for (;;) {
char **event = xs_check_watch(CTX->xsh);
if (!event) {
if (errno == EAGAIN) break;
if (errno == EINTR) continue;
<API key>(egc, "cannot check/read watches", errno, 0);
return;
}
const char *epath = event[0];
const char *token = event[1];
int slotnum;
uint32_t counterval;
int rc = sscanf(token, "%d/%"SCNx32, &slotnum, &counterval);
if (rc != 2) {
LIBXL__LOG(CTX, LIBXL__LOG_ERROR,
"watch epath=%s token=%s: failed to parse token",
epath, token);
/* oh well */
goto ignore;
}
if (slotnum < 0 || slotnum >= CTX->watch_nslots) {
/* perhaps in the future we will make the watchslots array shrink */
LIBXL__LOG(CTX, LIBXL__LOG_DEBUG, "watch epath=%s token=%s:"
" slotnum %d out of range [0,%d>",
epath, token, slotnum, CTX->watch_nslots);
goto ignore;
}
libxl__ev_xswatch *w = <API key>(gc, slotnum);
if (!w) {
LIBXL__LOG(CTX, LIBXL__LOG_DEBUG,
"watch epath=%s token=%s: empty slot",
epath, token);
goto ignore;
}
if (w->counterval != counterval) {
LOG(DEBUG, "watch w=%p epath=%s token=%s: counter != %"PRIx32,
w, epath, token, w->counterval);
goto ignore;
}
/* Now it's possible, though unlikely, that this was an event
* from a previous use of the same slot with the same counterval.
*
* In that case either:
* - the event path is a child of the watch path, in
* which case this watch would really have generated this
* event if it had been registered soon enough and we are
* OK to give this possibly-spurious event to the caller; or
* - it is not, in which case we must suppress it as the
* caller should not see events for unrelated paths.
*
* See also docs/misc/xenstore.txt.
*/
if (!xs_path_is_subpath(w->path, epath)) {
LOG(DEBUG, "watch w=%p wpath=%s token=%s: unexpected epath=%s",
w, w->path, token, epath);
goto ignore;
}
/* At last, we have checked everything! */
LOG(DEBUG, "watch w=%p wpath=%s token=%s: event epath=%s",
w, w->path, token, epath);
w->callback(egc, w, w->path, epath);
ignore:
free(event);
}
}
static char *watch_token(libxl__gc *gc, int slotnum, uint32_t counterval)
{
return libxl__sprintf(gc, "%d/%"PRIx32, slotnum, counterval);
}
static void <API key>(libxl__gc *gc)
{
assert(CTX->nwatches>=0);
if (!CTX->nwatches)
<API key>(gc, &CTX->watch_efd);
}
int <API key>(libxl__gc *gc, libxl__ev_xswatch *w,
<API key> *func,
const char *path /* copied */)
{
<API key> *use = NULL;
char *path_copy = NULL;
int rc;
CTX_LOCK;
if (!<API key>(&CTX->watch_efd)) {
rc = <API key>(gc, &CTX->watch_efd, watchfd_callback,
xs_fileno(CTX->xsh), POLLIN);
if (rc) goto out_rc;
}
if (LIBXL_SLIST_EMPTY(&CTX->watch_freeslots)) {
/* Free list is empty so there is not in fact a linked
* free list in the array and we can safely realloc it */
int newarraysize = (CTX->watch_nslots + 1) << 2;
int i;
<API key> *newarray =
libxl__realloc(NOGC,
CTX->watch_slots, sizeof(*newarray) * newarraysize);
if (!newarray) goto out_nomem;
for (i = CTX->watch_nslots; i < newarraysize; i++)
<API key>(&CTX->watch_freeslots,
&newarray[i], empty);
CTX->watch_slots = newarray;
CTX->watch_nslots = newarraysize;
}
use = LIBXL_SLIST_FIRST(&CTX->watch_freeslots);
assert(use);
<API key>(&CTX->watch_freeslots, empty);
path_copy = strdup(path);
if (!path_copy) goto out_nomem;
int slotnum = use - CTX->watch_slots;
w->counterval = CTX->watch_counter++;
const char *token = watch_token(gc, slotnum, w->counterval);
LOG(DEBUG, "watch w=%p wpath=%s token=%s: register slotnum=%d",
w, path, token, slotnum);
if (!xs_watch(CTX->xsh, path, token)) {
LIBXL__LOG_ERRNOVAL(CTX, LIBXL__LOG_ERROR, errno,
"create watch for path %s", path);
rc = ERROR_FAIL;
goto out_rc;
}
w->slotnum = slotnum;
w->path = path_copy;
w->callback = func;
CTX->nwatches++;
<API key>(use, w);
CTX_UNLOCK;
return 0;
out_nomem:
rc = ERROR_NOMEM;
out_rc:
if (use)
<API key>(&CTX->watch_freeslots, use, empty);
free(path_copy);
<API key>(gc);
CTX_UNLOCK;
return rc;
}
void <API key>(libxl__gc *gc, libxl__ev_xswatch *w)
{
CTX_LOCK;
if (w->slotnum >= 0) {
const char *token = watch_token(gc, w->slotnum, w->counterval);
LOG(DEBUG, "watch w=%p wpath=%s token=%s: deregister slotnum=%d",
w, w->path, token, w->slotnum);
if (!xs_unwatch(CTX->xsh, w->path, token))
/* Oh well, we will just get watch events forever more
* and ignore them. But we should complain to the log. */
LIBXL__LOG_ERRNOVAL(CTX, LIBXL__LOG_ERROR, errno,
"remove watch for path %s", w->path);
<API key> *slot = &CTX->watch_slots[w->slotnum];
<API key>(&CTX->watch_freeslots, slot, empty);
w->slotnum = -1;
CTX->nwatches
<API key>(gc);
} else {
LOG(DEBUG, "watch w=%p: deregister unregistered", w);
}
free(w->path);
w->path = NULL;
CTX_UNLOCK;
}
/*
* evtchn
*/
static int <API key>(libxl__egc *egc, int revents)
{
EGC_GC;
if (revents & ~POLLIN) {
LOG(ERROR, "unexpected poll event on event channel fd: %x", revents);
<API key>(egc,
"unexpected poll event on event channel fd", 0, 0);
<API key>(gc, &CTX->evtchn_efd);
return ERROR_FAIL;
}
assert(revents & POLLIN);
return 0;
}
static void evtchn_fd_callback(libxl__egc *egc, libxl__ev_fd *ev,
int fd, short events, short revents)
{
EGC_GC;
libxl__ev_evtchn *evev;
int rc;
<API key> port;
rc = <API key>(egc, revents);
if (rc) return;
for (;;) {
/* Check the fd again. The incoming revent may no longer be
* true, because the libxl ctx lock has not necessarily been
* held continuously since someone noticed the fd. Normally
* this wouldn't be a problem but evtchn devices don't always
* honour O_NONBLOCK (see xenctrl.h). */
revents = <API key>(egc,fd,POLLIN);
if (!revents)
break;
rc = <API key>(egc, revents);
if (rc) return;
/* OK, that's that workaround done. We can actually check for
* work for us to do: */
port = xc_evtchn_pending(CTX->xce);
if (port < 0) {
if (errno == EAGAIN)
break;
<API key>(egc,
"unexpected failure fetching occurring event port number from evtchn",
errno, 0);
return;
}
LIBXL_LIST_FOREACH(evev, &CTX->evtchns_waiting, entry)
if (port == evev->port)
goto found;
/* not found */
DBG("ev_evtchn port=%d no-one cared", port);
continue;
found:
DBG("ev_evtchn=%p port=%d signaled", evev, port);
evev->waiting = 0;
LIBXL_LIST_REMOVE(evev, entry);
evev->callback(egc, evev);
}
}
int <API key>(libxl__gc *gc) {
xc_evtchn *xce;
int rc, fd;
if (CTX->xce)
return 0;
xce = xc_evtchn_open(CTX->lg, 0);
if (!xce) {
LOGE(ERROR,"cannot open libxc evtchn handle");
rc = ERROR_FAIL;
goto out;
}
fd = xc_evtchn_fd(xce);
assert(fd >= 0);
rc = <API key>(CTX, fd, 1);
if (rc) goto out;
CTX->xce = xce;
return 0;
out:
xc_evtchn_close(xce);
return rc;
}
static void <API key>(libxl__gc *gc)
{
if (CTX->xce && LIBXL_LIST_EMPTY(&CTX->evtchns_waiting))
<API key>(gc, &CTX->evtchn_efd);
}
int <API key>(libxl__gc *gc, libxl__ev_evtchn *evev)
{
int r, rc;
DBG("ev_evtchn=%p port=%d wait (was waiting=%d)",
evev, evev->port, evev->waiting);
rc = <API key>(gc);
if (rc) goto out;
if (!<API key>(&CTX->evtchn_efd)) {
rc = <API key>(gc, &CTX->evtchn_efd, evtchn_fd_callback,
xc_evtchn_fd(CTX->xce), POLLIN);
if (rc) goto out;
}
if (evev->waiting)
return 0;
r = xc_evtchn_unmask(CTX->xce, evev->port);
if (r) {
LOGE(ERROR,"cannot unmask event channel %d",evev->port);
rc = ERROR_FAIL;
goto out;
}
evev->waiting = 1;
<API key>(&CTX->evtchns_waiting, evev, entry);
return 0;
out:
<API key>(gc);
return rc;
}
void <API key>(libxl__gc *gc, libxl__ev_evtchn *evev)
{
DBG("ev_evtchn=%p port=%d cancel (was waiting=%d)",
evev, evev->port, evev->waiting);
if (!evev->waiting)
return;
evev->waiting = 0;
LIBXL_LIST_REMOVE(evev, entry);
<API key>(gc);
}
/*
* waiting for device state
*/
static void devstate_callback(libxl__egc *egc, libxl__xswait_state *xsw,
int rc, const char *sstate)
{
EGC_GC;
libxl__ev_devstate *ds = CONTAINER_OF(xsw, *ds, w);
if (rc) {
if (rc == ERROR_TIMEDOUT)
LIBXL__LOG(CTX, LIBXL__LOG_DEBUG, "backend %s wanted state %d "
" timed out", ds->w.path, ds->wanted);
goto out;
}
if (!sstate) {
LIBXL__LOG(CTX, LIBXL__LOG_DEBUG, "backend %s wanted state %d"
" but it was removed", ds->w.path, ds->wanted);
rc = ERROR_INVAL;
goto out;
}
int got = atoi(sstate);
if (got == ds->wanted) {
LIBXL__LOG(CTX, LIBXL__LOG_DEBUG, "backend %s wanted state %d ok",
ds->w.path, ds->wanted);
rc = 0;
} else {
LIBXL__LOG(CTX, LIBXL__LOG_DEBUG, "backend %s wanted state %d"
" still waiting state %d", ds->w.path, ds->wanted, got);
return;
}
out:
<API key>(gc, ds);
ds->callback(egc, ds, rc);
}
int <API key>(libxl__ao *ao, libxl__ev_devstate *ds,
<API key> cb,
const char *state_path, int state, int milliseconds)
{
AO_GC;
int rc;
libxl__xswait_init(&ds->w);
ds->wanted = state;
ds->callback = cb;
ds->w.ao = ao;
ds->w.what = GCSPRINTF("backend %s (hoping for state change to %d)",
state_path, state);
ds->w.path = state_path;
ds->w.timeout_ms = milliseconds;
ds->w.callback = devstate_callback;
rc = libxl__xswait_start(gc, &ds->w);
if (rc) goto out;
return 0;
out:
<API key>(gc, ds);
return rc;
}
/*
* domain death/destruction
*/
/*
* We use a xenstore watch on the domain's path, rather than using an
* @releaseDomain watch and asking the hypervisor. This is simpler
* because turning @releaseDomain into domain-specific information is
* complicated.
*
* It is also sufficient for our callers, which are generally trying
* to do cleanup of their own execution state on domain death, for the
* following reason: if the domain is destroyed then either (a) the
* entries in xenstore have already been deleted, in which case the
* test here works or (b) they have not in which case something has
* gone very badly wrong and we are going to leak those xenstore
* entries, in which case trying to avoid leaking other stuff is
* futile.
*/
void <API key>(<API key> *dc)
{
<API key>(&dc->abrt);
<API key>(&dc->watch);
}
void <API key>(libxl__gc *gc, <API key> *dc)
{
<API key>(&dc->abrt);
<API key>(gc,&dc->watch);
}
static void <API key>(libxl__egc *egc, libxl__ev_xswatch *w,
const char *watch_path, const char *event_path)
{
<API key> *dc = CONTAINER_OF(w, *dc, watch);
EGC_GC;
const char *p = libxl__xs_read(gc, XBT_NULL, watch_path);
if (p) return;
<API key>(gc,dc);
if (errno!=ENOENT) {
<API key>(egc,"failed to read xenstore"
" for domain detach check", errno, 0);
return;
}
LOG(ERROR,"%s: domain %"PRIu32" removed (%s no longer in xenstore)",
dc->what, dc->domid, watch_path);
dc->callback(egc, dc, <API key>);
}
static void <API key>(libxl__egc *egc,
libxl__ao_abortable *abrt,
int rc)
{
<API key> *dc = CONTAINER_OF(abrt, *dc, abrt);
EGC_GC;
<API key>(gc,dc);
dc->callback(egc, dc, rc);
}
int <API key>(libxl__ao *ao,
<API key> *dc)
{
AO_GC;
int rc;
const char *path = GCSPRINTF("/local/domain/%"PRIu32, dc->domid);
<API key>(dc);
dc->abrt.ao = ao;
dc->abrt.callback = <API key>;
rc = <API key>(&dc->abrt);
if (rc) goto out;
rc = <API key>(gc, &dc->watch,
<API key>, path);
if (rc) goto out;
return 0;
out:
<API key>(gc,dc);
return rc;
}
/*
* osevent poll
*/
static int beforepoll_internal(libxl__gc *gc, libxl__poller *poller,
int *nfds_io, struct pollfd *fds,
int *timeout_upd, struct timeval now)
{
libxl__ev_fd *efd;
int rc;
/*
* We need to look at the fds we want twice: firstly, to count
* them so we can make the rindex array big enough, and secondly
* to actually fill the arrays in.
*
* To ensure correctness and avoid repeating the logic for
* deciding which fds are relevant, we define a macro
* REQUIRE_FDS( BODY )
* which calls
* do{
* int req_fd;
* int req_events;
* BODY;
* }while(0)
* for each fd with a nonzero events. This is invoked twice.
*
* The definition of REQUIRE_FDS is simplified with the helper
* macro
* void REQUIRE_FD(int req_fd, int req_events, BODY);
*/
#define REQUIRE_FDS(BODY) do{ \
\
LIBXL_LIST_FOREACH(efd, &CTX->efds, entry) \
REQUIRE_FD(efd->fd, efd->events, BODY); \
\
REQUIRE_FD(poller->wakeup_pipe[0], POLLIN, BODY); \
\
}while(0)
#define REQUIRE_FD(req_fd_, req_events_, BODY) do{ \
int req_events = (req_events_); \
int req_fd = (req_fd_); \
if (req_events) { \
BODY; \
} \
}while(0)
/*
* In order to be able to efficiently find the libxl__ev_fd for a
* struct poll during _afterpoll, we maintain a shadow data
* structure in CTX->fd_rindices: each fd corresponds to a slot in
* fd_rindices, and each element in the rindices is three indices
* into the fd array (for POLLIN, POLLPRI and POLLOUT).
*/
if (*nfds_io) {
/*
* As an optimisation, we don't touch fd_rindex
* if *nfds_io is zero on entry, since in that case the
* caller just wanted to know how big an array to give us.
*
* If !*nfds_io, the unconditional parts below are guaranteed
* not to mess with fd_rindex.
*/
int maxfd = 0;
REQUIRE_FDS({
if (req_fd >= maxfd)
maxfd = req_fd + 1;
});
/* make sure our array is as big as *nfds_io */
if (poller->fd_rindices_allocd < maxfd) {
assert(ARRAY_SIZE_OK(poller->fd_rindices, maxfd));
poller->fd_rindices =
libxl__realloc(NOGC, poller->fd_rindices,
maxfd * sizeof(*poller->fd_rindices));
memset(poller->fd_rindices + poller->fd_rindices_allocd,
0,
(maxfd - poller->fd_rindices_allocd)
* sizeof(*poller->fd_rindices));
poller->fd_rindices_allocd = maxfd;
}
}
int used = 0;
REQUIRE_FDS({
if (used < *nfds_io) {
fds[used].fd = req_fd;
fds[used].events = req_events;
fds[used].revents = 0;
assert(req_fd < poller->fd_rindices_allocd);
if (req_events & POLLIN) poller->fd_rindices[req_fd][0] = used;
if (req_events & POLLPRI) poller->fd_rindices[req_fd][1] = used;
if (req_events & POLLOUT) poller->fd_rindices[req_fd][2] = used;
}
used++;
});
rc = used <= *nfds_io ? 0 : ERROR_BUFFERFULL;
*nfds_io = used;
poller->fds_changed = 0;
libxl__ev_time *etime = LIBXL_TAILQ_FIRST(&CTX->etimes);
if (etime) {
int our_timeout;
struct timeval rel;
static struct timeval zero;
timersub(&etime->abs, &now, &rel);
if (timercmp(&rel, &zero, <)) {
our_timeout = 0;
} else if (rel.tv_sec >= 2000000) {
our_timeout = 2000000000;
} else {
our_timeout = rel.tv_sec * 1000 + (rel.tv_usec + 999) / 1000;
}
if (*timeout_upd < 0 || our_timeout < *timeout_upd)
*timeout_upd = our_timeout;
}
return rc;
}
int <API key>(libxl_ctx *ctx, int *nfds_io,
struct pollfd *fds, int *timeout_upd,
struct timeval now)
{
EGC_INIT(ctx);
CTX_LOCK;
int rc = beforepoll_internal(gc, ctx->poller_app,
nfds_io, fds, timeout_upd, now);
CTX_UNLOCK;
EGC_FREE;
return rc;
}
static int afterpoll_check_fd(libxl__poller *poller,
const struct pollfd *fds, int nfds,
int fd, int events)
/* Returns mask of events which were requested and occurred. Will
* return nonzero only once for each (poller,fd,events)
* combination, until the next beforepoll. If events from
* different combinations overlap, between one such combination
* and all distinct combinations will produce nonzero returns. */
{
if (fd >= poller->fd_rindices_allocd)
/* added after we went into poll, have to try again */
return 0;
events |= POLLERR | POLLHUP;
int i, revents = 0;
for (i=0; i<3; i++) {
int *slotp = &poller->fd_rindices[fd][i];
int slot = *slotp;
if (slot >= nfds)
/* stale slot entry (again, added afterwards), */
/* or slot for which we have already returned nonzero */
continue;
if (fds[slot].fd != fd)
/* again, stale slot entry */
continue;
assert(poller->fds_changed || !(fds[slot].revents & POLLNVAL));
/* we mask in case requested events have changed */
int slot_revents = fds[slot].revents & events;
if (!slot_revents)
/* this slot is for a different set of events */
continue;
revents |= slot_revents;
*slotp = INT_MAX; /* so that next time we'll see slot >= nfds */
}
return revents;
}
static void fd_occurs(libxl__egc *egc, libxl__ev_fd *efd, short revents_ign)
{
short revents_current = <API key>(egc, efd->fd, efd->events);
DBG("ev_fd=%p occurs fd=%d events=%x revents_ign=%x revents_current=%x",
efd, efd->fd, efd->events, revents_ign, revents_current);
if (revents_current)
efd->func(egc, efd, efd->fd, efd->events, revents_current);
}
static void afterpoll_internal(libxl__egc *egc, libxl__poller *poller,
int nfds, const struct pollfd *fds,
struct timeval now)
{
/* May make callbacks into the application for child processes.
* ctx must be locked exactly once */
EGC_GC;
libxl__ev_fd *efd;
for (;;) {
/* We restart our scan of fd events whenever we call a
* callback function. This is necessary because such
* a callback might make arbitrary changes to CTX->efds.
* We invalidate the fd_rindices[] entries which were used
* so that we don't call the same function again. */
int revents;
LIBXL_LIST_FOREACH(efd, &CTX->efds, entry) {
if (!efd->events)
continue;
revents = afterpoll_check_fd(poller,fds,nfds,
efd->fd,efd->events);
if (revents)
goto found_fd_event;
}
/* no ordinary fd events, then */
break;
found_fd_event:
fd_occurs(egc, efd, revents);
}
if (afterpoll_check_fd(poller,fds,nfds, poller->wakeup_pipe[0],POLLIN)) {
int e = <API key>(poller->wakeup_pipe[0]);
if (e) <API key>(egc, "read wakeup", e, 0);
}
for (;;) {
libxl__ev_time *etime = LIBXL_TAILQ_FIRST(&CTX->etimes);
if (!etime)
break;
assert(!etime->infinite);
if (timercmp(&etime->abs, &now, >))
break;
time_deregister(gc, etime);
time_occurs(egc, etime, ERROR_TIMEDOUT);
}
}
void <API key>(libxl_ctx *ctx, int nfds, const struct pollfd *fds,
struct timeval now)
{
EGC_INIT(ctx);
CTX_LOCK;
afterpoll_internal(egc, ctx->poller_app, nfds, fds, now);
CTX_UNLOCK;
EGC_FREE;
}
/*
* osevent hook and callback machinery
*/
void <API key>(libxl_ctx *ctx,
const libxl_osevent_hooks *hooks,
void *user)
{
GC_INIT(ctx);
CTX_LOCK;
assert(LIBXL_LIST_EMPTY(&ctx->efds));
assert(LIBXL_TAILQ_EMPTY(&ctx->etimes));
ctx->osevent_hooks = hooks;
ctx->osevent_user = user;
CTX_UNLOCK;
GC_FREE;
}
void <API key>(libxl_ctx *ctx, void *for_libxl,
int fd, short events_ign, short revents_ign)
{
EGC_INIT(ctx);
CTX_LOCK;
assert(!CTX->osevent_in_hook);
libxl__ev_fd *ev = <API key>(ctx, for_libxl);
if (!ev) goto out;
if (ev->fd != fd) goto out;
fd_occurs(egc, ev, revents_ign);
out:
CTX_UNLOCK;
EGC_FREE;
}
void <API key>(libxl_ctx *ctx, void *for_libxl)
{
EGC_INIT(ctx);
CTX_LOCK;
assert(!CTX->osevent_in_hook);
<API key> *nexus = for_libxl;
libxl__ev_time *ev = <API key>(ctx, nexus);
<API key>(gc, &CTX-><API key>, nexus);
if (!ev) goto out;
assert(!ev->infinite);
LIBXL_TAILQ_REMOVE(&CTX->etimes, ev, entry);
time_occurs(egc, ev, ERROR_TIMEDOUT);
out:
CTX_UNLOCK;
EGC_FREE;
}
void <API key>(libxl__egc *egc, const char *msg, int errnoval,
libxl_event_type type /* may be 0 */,
const char *file, int line, const char *func)
{
EGC_GC;
libxl__log(CTX, XTL_CRITICAL, errnoval, file, line, func,
"DISASTER in event loop: %s%s%s%s",
msg,
type ? " (relates to event type " : "",
type ? <API key>(type) : "",
type ? ")" : "");
if (CTX->event_hooks && CTX->event_hooks->disaster) {
CTX->event_hooks->disaster(CTX->event_hooks_user, type, msg, errnoval);
return;
}
const char verybad[] =
"DISASTER in event loop not handled by libxl application";
LIBXL__LOG(CTX, XTL_CRITICAL, verybad);
fprintf(stderr, "libxl: fatal error, exiting program: %s\n", verybad);
exit(-1);
}
static void egc_run_callbacks(libxl__egc *egc)
{
/*
* The callbacks must happen with the ctx unlocked. See the
* comment near #define EGC_GC in libxl_internal.h and those in
* the definitions of libxl__egc, libxl__ao and libxl__aop.
*/
EGC_GC;
libxl_event *ev, *ev_tmp;
libxl__aop_occurred *aop, *aop_tmp;
<API key>(ev, &egc-><API key>, link, ev_tmp) {
LIBXL_TAILQ_REMOVE(&egc-><API key>, ev, link);
LOG(DEBUG,"event %p callback type=%s",
ev, <API key>(ev->type));
CTX->event_hooks->event_occurs(CTX->event_hooks_user, ev);
}
<API key>(aop, &egc->aops_for_callback, entry, aop_tmp) {
LIBXL_TAILQ_REMOVE(&egc->aops_for_callback, aop, entry);
LOG(DEBUG,"ao %p: progress report: callback aop=%p", aop->ao, aop);
aop->how->callback(CTX, aop->ev, aop->how->for_callback);
CTX_LOCK;
assert(aop->ao->magic == LIBXL__AO_MAGIC);
aop->ao-><API key>
<API key>(egc, aop->ao);
CTX_UNLOCK;
}
libxl__ao *ao, *ao_tmp;
<API key>(ao, &egc->aos_for_callback,
entry_for_callback, ao_tmp) {
LIBXL_TAILQ_REMOVE(&egc->aos_for_callback, ao, entry_for_callback);
LOG(DEBUG,"ao %p: completion callback", ao);
ao->how.callback(CTX, ao->rc, ao->how.u.for_callback);
CTX_LOCK;
ao->notified = 1;
ao__check_destroy(CTX, ao);
CTX_UNLOCK;
}
}
void libxl__egc_cleanup(libxl__egc *egc)
{
EGC_GC;
egc_run_callbacks(egc);
libxl__free_all(gc);
}
/*
* Event retrieval etc.
*/
void <API key>(libxl_ctx *ctx,
const libxl_event_hooks *hooks, void *user)
{
ctx->event_hooks = hooks;
ctx->event_hooks_user = user;
}
void <API key>(libxl__egc *egc, libxl_event *event)
{
EGC_GC;
if (CTX->event_hooks &&
(CTX->event_hooks->event_occurs_mask & (1UL << event->type))) {
/* libxl__egc_cleanup will call the callback, just before exit
* from libxl. This helps avoid reentrancy bugs: parts of
* libxl that call <API key> do not have to worry
* that libxl might be reentered at that point. */
<API key>(&egc-><API key>, event, link);
return;
} else {
libxl__poller *poller;
<API key>(&CTX->occurred, event, link);
LIBXL_LIST_FOREACH(poller, &CTX->pollers_event, entry)
<API key>(egc, poller);
}
}
void libxl_event_free(libxl_ctx *ctx, libxl_event *event)
{
/* Exceptionally, this function may be called from libxl, with ctx==0 */
libxl_event_dispose(event);
free(event);
}
libxl_event *libxl__event_new(libxl__egc *egc,
libxl_event_type type, uint32_t domid,
libxl_ev_user for_user)
{
EGC_GC;
libxl_event *ev;
ev = libxl__zalloc(NOGC,sizeof(*ev));
libxl_event_init(ev);
<API key>(ev, type);
ev->domid = domid;
ev->for_user = for_user;
return ev;
}
static int <API key>(libxl__egc *egc, libxl_event **event_r,
unsigned long typemask,
<API key> *pred, void *pred_user)
{
EGC_GC;
libxl_event *ev;
int rc;
LIBXL_TAILQ_FOREACH(ev, &CTX->occurred, link) {
if (!(typemask & ((uint64_t)1 << ev->type)))
continue;
if (pred && !pred(ev, pred_user))
continue;
/* got one! */
LIBXL_TAILQ_REMOVE(&CTX->occurred, ev, link);
*event_r = ev;
rc = 0;
goto out;
}
rc = ERROR_NOT_READY;
out:
return rc;
}
int libxl_event_check(libxl_ctx *ctx, libxl_event **event_r,
uint64_t typemask,
<API key> *pred, void *pred_user)
{
EGC_INIT(ctx);
CTX_LOCK;
int rc = <API key>(egc, event_r, typemask, pred, pred_user);
CTX_UNLOCK;
EGC_FREE;
return rc;
}
/*
* Utilities for pipes (specifically, useful for self-pipes)
*/
void libxl__pipe_close(int fds[2])
{
if (fds[0] >= 0) close(fds[0]);
if (fds[1] >= 0) close(fds[1]);
fds[0] = fds[1] = -1;
}
int <API key>(libxl_ctx *ctx, int fds[2])
{
int r, rc;
r = libxl_pipe(ctx, fds);
if (r) {
fds[0] = fds[1] = -1;
rc = ERROR_FAIL;
goto out;
}
rc = <API key>(ctx, fds[0], 1);
if (rc) goto out;
rc = <API key>(ctx, fds[1], 1);
if (rc) goto out;
return 0;
out:
libxl__pipe_close(fds);
return rc;
}
int <API key>(int fd)
{
static const char buf[1] = "";
for (;;) {
int r = write(fd, buf, 1);
if (r==1) return 0;
assert(r==-1);
if (errno == EINTR) continue;
if (errno == EWOULDBLOCK) return 0;
assert(errno);
return errno;
}
}
int <API key>(int fd)
{
char buf[256];
for (;;) {
int r = read(fd, buf, sizeof(buf));
if (r == sizeof(buf)) continue;
if (r >= 0) return 0;
assert(r == -1);
if (errno == EINTR) continue;
if (errno == EWOULDBLOCK) return 0;
assert(errno);
return errno;
}
}
/*
* Manipulation of pollers
*/
int libxl__poller_init(libxl__gc *gc, libxl__poller *p)
{
int rc;
p->fd_polls = 0;
p->fd_rindices = 0;
p->fds_changed = 0;
rc = <API key>(CTX, p->wakeup_pipe);
if (rc) goto out;
return 0;
out:
<API key>(p);
return rc;
}
void <API key>(libxl__poller *p)
{
libxl__pipe_close(p->wakeup_pipe);
free(p->fd_polls);
free(p->fd_rindices);
}
libxl__poller *libxl__poller_get(libxl__gc *gc)
{
/* must be called with ctx locked */
int rc;
libxl__poller *p = LIBXL_LIST_FIRST(&CTX->pollers_idle);
if (p) {
LIBXL_LIST_REMOVE(p, entry);
} else {
p = libxl__zalloc(NOGC, sizeof(*p));
rc = libxl__poller_init(gc, p);
if (rc) {
free(p);
return NULL;
}
}
<API key>(&CTX->pollers_fds_changed, p,
fds_changed_entry);
return p;
}
void libxl__poller_put(libxl_ctx *ctx, libxl__poller *p)
{
if (!p) return;
LIBXL_LIST_REMOVE(p, fds_changed_entry);
<API key>(&ctx->pollers_idle, p, entry);
}
void <API key>(libxl__egc *egc, libxl__poller *p)
{
int e = <API key>(p->wakeup_pipe[1]);
if (e) <API key>(egc, "cannot poke watch pipe", e, 0);
}
/*
* Main event loop iteration
*/
static int eventloop_iteration(libxl__egc *egc, libxl__poller *poller) {
/* The CTX must be locked EXACTLY ONCE so that this function
* can unlock it when it polls.
*/
EGC_GC;
int rc, nfds;
struct timeval now;
rc = libxl__gettimeofday(gc, &now);
if (rc) goto out;
int timeout;
for (;;) {
nfds = poller->fd_polls_allocd;
timeout = -1;
rc = beforepoll_internal(gc, poller, &nfds, poller->fd_polls,
&timeout, now);
if (!rc) break;
if (rc != ERROR_BUFFERFULL) goto out;
struct pollfd *newarray =
(nfds > INT_MAX / sizeof(struct pollfd) / 2) ? 0 :
libxl__realloc(NOGC, poller->fd_polls, sizeof(*newarray) * nfds);
if (!newarray) { rc = ERROR_NOMEM; goto out; }
poller->fd_polls = newarray;
poller->fd_polls_allocd = nfds;
}
CTX_UNLOCK;
rc = poll(poller->fd_polls, nfds, timeout);
CTX_LOCK;
if (rc < 0) {
if (errno == EINTR)
return 0; /* will go round again if caller requires */
LIBXL__LOG_ERRNOVAL(CTX, LIBXL__LOG_ERROR, errno, "poll failed");
rc = ERROR_FAIL;
goto out;
}
rc = libxl__gettimeofday(gc, &now);
if (rc) goto out;
afterpoll_internal(egc, poller, nfds, poller->fd_polls, now);
rc = 0;
out:
return rc;
}
int libxl_event_wait(libxl_ctx *ctx, libxl_event **event_r,
uint64_t typemask,
<API key> *pred, void *pred_user)
{
int rc;
libxl__poller *poller = NULL;
EGC_INIT(ctx);
CTX_LOCK;
poller = libxl__poller_get(gc);
if (!poller) { rc = ERROR_FAIL; goto out; }
for (;;) {
rc = <API key>(egc, event_r, typemask, pred, pred_user);
if (rc != ERROR_NOT_READY) goto out;
rc = eventloop_iteration(egc, poller);
if (rc) goto out;
/* we unlock and cleanup the egc each time we go through this loop,
* so that (a) we don't accumulate garbage and (b) any events
* which are to be dispatched by callback are actually delivered
* in a timely fashion.
*/
CTX_UNLOCK;
libxl__egc_cleanup(egc);
CTX_LOCK;
}
out:
libxl__poller_put(ctx, poller);
CTX_UNLOCK;
EGC_FREE;
return rc;
}
/*
* A "manip" is a libxl public function manipulating this ao, which
* has a pointer to it. We have to not destroy it while that's the
* case, obviously. Callers must have the ctx locked, obviously.
*/
static void ao__manip_enter(libxl__ao *ao)
{
assert(ao->manip_refcnt < INT_MAX);
ao->manip_refcnt++;
}
static void ao__manip_leave(libxl_ctx *ctx, libxl__ao *ao)
{
assert(ao->manip_refcnt > 0);
ao->manip_refcnt
ao__check_destroy(ctx, ao);
}
static void ao__check_destroy(libxl_ctx *ctx, libxl__ao *ao)
{
if (!ao->manip_refcnt && ao->notified) {
assert(ao->complete);
libxl__ao__destroy(ctx, ao);
}
}
void libxl__ao__destroy(libxl_ctx *ctx, libxl__ao *ao)
{
AO_GC;
if (!ao) return;
LOG(DEBUG,"ao %p: destroy",ao);
libxl__poller_put(ctx, ao->poller);
ao->magic = <API key>;
libxl__free_all(&ao->gc);
free(ao);
}
void <API key>(libxl__ao *ao)
{
AO_GC;
LOG(DEBUG,"ao %p: create fail",ao);
assert(ao->magic == LIBXL__AO_MAGIC);
assert(ao->in_initiator);
assert(!ao->complete);
assert(!ao-><API key>);
assert(!ao->aborting);
LIBXL_LIST_REMOVE(ao, inprogress_entry);
libxl__ao__destroy(CTX, ao);
}
libxl__gc *<API key>(libxl__ao *ao)
{
assert(ao);
assert(ao->magic == LIBXL__AO_MAGIC);
assert(!ao->complete);
return &ao->gc;
}
void libxl__ao_complete(libxl__egc *egc, libxl__ao *ao, int rc)
{
AO_GC;
LOG(DEBUG,"ao %p: complete, rc=%d",ao,rc);
assert(ao->magic == LIBXL__AO_MAGIC);
assert(!ao->complete);
assert(!ao->nested_root);
assert(!ao->nested_progeny);
ao->complete = 1;
ao->rc = rc;
LIBXL_LIST_REMOVE(ao, inprogress_entry);
<API key>(egc, ao);
}
static bool ao_work_outstanding(libxl__ao *ao)
{
/*
* We don't consider an ao complete if it has any outstanding
* callbacks. These callbacks might be outstanding on other
* threads, queued up in the other threads' egc's. Those threads
* will, after making the callback, take out the lock again,
* decrement <API key>, and call
* <API key>.
*/
return !ao->complete || ao-><API key>;
}
void <API key>(libxl__egc *egc, libxl__ao *ao)
{
libxl_ctx *ctx = libxl__gc_owner(&egc->gc);
assert(ao-><API key> >= 0);
if (ao_work_outstanding(ao))
return;
if (ao->poller) {
assert(ao->in_initiator);
if (!ao->constructing)
/* don't bother with this if we're not in the event loop */
<API key>(egc, ao->poller);
} else if (ao->how.callback) {
LIBXL__LOG(ctx, XTL_DEBUG, "ao %p: complete for callback",ao);
<API key>(&egc->aos_for_callback, ao, entry_for_callback);
} else {
libxl_event *ev;
ev = NEW_EVENT(egc, OPERATION_COMPLETE, ao->domid, ao->how.u.for_event);
if (ev) {
ev->u.operation_complete.rc = ao->rc;
<API key>(egc, ev);
}
ao->notified = 1;
}
ao__check_destroy(ctx, ao);
}
libxl__ao *libxl__ao_create(libxl_ctx *ctx, uint32_t domid,
const libxl_asyncop_how *how,
const char *file, int line, const char *func)
{
libxl__ao *ao;
ao = calloc(1, sizeof(*ao));
if (!ao) goto out;
ao->magic = LIBXL__AO_MAGIC;
ao->constructing = 1;
ao->in_initiator = 1;
ao__manip_enter(ao);
ao->poller = 0;
ao->domid = domid;
LIBXL_INIT_GC(ao->gc, ctx);
if (how) {
ao->how = *how;
} else {
ao->poller = libxl__poller_get(&ao->gc);
if (!ao->poller) goto out;
}
libxl__log(ctx,XTL_DEBUG,-1,file,line,func,
"ao %p: create: how=%p callback=%p poller=%p",
ao, how, ao->how.callback, ao->poller);
<API key>(&ctx->aos_inprogress, ao, inprogress_entry);
return ao;
out:
if (ao) libxl__ao__destroy(ctx, ao);
return NULL;
}
int <API key>(libxl__ao *ao,
const char *file, int line, const char *func)
{
AO_GC;
int rc;
assert(ao->magic == LIBXL__AO_MAGIC);
assert(ao->constructing);
assert(ao->in_initiator);
ao->constructing = 0;
libxl__log(CTX,XTL_DEBUG,-1,file,line,func,
"ao %p: inprogress: poller=%p, flags=%s%s%s%s",
ao, ao->poller,
ao->constructing ? "o" : "",
ao->in_initiator ? "i" : "",
ao->complete ? "c" : "",
ao->notified ? "n" : "");
if (ao->poller) {
/* Caller wants it done synchronously. */
/* We use a fresh gc, so that we can free things
* each time round the loop. */
libxl__egc egc;
LIBXL_INIT_EGC(egc,CTX);
for (;;) {
assert(ao->magic == LIBXL__AO_MAGIC);
if (!ao_work_outstanding(ao)) {
rc = ao->rc;
ao->notified = 1;
break;
}
DBG("ao %p: not ready, waiting",ao);
rc = eventloop_iteration(&egc,ao->poller);
if (rc) {
/* Oh dear, this is quite unfortunate. */
LIBXL__LOG(CTX, LIBXL__LOG_ERROR, "Error waiting for"
" event during long-running operation (rc=%d)", rc);
sleep(1);
/* It's either this or return <API key>
* <API key>
* <API key>, since we don't have a
* synchronous cancellation ability. */
}
CTX_UNLOCK;
libxl__egc_cleanup(&egc);
CTX_LOCK;
}
} else {
rc = 0;
}
ao->in_initiator = 0;
ao__manip_leave(CTX, ao);
return rc;
}
/* abort requests */
static int ao__abort(libxl_ctx *ctx, libxl__ao *parent)
/* Temporarily unlocks ctx, which must be locked exactly once on entry. */
{
int rc;
ao__manip_enter(parent);
if (parent->aborting) {
rc = ERROR_ABORTED;
goto out;
}
parent->aborting = 1;
if (LIBXL_LIST_EMPTY(&parent->abortables)) {
LIBXL__LOG(ctx, XTL_DEBUG,
"ao %p: abort requested and noted, but no-one interested",
parent);
rc = 0;
goto out;
}
/* We keep calling abort hooks until there are none left */
while (!LIBXL_LIST_EMPTY(&parent->abortables)) {
libxl__egc egc;
LIBXL_INIT_EGC(egc,ctx);
assert(!parent->complete);
libxl__ao_abortable *abrt = LIBXL_LIST_FIRST(&parent->abortables);
assert(parent == ao_nested_root(abrt->ao));
LIBXL_LIST_REMOVE(abrt, entry);
abrt->registered = 0;
LIBXL__LOG(ctx, XTL_DEBUG, "ao %p: abrt=%p: aborting",
parent, abrt->ao);
abrt->callback(&egc, abrt, ERROR_ABORTED);
libxl__ctx_unlock(ctx);
libxl__egc_cleanup(&egc);
libxl__ctx_lock(ctx);
}
rc = 0;
out:
ao__manip_leave(ctx, parent);
return rc;
}
int libxl_ao_abort(libxl_ctx *ctx, const libxl_asyncop_how *how)
{
libxl__ao *search;
libxl__ctx_lock(ctx);
int rc;
LIBXL_LIST_FOREACH(search, &ctx->aos_inprogress, inprogress_entry) {
if (how) {
/* looking for ao to be reported by callback or event */
if (search->poller)
/* sync */
continue;
if (how->callback != search->how.callback)
continue;
if (how->callback
? (how->u.for_callback != search->how.u.for_callback)
: (how->u.for_event != search->how.u.for_event))
continue;
} else {
/* looking for synchronous call */
if (!search->poller)
/* async */
continue;
}
goto found;
}
rc = ERROR_NOTFOUND;
goto out;
found:
rc = ao__abort(ctx, search);
out:
libxl__ctx_unlock(ctx);
return rc;
}
int libxl__ao_aborting(libxl__ao *ao)
{
libxl__ao *root = ao_nested_root(ao);
if (root->aborting) {
DBG("ao=%p: aborting at explicit check (root=%p)", ao, root);
return ERROR_ABORTED;
}
return 0;
}
int <API key>(libxl__ao_abortable *abrt)
{
libxl__ao *ao = abrt->ao;
libxl__ao *root = ao_nested_root(ao);
AO_GC;
if (root->aborting) {
DBG("ao=%p: preemptively aborting ao_abortable registration %p (root=%p)",
ao, abrt, root);
return ERROR_ABORTED;
}
DBG("ao=%p, abrt=%p: registering (root=%p)", ao, abrt, root);
<API key>(&root->abortables, abrt, entry);
abrt->registered = 1;
return 0;
}
_hidden void <API key>(libxl__ao_abortable *abrt)
{
if (!abrt->registered)
return;
libxl__ao *ao = abrt->ao;
libxl__ao *root __attribute__((unused)) = ao_nested_root(ao);
AO_GC;
DBG("ao=%p, abrt=%p: deregistering (root=%p)", ao, abrt, root);
LIBXL_LIST_REMOVE(abrt, entry);
abrt->registered = 0;
}
/* progress reporting */
/* The application indicates a desire to ignore events by passing NULL
* for how. But we want to copy *how. So we have this dummy function
* whose address is stored in callback if the app passed how==NULL. */
static void <API key>
(libxl_ctx *ctx, libxl_event *ev, void *for_callback) { }
void <API key>(<API key> *in_state,
const <API key> *from_app) {
if (from_app)
*in_state = *from_app;
else
in_state->callback = <API key>;
}
void <API key>(libxl__egc *egc, libxl__ao *ao,
const <API key> *how, libxl_event *ev)
{
AO_GC;
assert(!ao->nested_root);
if (how->callback == <API key>) {
LOG(DEBUG,"ao %p: progress report: ignored",ao);
libxl_event_free(CTX,ev);
/* ignore */
} else if (how->callback) {
libxl__aop_occurred *aop = libxl__zalloc(&egc->gc, sizeof(*aop));
ao-><API key>++;
aop->ao = ao;
aop->ev = ev;
aop->how = how;
<API key>(&egc->aops_for_callback, aop, entry);
LOG(DEBUG,"ao %p: progress report: callback queued aop=%p",ao,aop);
} else {
LOG(DEBUG,"ao %p: progress report: event queued ev=%p type=%s",
ao, ev, <API key>(ev->type));
<API key>(egc, ev);
}
}
/* nested ao */
static libxl__ao *ao_nested_root(libxl__ao *ao) {
libxl__ao *root = ao->nested_root ? : ao;
assert(!root->nested_root);
return root;
}
_hidden libxl__ao *<API key>(libxl__ao *parent)
{
libxl__ao *child = NULL, *root;
libxl_ctx *ctx = libxl__gc_owner(&parent->gc);
assert(parent->magic == LIBXL__AO_MAGIC);
root = ao_nested_root(parent);
child = libxl__zalloc(&ctx->nogc_gc, sizeof(*child));
child->magic = LIBXL__AO_MAGIC;
child->nested_root = root;
assert(root->nested_progeny < INT_MAX);
root->nested_progeny++;
LIBXL_INIT_GC(child->gc, ctx);
libxl__gc *gc = &child->gc;
LOG(DEBUG,"ao %p: nested ao, parent %p", child, parent);
return child;
}
_hidden void <API key>(libxl__ao *child)
{
assert(child->magic == LIBXL__AO_MAGIC);
libxl__ao *root = child->nested_root;
assert(root);
assert(root->nested_progeny > 0);
root->nested_progeny
libxl_ctx *ctx = libxl__gc_owner(&child->gc);
libxl__ao__destroy(ctx, child);
}
/*
* Local variables:
* mode: C
* c-basic-offset: 4
* indent-tabs-mode: nil
* End:
*/ |
#ifndef GST_GST_H
#define GST_GST_H
/* AIX is so broken that requires this to be the first thing in the file. */
#if defined(_AIX)
#pragma alloca
#else
# if !defined(alloca) /* predefined by HP cc +Olibcalls */
# ifdef __GNUC__
# define alloca(size) __builtin_alloca(size)
# else
# if HAVE_ALLOCA_H
# include <alloca.h>
# else
# if defined(__hpux)
void *alloca ();
# else
# if !defined(__OS2__) && !defined(WIN32)
char *alloca ();
# else
# include <malloc.h> /* OS/2 defines alloca in here */
# endif
# endif
# endif
# endif
# endif
#endif
/* Some compilers use different win32 definitions. Define WIN32 so we
have only to check for one symbol. */
#if defined(_WIN32) || defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(Win32) || defined(__WIN32)
#ifndef WIN32
#define WIN32 1
#endif
#endif
#ifdef _MSC_VER
/* Visual C++ does not define STDC */
#define __STDC__ 1
#endif
/* Defined as char * in traditional compilers, void * in
standard-compliant compilers. */
#ifndef PTR
#if !defined(__STDC__)
#define PTR char *
#else
#define PTR void *
#endif
#endif
/* A boolean type */
#ifdef __cplusplus
typedef bool mst_Boolean;
#else
typedef enum {
false,
true
} mst_Boolean;
#endif
/* An indirect pointer to object data. */
typedef struct oop_s *OOP;
/* A direct pointer to the object data. */
typedef struct object_s *gst_object, *mst_Object;
/* The contents of an indirect pointer to object data. */
struct oop_s
{
gst_object object;
unsigned long flags; /* FIXME, use uintptr_t */
};
/* The header of all objects in the system.
Note how structural inheritance is achieved without adding extra levels of
nested structures. */
#define OBJ_HEADER \
OOP objSize; \
OOP objClass
/* Just for symbolic use in sizeof's */
typedef struct gst_object_header
{
OBJ_HEADER;
}
gst_object_header;
#define <API key> (sizeof(gst_object_header) / sizeof(PTR))
/* A bare-knuckles accessor for real objects */
struct object_s
{
OBJ_HEADER;
OOP data[1]; /* variable length, may not be objects,
but will always be at least this
big. */
};
/* Convert an OOP (indirect pointer to an object) to the real object
data. */
#define OOP_TO_OBJ(oop) \
((oop)->object)
/* Retrieve the class for the object pointed to by OOP. OOP must be
a real pointer, not a SmallInteger. */
#define OOP_CLASS(oop) \
(OOP_TO_OBJ(oop)->objClass)
/* Answer whether OOP is a SmallInteger or a `real' object pointer. */
#define IS_INT(oop) \
((intptr_t)(oop) & 1)
/* Answer whether both OOP1 and OOP2 are SmallIntegers, or rather at
least one of them a `real' object pointer. */
#define ARE_INTS(oop1, oop2) \
((intptr_t)(oop1) & (intptr_t)(oop2) & 1)
/* Answer whether OOP is a `real' object pointer or rather a
SmallInteger. */
#define IS_OOP(oop) \
(! IS_INT(oop) )
/* Keep these in sync with _gst_sizes, in dict.c.
FIXME: these should be exported in a pool dictionary. */
enum gst_indexed_kind {
GST_ISP_FIXED = 0,
GST_ISP_SCHAR = 32,
GST_ISP_UCHAR = 34,
GST_ISP_CHARACTER = 36,
GST_ISP_SHORT = 38,
GST_ISP_USHORT = 40,
GST_ISP_INT = 42,
GST_ISP_UINT = 44,
GST_ISP_FLOAT = 46,
GST_ISP_INT64 = 48,
GST_ISP_UINT64 = 50,
GST_ISP_DOUBLE = 52,
GST_ISP_UTF32 = 54,
GST_ISP_LAST_SCALAR = 54,
GST_ISP_POINTER = 62,
#if SIZEOF_OOP == 8
GST_ISP_LONG = GST_ISP_INT64,
GST_ISP_ULONG = GST_ISP_UINT64,
<API key> = GST_ISP_FLOAT,
#else
GST_ISP_LONG = GST_ISP_INT,
GST_ISP_ULONG = GST_ISP_UINT,
<API key> = GST_ISP_USHORT,
#endif
};
/* enum types used by the public APIs. */
enum gst_file_dir {
GST_DIR_ABS,
<API key>,
GST_DIR_KERNEL,
GST_DIR_BASE
};
enum gst_var_index {
GST_DECLARE_TRACING,
<API key>,
<API key>,
GST_GC_MESSAGE,
GST_VERBOSITY,
GST_MAKE_CORE_FILE,
<API key>
};
enum gst_init_flags {
GST_REBUILD_IMAGE = 1,
<API key> = 2,
<API key> = 4,
<API key> = 8,
<API key> = 16,
GST_NO_TTY = 32,
};
enum gst_vm_hook {
GST_BEFORE_EVAL,
GST_AFTER_EVAL,
<API key>,
GST_ABOUT_TO_QUIT,
<API key>,
<API key>
};
#define INDEXED_WORD(obj, n) ( ((long *) ((obj) + 1)) [(n)-1] )
#define INDEXED_BYTE(obj, n) ( ((char *) ((obj) + 1)) [(n)-1] )
#define INDEXED_OOP(obj, n) ( ((OOP *) ((obj) + 1)) [(n)-1] )
#define ARRAY_OOP_AT(obj, n) ( ((OOP *) ((gst_object) obj)->data) [(n)-1] )
#define STRING_OOP_AT(obj, n) ( ((char *) ((gst_object) obj)->data) [(n)-1] )
#endif /* GST_GST_H */ |
<?php
namespace Vokuro\Controllers;
use Phalcon\Tag;
use Phalcon\Mvc\Model\Criteria;
use Phalcon\Paginator\Adapter\Model as Paginator;
use Vokuro\Forms\ProfilesForm;
use Vokuro\Models\Profiles;
/**
* Vokuro\Controllers\ProfilesController
* CRUD to manage profiles
*/
class ProfilesController extends ControllerBase
{
/**
* Default action. Set the private (authenticated) layout (layouts/private.volt)
*/
public function initialize()
{
$this->view->setTemplateBefore('private');
}
/**
* Default action, shows the search form
*/
public function indexAction()
{
$this->persistent->conditions = null;
$this->view->form = new ProfilesForm();
}
/**
* Searches for profiles
*/
public function searchAction()
{
$numberPage = 1;
if ($this->request->isPost()) {
$query = Criteria::fromInput($this->di, 'Vokuro\Models\Profiles', $this->request->getPost());
$this->persistent->searchParams = $query->getParams();
} else {
$numberPage = $this->request->getQuery("page", "int");
}
$parameters = array();
if ($this->persistent->searchParams) {
$parameters = $this->persistent->searchParams;
}
$profiles = Profiles::find($parameters);
if (count($profiles) == 0) {
$this->flash->notice("The search did not find any profiles");
return $this->dispatcher->forward(array(
"action" => "index"
));
}
$paginator = new Paginator(array(
"data" => $profiles,
"limit" => 10,
"page" => $numberPage
));
$this->view->page = $paginator->getPaginate();
}
/**
* Creates a new Profile
*/
public function createAction()
{
if ($this->request->isPost()) {
$profile = new Profiles();
$profile->assign(array(
'name' => $this->request->getPost('name', 'striptags'),
'active' => $this->request->getPost('active')
));
if (!$profile->save()) {
$this->flash->error($profile->getMessages());
} else {
$this->flash->success("Profile was created successfully");
}
Tag::resetInput();
}
$this->view->form = new ProfilesForm(null);
}
/**
* Edits an existing Profile
*
* @param int $id
*/
public function editAction($id)
{
$profile = Profiles::findFirstById($id);
if (!$profile) {
$this->flash->error("Profile was not found");
return $this->dispatcher->forward(array(
'action' => 'index'
));
}
if ($this->request->isPost()) {
$profile->assign(array(
'name' => $this->request->getPost('name', 'striptags'),
'active' => $this->request->getPost('active')
));
if (!$profile->save()) {
$this->flash->error($profile->getMessages());
} else {
$this->flash->success("Profile was updated successfully");
}
Tag::resetInput();
}
$this->view->form = new ProfilesForm($profile, array(
'edit' => true
));
$this->view->profile = $profile;
}
/**
* Deletes a Profile
*
* @param int $id
*/
public function deleteAction($id)
{
$profile = Profiles::findFirstById($id);
if (!$profile) {
$this->flash->error("Profile was not found");
return $this->dispatcher->forward(array(
'action' => 'index'
));
}
if (!$profile->delete()) {
$this->flash->error($profile->getMessages());
} else {
$this->flash->success("Profile was deleted");
}
return $this->dispatcher->forward(array(
'action' => 'index'
));
}
} |
<html lang="en">
<head>
<title>Purgem - Using as</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Using as">
<meta name="generator" content="makeinfo 4.13">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="Pseudo-Ops.html#Pseudo-Ops" title="Pseudo Ops">
<link rel="prev" href="Psize.html#Psize" title="Psize">
<link rel="next" href="PushSection.html#PushSection" title="PushSection">
<link href="http:
<!
This file documents the GNU Assembler "as".
Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000, 2001, 2002,
2006, 2007, 2008, 2009 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3
or any later version published by the Free Software Foundation;
with no Invariant Sections, with no Front-Cover Texts, and with no
Back-Cover Texts. A copy of the license is included in the
section entitled ``GNU Free Documentation License''.
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!
pre.display { font-family:inherit }
pre.format { font-family:inherit }
pre.smalldisplay { font-family:inherit; font-size:smaller }
pre.smallformat { font-family:inherit; font-size:smaller }
pre.smallexample { font-size:smaller }
pre.smalllisp { font-size:smaller }
span.sc { font-variant:small-caps }
span.roman { font-family:serif; font-weight:normal; }
span.sansserif { font-family:sans-serif; font-weight:normal; }
--></style>
<link rel="stylesheet" type="text/css" href="../cs.css">
</head>
<body>
<div class="node">
<a name="Purgem"></a>
<p>
Next: <a rel="next" accesskey="n" href="PushSection.html#PushSection">PushSection</a>,
Previous: <a rel="previous" accesskey="p" href="Psize.html#Psize">Psize</a>,
Up: <a rel="up" accesskey="u" href="Pseudo-Ops.html#Pseudo-Ops">Pseudo Ops</a>
<hr>
</div>
<h3 class="section">7.89 <code>.purgem </code><var>name</var></h3>
<p><a name="<API key>"></a>Undefine the macro <var>name</var>, so that later uses of the string will not be
expanded. See <a href="Macro.html#Macro">Macro</a>.
</body></html> |
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/pstore.h>
#include <linux/time.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/compiler.h>
#include <linux/pstore_ram.h>
#define RAMOOPS_KERNMSG_HDR "===="
#define MIN_MEM_SIZE 4096UL
static ulong record_size = MIN_MEM_SIZE;
module_param(record_size, ulong, 0400);
MODULE_PARM_DESC(record_size,
"size of each dump done on oops/panic");
#ifdef VENDOR_EDIT
//tanggeliang@Swdp.Android.Kernel, 2015/03/12, enable ramoops_console
static ulong <API key> = 64 * MIN_MEM_SIZE;
#else
static ulong <API key> = MIN_MEM_SIZE;
#endif /* VENDOR_EDIT */
module_param_named(console_size, <API key>, ulong, 0400);
MODULE_PARM_DESC(console_size, "size of kernel console log");
static ulong ramoops_ftrace_size = MIN_MEM_SIZE;
module_param_named(ftrace_size, ramoops_ftrace_size, ulong, 0400);
MODULE_PARM_DESC(ftrace_size, "size of ftrace log");
static ulong mem_address;
module_param(mem_address, ulong, 0400);
MODULE_PARM_DESC(mem_address,
"start of reserved RAM used to store oops/panic logs");
static ulong mem_size;
module_param(mem_size, ulong, 0400);
MODULE_PARM_DESC(mem_size,
"size of reserved RAM used to store oops/panic logs");
static int dump_oops = 1;
module_param(dump_oops, int, 0600);
MODULE_PARM_DESC(dump_oops,
"set to 1 to dump oopses, 0 to only dump panics (default 1)");
static int ramoops_ecc;
module_param_named(ecc, ramoops_ecc, int, 0600);
MODULE_PARM_DESC(ramoops_ecc,
"if non-zero, the option enables ECC support and specifies "
"ECC buffer size in bytes (1 is a special value, means 16 "
"bytes ECC)");
struct ramoops_context {
struct persistent_ram_zone **przs;
struct persistent_ram_zone *cprz;
struct persistent_ram_zone *fprz;
phys_addr_t phys_addr;
unsigned long size;
size_t record_size;
size_t console_size;
size_t ftrace_size;
int dump_oops;
struct <API key> ecc_info;
unsigned int max_dump_cnt;
unsigned int dump_write_cnt;
unsigned int dump_read_cnt;
unsigned int console_read_cnt;
unsigned int ftrace_read_cnt;
struct pstore_info pstore;
};
static struct platform_device *dummy;
static struct <API key> *dummy_data;
static int ramoops_pstore_open(struct pstore_info *psi)
{
struct ramoops_context *cxt = psi->data;
cxt->dump_read_cnt = 0;
cxt->console_read_cnt = 0;
return 0;
}
static struct persistent_ram_zone *
<API key>(struct persistent_ram_zone *przs[], uint *c, uint max,
u64 *id,
enum pstore_type_id *typep, enum pstore_type_id type,
bool update)
{
struct persistent_ram_zone *prz;
int i = (*c)++;
if (i >= max)
return NULL;
prz = przs[i];
#ifdef VENDOR_EDIT
//tanggeliang@Swdp.Android.Kernel, 2015/05/07, enable ramoops_console
if (!prz)
return NULL;
/* Update old/shadowed buffer. */
if (update)
<API key>(prz);
if (!<API key>(prz))
return NULL;
#else
if (update) {
/* Update old/shadowed buffer. */
<API key>(prz);
if (!<API key>(prz))
return NULL;
}
#endif /* VENDOR_EDIT */
*typep = type;
*id = i;
return prz;
}
#ifdef VENDOR_EDIT
//tanggeliang@Swdp.Android.Kernel, 2015/05/07, enable ramoops_console
static bool prz_ok(struct persistent_ram_zone *prz)
{
return !!prz && !!(<API key>(prz) +
<API key>(prz, NULL, 0));
}
#endif /* VENDOR_EDIT */
static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
int *count, struct timespec *time,
char **buf, struct pstore_info *psi)
{
ssize_t size;
ssize_t ecc_notice_size;
struct ramoops_context *cxt = psi->data;
struct persistent_ram_zone *prz;
prz = <API key>(cxt->przs, &cxt->dump_read_cnt,
cxt->max_dump_cnt, id, type,
PSTORE_TYPE_DMESG, 1);
#ifdef VENDOR_EDIT
//tanggeliang@Swdp.Android.Kernel, 2015/05/07, enable ramoops_console
if (!prz_ok(prz))
#else
if (!prz)
#endif /* VENDOR_EDIT */
prz = <API key>(&cxt->cprz, &cxt->console_read_cnt,
1, id, type, PSTORE_TYPE_CONSOLE, 0);
#ifdef VENDOR_EDIT
//tanggeliang@Swdp.Android.Kernel, 2015/05/07, enable ramoops_console
if (!prz_ok(prz))
#else
if (!prz)
#endif /* VENDOR_EDIT */
prz = <API key>(&cxt->fprz, &cxt->ftrace_read_cnt,
1, id, type, PSTORE_TYPE_FTRACE, 0);
#ifdef VENDOR_EDIT
//tanggeliang@Swdp.Android.Kernel, 2015/05/07, enable ramoops_console
if (!prz_ok(prz))
#else
if (!prz)
#endif /* VENDOR_EDIT */
return 0;
#ifdef VENDOR_EDIT
//tanggeliang@Swdp.Android.Kernel, 2015/05/07, enable ramoops_console
if (!persistent_ram_old(prz))
return 0;
#endif /* VENDOR_EDIT */
/* TODO(kees): Bogus time for the moment. */
time->tv_sec = 0;
time->tv_nsec = 0;
size = <API key>(prz);
/* ECC correction notice */
ecc_notice_size = <API key>(prz, NULL, 0);
*buf = kmalloc(size + ecc_notice_size + 1, GFP_KERNEL);
if (*buf == NULL)
return -ENOMEM;
memcpy(*buf, persistent_ram_old(prz), size);
<API key>(prz, *buf + size, ecc_notice_size + 1);
return size + ecc_notice_size;
}
static size_t <API key>(struct persistent_ram_zone *prz)
{
char *hdr;
struct timespec timestamp;
size_t len;
/* Report zeroed timestamp if called before timekeeping has resumed. */
if (__getnstimeofday(×tamp)) {
timestamp.tv_sec = 0;
timestamp.tv_nsec = 0;
}
hdr = kasprintf(GFP_ATOMIC, RAMOOPS_KERNMSG_HDR "%lu.%lu\n",
(long)timestamp.tv_sec, (long)(timestamp.tv_nsec / 1000));
WARN_ON_ONCE(!hdr);
len = hdr ? strlen(hdr) : 0;
<API key>(prz, hdr, len);
kfree(hdr);
return len;
}
static int notrace <API key>(enum pstore_type_id type,
enum kmsg_dump_reason reason,
u64 *id, unsigned int part,
const char *buf, size_t size,
struct pstore_info *psi)
{
struct ramoops_context *cxt = psi->data;
struct persistent_ram_zone *prz;
size_t hlen;
if (type == PSTORE_TYPE_CONSOLE) {
if (!cxt->cprz)
return -ENOMEM;
<API key>(cxt->cprz, buf, size);
return 0;
} else if (type == PSTORE_TYPE_FTRACE) {
if (!cxt->fprz)
return -ENOMEM;
<API key>(cxt->fprz, buf, size);
return 0;
}
if (type != PSTORE_TYPE_DMESG)
return -EINVAL;
/* Out of the various dmesg dump types, ramoops is currently designed
* to only store crash logs, rather than storing general kernel logs.
*/
if (reason != KMSG_DUMP_OOPS &&
reason != KMSG_DUMP_PANIC)
return -EINVAL;
/* Skip Oopes when configured to do so. */
if (reason == KMSG_DUMP_OOPS && !cxt->dump_oops)
return -EINVAL;
/* Explicitly only take the first part of any new crash.
* If our buffer is larger than kmsg_bytes, this can never happen,
* and if our buffer is smaller than kmsg_bytes, we don't want the
* report split across multiple records.
*/
if (part != 1)
return -ENOSPC;
if (!cxt->przs)
return -ENOSPC;
prz = cxt->przs[cxt->dump_write_cnt];
hlen = <API key>(prz);
if (size + hlen > prz->buffer_size)
size = prz->buffer_size - hlen;
<API key>(prz, buf, size);
cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt;
return 0;
}
static int <API key>(enum pstore_type_id type, u64 id, int count,
struct timespec time, struct pstore_info *psi)
{
struct ramoops_context *cxt = psi->data;
struct persistent_ram_zone *prz;
switch (type) {
case PSTORE_TYPE_DMESG:
if (id >= cxt->max_dump_cnt)
return -EINVAL;
prz = cxt->przs[id];
break;
case PSTORE_TYPE_CONSOLE:
prz = cxt->cprz;
break;
case PSTORE_TYPE_FTRACE:
prz = cxt->fprz;
break;
default:
return -EINVAL;
}
<API key>(prz);
persistent_ram_zap(prz);
return 0;
}
static struct ramoops_context oops_cxt = {
.pstore = {
.owner = THIS_MODULE,
.name = "ramoops",
.open = ramoops_pstore_open,
.read = ramoops_pstore_read,
.write_buf = <API key>,
.erase = <API key>,
},
};
static void ramoops_free_przs(struct ramoops_context *cxt)
{
int i;
if (!cxt->przs)
return;
for (i = 0; !IS_ERR_OR_NULL(cxt->przs[i]); i++)
persistent_ram_free(cxt->przs[i]);
kfree(cxt->przs);
}
static int ramoops_init_przs(struct device *dev, struct ramoops_context *cxt,
phys_addr_t *paddr, size_t dump_mem_sz)
{
int err = -ENOMEM;
int i;
if (!cxt->record_size)
return 0;
if (*paddr + dump_mem_sz - cxt->phys_addr > cxt->size) {
dev_err(dev, "no room for dumps\n");
return -ENOMEM;
}
cxt->max_dump_cnt = dump_mem_sz / cxt->record_size;
if (!cxt->max_dump_cnt)
return -ENOMEM;
cxt->przs = kzalloc(sizeof(*cxt->przs) * cxt->max_dump_cnt,
GFP_KERNEL);
if (!cxt->przs) {
dev_err(dev, "failed to initialize a prz array for dumps\n");
return -ENOMEM;
}
for (i = 0; i < cxt->max_dump_cnt; i++) {
size_t sz = cxt->record_size;
cxt->przs[i] = persistent_ram_new(*paddr, sz, 0,
&cxt->ecc_info);
if (IS_ERR(cxt->przs[i])) {
err = PTR_ERR(cxt->przs[i]);
dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
sz, (unsigned long long)*paddr, err);
goto fail_prz;
}
*paddr += sz;
}
return 0;
fail_prz:
ramoops_free_przs(cxt);
return err;
}
static int ramoops_init_prz(struct device *dev, struct ramoops_context *cxt,
struct persistent_ram_zone **prz,
phys_addr_t *paddr, size_t sz, u32 sig)
{
if (!sz)
return 0;
if (*paddr + sz - cxt->phys_addr > cxt->size) {
dev_err(dev, "no room for mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n",
sz, (unsigned long long)*paddr,
cxt->size, (unsigned long long)cxt->phys_addr);
return -ENOMEM;
}
*prz = persistent_ram_new(*paddr, sz, sig, &cxt->ecc_info);
if (IS_ERR(*prz)) {
int err = PTR_ERR(*prz);
dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
sz, (unsigned long long)*paddr, err);
return err;
}
persistent_ram_zap(*prz);
*paddr += sz;
return 0;
}
void notrace <API key>(const char *buf, size_t size)
{
struct ramoops_context *cxt = &oops_cxt;
<API key>(cxt->cprz, buf, size);
}
static int ramoops_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct <API key> *pdata = pdev->dev.platform_data;
struct ramoops_context *cxt = &oops_cxt;
size_t dump_mem_sz;
phys_addr_t paddr;
int err = -EINVAL;
/* Only a single ramoops area allowed at a time, so fail extra
* probes.
*/
if (cxt->max_dump_cnt)
goto fail_out;
if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size &&
!pdata->ftrace_size)) {
pr_err("The memory size and the record/console size must be "
"non-zero\n");
goto fail_out;
}
if (!is_power_of_2(pdata->mem_size))
pdata->mem_size = <API key>(pdata->mem_size);
if (!is_power_of_2(pdata->record_size))
pdata->record_size = <API key>(pdata->record_size);
if (!is_power_of_2(pdata->console_size))
pdata->console_size = <API key>(pdata->console_size);
if (!is_power_of_2(pdata->ftrace_size))
pdata->ftrace_size = <API key>(pdata->ftrace_size);
cxt->dump_read_cnt = 0;
cxt->size = pdata->mem_size;
cxt->phys_addr = pdata->mem_address;
cxt->record_size = pdata->record_size;
cxt->console_size = pdata->console_size;
cxt->ftrace_size = pdata->ftrace_size;
cxt->dump_oops = pdata->dump_oops;
cxt->ecc_info = pdata->ecc_info;
paddr = cxt->phys_addr;
dump_mem_sz = cxt->size - cxt->console_size - cxt->ftrace_size;
err = ramoops_init_przs(dev, cxt, &paddr, dump_mem_sz);
if (err)
goto fail_out;
err = ramoops_init_prz(dev, cxt, &cxt->cprz, &paddr,
cxt->console_size, 0);
if (err)
goto fail_init_cprz;
err = ramoops_init_prz(dev, cxt, &cxt->fprz, &paddr, cxt->ftrace_size,
LINUX_VERSION_CODE);
if (err)
goto fail_init_fprz;
if (!cxt->przs && !cxt->cprz && !cxt->fprz) {
pr_err("memory size too small, minimum is %zu\n",
cxt->console_size + cxt->record_size +
cxt->ftrace_size);
err = -EINVAL;
goto fail_cnt;
}
cxt->pstore.data = cxt;
/*
* Console can handle any buffer size, so prefer LOG_LINE_MAX. If we
* have to handle dumps, we must have at least record_size buffer. And
* for ftrace, bufsize is irrelevant (if bufsize is 0, buf will be
* ZERO_SIZE_PTR).
*/
if (cxt->console_size)
cxt->pstore.bufsize = 1024; /* LOG_LINE_MAX */
cxt->pstore.bufsize = max(cxt->record_size, cxt->pstore.bufsize);
cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL);
spin_lock_init(&cxt->pstore.buf_lock);
if (!cxt->pstore.buf) {
pr_err("cannot allocate pstore buffer\n");
err = -ENOMEM;
goto fail_clear;
}
err = pstore_register(&cxt->pstore);
if (err) {
pr_err("registering with pstore failed\n");
goto fail_buf;
}
/*
* Update the module parameter variables as well so they are visible
* through /sys/module/ramoops/parameters/
*/
mem_size = pdata->mem_size;
mem_address = pdata->mem_address;
record_size = pdata->record_size;
dump_oops = pdata->dump_oops;
pr_info("attached 0x%lx@0x%llx, ecc: %d/%d\n",
cxt->size, (unsigned long long)cxt->phys_addr,
cxt->ecc_info.ecc_size, cxt->ecc_info.block_size);
return 0;
fail_buf:
kfree(cxt->pstore.buf);
fail_clear:
cxt->pstore.bufsize = 0;
cxt->max_dump_cnt = 0;
fail_cnt:
kfree(cxt->fprz);
fail_init_fprz:
kfree(cxt->cprz);
fail_init_cprz:
ramoops_free_przs(cxt);
fail_out:
return err;
}
static int __exit ramoops_remove(struct platform_device *pdev)
{
#if 0
/* TODO(kees): We cannot unload ramoops since pstore doesn't support
* unregistering yet.
*/
struct ramoops_context *cxt = &oops_cxt;
iounmap(cxt->virt_addr);
release_mem_region(cxt->phys_addr, cxt->size);
cxt->max_dump_cnt = 0;
/* TODO(kees): When pstore supports unregistering, call it here. */
kfree(cxt->pstore.buf);
cxt->pstore.bufsize = 0;
return 0;
#endif
return -EBUSY;
}
static struct platform_driver ramoops_driver = {
.probe = ramoops_probe,
.remove = __exit_p(ramoops_remove),
.driver = {
.name = "ramoops",
.owner = THIS_MODULE,
},
};
static void <API key>(void)
{
if (!mem_size)
return;
pr_info("using module parameters\n");
dummy_data = kzalloc(sizeof(*dummy_data), GFP_KERNEL);
if (!dummy_data) {
pr_info("could not allocate pdata\n");
return;
}
dummy_data->mem_size = mem_size;
dummy_data->mem_address = mem_address;
dummy_data->record_size = record_size;
dummy_data->console_size = <API key>;
dummy_data->ftrace_size = ramoops_ftrace_size;
dummy_data->dump_oops = dump_oops;
/*
* For backwards compatibility ramoops.ecc=1 means 16 bytes ECC
* (using 1 byte for ECC isn't much of use anyway).
*/
dummy_data->ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc;
dummy = <API key>(NULL, "ramoops", -1,
dummy_data, sizeof(struct <API key>));
if (IS_ERR(dummy)) {
pr_info("could not create platform device: %ld\n",
PTR_ERR(dummy));
}
}
static int __init ramoops_init(void)
{
<API key>();
return <API key>(&ramoops_driver);
}
postcore_initcall(ramoops_init);
static void __exit ramoops_exit(void)
{
<API key>(&ramoops_driver);
<API key>(dummy);
kfree(dummy_data);
}
module_exit(ramoops_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Marco Stornelli <marco.stornelli@gmail.com>");
MODULE_DESCRIPTION("RAM Oops/Panic logger/driver"); |
# encoding: utf-8
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
pass
def backwards(self, orm):
pass
models = {}
complete_apps = ['mirrors'] |
<?php
/**
* Sparkling Top Posts Widget
* Sparkling Theme
*/
class <API key> extends WP_Widget
{
function <API key>(){
$widget_ops = array('classname' => '<API key>','description' => esc_html__( "Sparkling Popular Posts Widget", 'sparkling') );
$this->WP_Widget('<API key>', esc_html__('Sparkling Popular Posts Widget','sparkling'), $widget_ops);
}
function widget($args , $instance) {
extract($args);
$title = isset($instance['title']) ? $instance['title'] : esc_html__('Popular Posts', 'sparkling');
$limit = isset($instance['limit']) ? $instance['limit'] : 5;
echo $before_widget;
echo $before_title;
echo $title;
echo $after_title;
/**
* Widget Content
*/
?>
<!-- popular posts -->
<div class="<API key>">
<?php
$featured_args = array(
'posts_per_page' => $limit + 1 ,
'orderby' => 'comment_count',
'order' => 'DESC',
'ignore_sticky_posts' => 1
);
$featured_query = new WP_Query($featured_args);
/**
* Check if zilla likes plugin exists
*/
if($featured_query->have_posts()) : while($featured_query->have_posts()) : $featured_query->the_post();
?>
<?php if(get_the_content() != '') : ?>
<!-- post -->
<div class="post">
<!-- image -->
<div class="post-image <?php echo get_post_format(); ?>">
<a href="<?php echo get_permalink(); ?>"><?php
if(get_post_format() != 'quote') {
echo <API key>(get_the_ID() , 'tab-small');
}
?></a>
</div> <!-- end post image -->
<!-- content -->
<div class="post-content">
<a href="<?php echo get_permalink(); ?>"><?php echo get_the_title(); ?></a>
<span class="date"><?php echo get_the_date('d M , Y'); ?></span>
</div><!-- end content -->
</div><!-- end post -->
<?php endif; ?>
<?php
endwhile; endif; wp_reset_query();
?>
</div> <!-- end posts wrapper -->
<?php
echo $after_widget;
}
function form($instance) {
if(!isset($instance['title'])) $instance['title'] = esc_html__('Popular Posts', 'sparkling');
if(!isset($instance['limit'])) $instance['limit'] = 5;
?>
<p><label for="<?php echo $this->get_field_id('title'); ?>"><?php esc_html_e('Title', 'sparkling') ?></label>
<input type="text" value="<?php echo esc_attr($instance['title']); ?>"
name="<?php echo $this->get_field_name('title'); ?>"
id="<?php $this->get_field_id('title'); ?>"
class="widefat" />
</p>
<p><label for="<?php echo $this->get_field_id('limit'); ?>"><?php esc_html_e('Limit Posts Number', 'sparkling') ?></label>
<input type="text" value="<?php echo esc_attr($instance['limit']); ?>"
name="<?php echo $this->get_field_name('limit'); ?>"
id="<?php $this->get_field_id('limit'); ?>"
class="widefat" />
<p>
<?php
}
}
?> |
<?php get_header(); the_post(); global $post; ?>
<div id="post-single" class="post type-project">
<div class="container">
<div id="project-images">
<div class="image">
<img src="<?php echo esc_url(<API key>().'/demo/project-large.jpg') ?>" />
<div class="shadow"></div>
</div>
</div>
<div id="project-info">
<div class="separator first"></div>
<h1>
<?php _e('This is A Demo Project', 'pitch') ?>
</h1>
<div class="separator"></div>
<p class="excerpt">
<?php _e('This is the excerpt. You can add a little description about your project here.', 'pitch') ?>
</p>
<div class="separator light"></div>
<div class="content entry-content">
<p>
<?php _e("This is the project content, you can add a whole load of content here. It'll show up, complete with formatting and all that cool stuff.", 'pitch') ?>
</p>
<p>
<?php _e("This demo project will stop showing up on your site when you add your first real project or when you disable projects entirely - but why would you do that?", 'pitch') ?>
</p>
<p>Donec tempus eros in nibh lacinia convallis. Pellentesque non purus elementum elit vestibulum facilisis non dictum nisi. Pellentesque habitant morbi tristique senectu.</p>
<p>Et netus et malesuada fames ac turpis egestas. Cras adipiscing vulputate ante et bibendum. Donec consequat congue urna, nec hendrerit sapien varius in. Integer ut pretium orci. Quisque vitae nulla leo.</p>
</div>
<div class="separator light"></div>
</div>
<div class="clear"></div>
<div id="related-projects">
<?php get_template_part('demo/homeloop', 'project') ?>
</div>
</div>
</div>
<?php get_footer(); ?> |
#ifndef MACROSCOPE_H
#define MACROSCOPE_H
#include "macrotab.h"
#include "symtab.h"
/* The table of macros defined by the user. */
extern struct macro_table *macro_user_macros;
/* All the information we need to decide which macro definitions are
in scope: a source file (either a main source file or an
#inclusion), and a line number in that file. */
struct macro_scope {
struct macro_source_file *file;
int line;
};
/* Return a `struct macro_scope' object corresponding to the symtab
and line given in SAL. If we have no macro information for that
location, or if SAL's pc is zero, return zero. */
struct macro_scope *sal_macro_scope (struct symtab_and_line sal);
/* Return a `struct macro_scope' object representing just the
user-defined macros. The result is allocated using xmalloc; the
caller is responsible for freeing it. */
struct macro_scope *user_macro_scope (void);
/* Return a `struct macro_scope' object describing the scope the `macro
expand' and `macro expand-once' commands should use for looking up
macros. If we have a selected frame, this is the source location of
its PC; otherwise, this is the last listing position.
If we have no macro information for the current location, return
the user macro scope.
The object returned is allocated using xmalloc; the caller is
responsible for freeing it. */
struct macro_scope *default_macro_scope (void);
/* Look up the definition of the macro named NAME in scope at the source
location given by BATON, which must be a pointer to a `struct
macro_scope' structure. This function is suitable for use as
a macro_lookup_ftype function. */
struct macro_definition *<API key> (const char *name, void *baton);
#endif /* MACROSCOPE_H */ |
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="Description" content="Cynthia">
<meta name="Keywords" content="Cynthia,BUG, ,,,BUG,,">
<title>Cynthia !</title>
<link href="../lib/bootstrap2/css/bootstrap.min.css" rel="stylesheet" type="text/css">
<link href="../lib/bootstrap2/css/<API key>.min.css" rel="stylesheet" type="text/css">
<link href="../lib/g_bootstrap/css/google-bootstrap.css" rel="stylesheet" type="text/css">
<link href="../css/admin.css" rel="stylesheet" type="text/css">
<link href="../lib/jquery.plugins/tablesorter/style.css" rel="stylesheet" type="text/css" />
<link href='../lib/select2/select2.css' rel="stylesheet" style="text/css">
<script type="text/javascript" src='../lib/jquery/jquery-1.9.3.min.js'></script>
<script type="text/javascript" src='../lib/bootstrap2/js/bootstrap.cynthia.min.js'></script>
<script type="text/javascript" src="../js/util.js"></script>
<script type="text/javascript" src="../js/admin/admin_user.js"></script>
<script type="text/javascript" src="../lib/jquery.plugins/tablesorter/jquery.tablesorter.js"></script>
<script type="text/javascript" src='../lib/select2/select2.js'></script>
<script type="text/javascript" src='../js/md5.js'></script>
</head>
<body>
<div class="container-fluid">
<div class="row-fluid">
<div class="span12 template_toolbar">
<button class="btn btn-danger btn-create <API key>" type="button" onclick="displayCreateDiv()"></button>
<select class="<API key>" id ="searchType" style="margin-bottom:0px;width:80px;line-height:24px;">
<option value=''></option>
<option value='normal'></option>
<option value='lock'></option>
<option value='not_auth'></option>
</select>
<input id="searchWord" style="margin-bottom:0px;" type="text" placeholder="">
<button class="btn btn-info" type="button" id="searchUserBtn">go</button>
</div>
</div>
<div class="row-fluid">
<div class="span12">
<table class="tablesorter table table-hover table-striped" id="userListGrid">
<thead>
<tr>
<th></th><th></th><th></th><th></th><th></th><th></th>
</tr>
</thead>
<tbody>
</tbody>
</table>
</div>
</div>
</div>
<!-- div -->
<div id="addOrModifyUserDiv" class="modal hide fade" tabindex="-1" role="dialog" aria-labelledby="tag modal" aria-hidden="true">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
<h5 id="myModalLabel"></h5>
</div>
<div class="modal-body">
<form class="form-horizontal">
<div class="control-group">
<p id="msgInfo" style="color:red"></p>
<label class="control-label" for="input_name">:</label>
<div class="controls">
<input type="hidden" id="input_user_id"/>
<input type="text" id="input_name"/>
</div>
</div>
<div class="control-group">
<label class="control-label" for="input_email" >:</label>
<div class="controls">
<input type="text" id="input_email" disabled="disabled"/>
</div>
</div>
<div class="control-group">
<label class="control-label" for="input_email_m" >:</label>
<div class="controls">
<fieldset>
<label class="radio">
<input type="radio" name="input_role" value="normal" checked/>
</label>
<label class="radio">
<input type="radio" name="input_role" value="admin"/>
</label>
<label id = "super_role" class="radio">
<input type="radio" name="input_role" value="super_admin"/>
</label>
</fieldset>
</div>
</div>
<div class="control-group">
<label class="control-label" for="input_pass" >:</label>
<div class="controls">
<input type="password" id="input_pass"/>
</div>
</div>
<div class="control-group">
<label class="control-label" for="input_pass_again" >:</label>
<div class="controls">
<input type="password" id="input_pass_again"/>
</div>
</div>
<!-- <div class="control-group"> -->
<!-- <label class="control-label" for="input_isquit_m">:</label> -->
<!-- <div class="controls"> -->
<!-- <label class="radio inline" style="margin-right:10px;"><input type="radio" name="input_isquit_m" value="true"></label> -->
<!-- <label class="radio inline" style="margin-right:10px;"><input type="radio" name="input_isquit_m" value="false"></label> -->
<!-- </div> -->
<!-- </div> -->
</form>
</div>
<div class="modal-footer">
<button class="btn" data-dismiss="modal" aria-hidden="true"></button>
<button class="btn btn-primary" onclick="addOrModifyUser()"></button>
</div>
</div>
<div id="userTemRightDiv" class="modal hide fade" tabindex="-1" role="dialog" aria-labelledby="tag modal" aria-hidden="true">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
<h5></h5>
</div>
<div class="modal-body">
<input type="hidden" id = "userMail"/>
<input type="button" class="btn btn-danger" value="" onclick="initAllTemplate();"/>
<table style="margin-top:10px;" class="tablesorter table table-hover table-striped">
<thead>
<tr>
<th></th><th></th><th></th>
</tr>
</thead>
<tbody id="temRightBody">
</tbody>
</table>
</div>
<div class="modal-footer">
<button class="btn btn-primary" data-dismiss="modal" aria-hidden="true"></button>
</div>
</div>
<div id="initAllTemDiv" class="modal hide fade" tabindex="-1" role="dialog" aria-labelledby="tag modal" aria-hidden="true">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
<h5 id="initAllTitle"></h5>
</div>
<div class="modal-body">
<form class="form-horizontal">
<input type="hidden" id="userTemMail"/>
<div class="control-group">
<label style="width:120px;" class="control-label" for="chooseTemplate">:</label>
<div class="controls">
<select style="width:250px; margin-left:-50px;" multiple id= "chooseTemplate">
</select>
</div>
</div>
</form>
</div>
<div class="modal-footer">
<button class="btn" data-dismiss="modal" aria-hidden="true"></button>
<button class="btn btn-danger" onclick="addUserTemplate();"></button>
</div>
</div>
</body>
</html> |
#include <linux/interrupt.h>
#include <linux/module.h>
#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
#include <net/bluetooth/l2cap.h>
#include <net/bluetooth/mgmt.h>
#include <net/bluetooth/smp.h>
#include <linux/crypto.h>
#include <crypto/b128ops.h>
#include <asm/unaligned.h>
#define SMP_TIMEOUT 30000 /* 30 seconds */
#define <API key> 40 /* 50ms (40 * 1.25ms) */
#define <API key> 56 /* 70ms (56 * 1.25ms) */
#define <API key> 0 /* 0ms (0 * 1.25ms) */
#define <API key> 500 /* 5 seconds (500 * 10ms) */
#ifndef FALSE
#define FALSE 0
#define TRUE (!FALSE)
#endif
static int smp_distribute_keys(struct l2cap_conn *conn, __u8 force);
static inline void swap128(u8 src[16], u8 dst[16])
{
int i;
for (i = 0; i < 16; i++)
dst[15 - i] = src[i];
}
static inline void swap56(u8 src[7], u8 dst[7])
{
int i;
for (i = 0; i < 7; i++)
dst[6 - i] = src[i];
}
static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
{
struct blkcipher_desc desc;
struct scatterlist sg;
int err, iv_len;
unsigned char iv[128];
if (tfm == NULL) {
BT_ERR("tfm %p", tfm);
return -EINVAL;
}
desc.tfm = tfm;
desc.flags = 0;
err = <API key>(tfm, k, 16);
if (err) {
BT_ERR("cipher setkey failed: %d", err);
return err;
}
sg_init_one(&sg, r, 16);
iv_len = <API key>(tfm);
if (iv_len) {
memset(&iv, 0xff, iv_len);
<API key>(tfm, iv, iv_len);
}
err = <API key>(&desc, &sg, &sg, 16);
if (err)
BT_ERR("Encrypt data error %d", err);
return err;
}
static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16],
u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia,
u8 _rat, bdaddr_t *ra, u8 res[16])
{
u8 p1[16], p2[16];
int err;
memset(p1, 0, 16);
/* p1 = pres || preq || _rat || _iat */
swap56(pres, p1);
swap56(preq, p1 + 7);
p1[14] = _rat;
p1[15] = _iat;
memset(p2, 0, 16);
/* p2 = padding || ia || ra */
baswap((bdaddr_t *) (p2 + 4), ia);
baswap((bdaddr_t *) (p2 + 10), ra);
/* res = r XOR p1 */
u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
/* res = e(k, res) */
err = smp_e(tfm, k, res);
if (err) {
BT_ERR("Encrypt data error");
return err;
}
/* res = res XOR p2 */
u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
/* res = e(k, res) */
err = smp_e(tfm, k, res);
if (err)
BT_ERR("Encrypt data error");
return err;
}
static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16],
u8 r1[16], u8 r2[16], u8 _r[16])
{
int err;
/* Just least significant octets from r1 and r2 are considered */
memcpy(_r, r1 + 8, 8);
memcpy(_r + 8, r2 + 8, 8);
err = smp_e(tfm, k, _r);
if (err)
BT_ERR("Encrypt data error");
return err;
}
static int smp_rand(u8 *buf)
{
get_random_bytes(buf, 16);
return 0;
}
static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code,
u16 dlen, void *data)
{
struct sk_buff *skb;
struct l2cap_hdr *lh;
int len;
len = L2CAP_HDR_SIZE + sizeof(code) + dlen;
if (len > conn->mtu)
return NULL;
skb = bt_skb_alloc(len, GFP_ATOMIC);
if (!skb)
return NULL;
lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
lh->len = cpu_to_le16(sizeof(code) + dlen);
lh->cid = cpu_to_le16(L2CAP_CID_SMP);
memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code));
memcpy(skb_put(skb, dlen), data, dlen);
return skb;
}
static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
{
struct sk_buff *skb = smp_build_cmd(conn, code, len, data);
BT_DBG("code 0x%2.2x", code);
if (!skb)
return;
hci_send_acl(conn->hcon, NULL, skb, 0);
}
static __u8 authreq_to_seclevel(__u8 authreq)
{
if (authreq & SMP_AUTH_MITM)
return BT_SECURITY_HIGH;
else if (authreq & SMP_AUTH_BONDING)
return BT_SECURITY_MEDIUM;
else
return BT_SECURITY_LOW;
}
static __u8 seclevel_to_authreq(__u8 level)
{
switch (level) {
case <API key>:
case BT_SECURITY_HIGH:
return SMP_AUTH_MITM | SMP_AUTH_BONDING;
default:
return SMP_AUTH_NONE;
}
}
static void build_pairing_cmd(struct l2cap_conn *conn,
struct smp_cmd_pairing *req,
struct smp_cmd_pairing *rsp,
__u8 authreq)
{
struct hci_conn *hcon = conn->hcon;
u8 all_keys = 0;
u8 dist_keys = 0;
dist_keys = SMP_DIST_ENC_KEY;
authreq |= SMP_AUTH_BONDING;
BT_DBG("conn->hcon->io_capability:%d", conn->hcon->io_capability);
if (rsp == NULL) {
req->io_capability = conn->hcon->io_capability;
req->oob_flag = hcon->oob ? SMP_OOB_PRESENT :
SMP_OOB_NOT_PRESENT;
req->max_key_size = <API key>;
req->init_key_dist = all_keys;
req->resp_key_dist = dist_keys;
req->auth_req = authreq;
BT_DBG("SMP_CMD_PAIRING_REQ %d %d %d %d %2.2x %2.2x",
req->io_capability, req->oob_flag,
req->auth_req, req->max_key_size,
req->init_key_dist, req->resp_key_dist);
return;
}
/* Only request OOB if remote AND we support it */
if (req->oob_flag)
rsp->oob_flag = hcon->oob ? SMP_OOB_PRESENT :
SMP_OOB_NOT_PRESENT;
else
rsp->oob_flag = SMP_OOB_NOT_PRESENT;
rsp->io_capability = conn->hcon->io_capability;
rsp->max_key_size = <API key>;
rsp->init_key_dist = req->init_key_dist & all_keys;
rsp->resp_key_dist = req->resp_key_dist & dist_keys;
rsp->auth_req = authreq;
BT_DBG("SMP_CMD_PAIRING_RSP %d %d %d %d %2.2x %2.2x",
req->io_capability, req->oob_flag, req->auth_req,
req->max_key_size, req->init_key_dist,
req->resp_key_dist);
}
static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
{
struct hci_conn *hcon = conn->hcon;
if ((max_key_size > <API key>) ||
(max_key_size < <API key>))
return SMP_ENC_KEY_SIZE;
hcon->smp_key_size = max_key_size;
return 0;
}
#define JUST_WORKS SMP_JUST_WORKS
#define REQ_PASSKEY SMP_REQ_PASSKEY
#define CFM_PASSKEY SMP_CFM_PASSKEY
#define JUST_CFM SMP_JUST_CFM
#define OVERLAP SMP_OVERLAP
static const u8 gen_method[5][5] = {
{JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY},
{JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY},
{CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY},
{JUST_WORKS, JUST_CFM, JUST_WORKS, JUST_WORKS, JUST_CFM},
{CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP}
};
static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
u8 local_io, u8 remote_io)
{
struct hci_conn *hcon = conn->hcon;
u8 method;
u32 passkey = 0;
int ret = 0;
/* Initialize key to JUST WORKS */
memset(hcon->tk, 0, sizeof(hcon->tk));
hcon->tk_valid = FALSE;
hcon->auth = auth;
/* By definition, OOB data will be used if both sides have it available
*/
if (remote_oob && hcon->oob) {
method = SMP_REQ_OOB;
goto agent_request;
}
BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
/* If neither side wants MITM, use JUST WORKS */
/* If either side has unknown io_caps, use JUST_WORKS */
if (!(auth & SMP_AUTH_MITM) ||
local_io > <API key> ||
remote_io > <API key>) {
hcon->auth &= ~SMP_AUTH_MITM;
hcon->tk_valid = TRUE;
return 0;
}
/* MITM is now officially requested, but not required */
/* Determine what we need (if anything) from the agent */
method = gen_method[local_io][remote_io];
BT_DBG("tk_method: %d", method);
if (method == SMP_JUST_WORKS || method == SMP_JUST_CFM)
hcon->auth &= ~SMP_AUTH_MITM;
/* Don't bother confirming unbonded JUST_WORKS */
if (!(auth & SMP_AUTH_BONDING) && method == SMP_JUST_CFM) {
hcon->tk_valid = TRUE;
return 0;
} else if (method == SMP_JUST_WORKS) {
hcon->tk_valid = TRUE;
return 0;
} else if (method == SMP_OVERLAP) {
if (hcon->link_mode & HCI_LM_MASTER)
method = SMP_CFM_PASSKEY;
else
method = SMP_REQ_PASSKEY;
}
BT_DBG("tk_method-2: %d", method);
if (method == SMP_CFM_PASSKEY) {
u8 key[16];
/* Generate a passkey for display. It is not valid until
* confirmed.
*/
memset(key, 0, sizeof(key));
get_random_bytes(&passkey, sizeof(passkey));
passkey %= 1000000;
put_unaligned_le32(passkey, key);
swap128(key, hcon->tk);
BT_DBG("PassKey: %d", passkey);
}
agent_request:
hci_dev_lock(hcon->hdev);
switch (method) {
case SMP_REQ_PASSKEY:
ret = <API key>(hcon->hdev->id,
<API key>, conn->dst, 0);
break;
case SMP_CFM_PASSKEY:
default:
ret = <API key>(hcon->hdev->id,
<API key>, conn->dst, passkey);
break;
}
hci_dev_unlock(hcon->hdev);
return ret;
}
static int <API key>(struct l2cap_conn *conn)
{
struct hci_conn *hcon = conn->hcon;
struct crypto_blkcipher *tfm = hcon->hdev->tfm;
struct <API key> cp;
int ret;
u8 res[16];
if (conn->hcon->out)
ret = smp_c1(tfm, hcon->tk, hcon->prnd, hcon->preq, hcon->prsp,
0, conn->src, hcon->dst_type, conn->dst, res);
else
ret = smp_c1(tfm, hcon->tk, hcon->prnd, hcon->preq, hcon->prsp,
hcon->dst_type, conn->dst, 0, conn->src, res);
if (ret)
return SMP_CONFIRM_FAILED;
swap128(res, cp.confirm_val);
hcon->cfm_pending = FALSE;
smp_send_cmd(conn, <API key>, sizeof(cp), &cp);
return 0;
}
int <API key>(struct hci_conn *hcon, u16 mgmt_op, void *cp)
{
struct <API key> *psk_reply = cp;
struct l2cap_conn *conn = hcon->smp_conn;
u8 key[16];
u8 reason = 0;
int ret = 0;
BT_DBG("");
hcon->tk_valid = TRUE;
switch (mgmt_op) {
case <API key>:
reason = SMP_CONFIRM_FAILED;
break;
case <API key>:
break;
case <API key>:
memset(key, 0, sizeof(key));
BT_DBG("PassKey: %d", psk_reply->passkey);
put_unaligned_le32(psk_reply->passkey, key);
swap128(key, hcon->tk);
break;
default:
reason = SMP_CONFIRM_FAILED;
ret = -EOPNOTSUPP;
break;
}
if (reason) {
BT_DBG("smp_send_cmd: <API key>");
smp_send_cmd(conn, <API key>, sizeof(reason),
&reason);
del_timer(&hcon->smp_timer);
if (hcon->disconn_cfm_cb)
hcon->disconn_cfm_cb(hcon, SMP_UNSPECIFIED);
clear_bit(<API key>, &hcon->pend);
mgmt_auth_failed(hcon->hdev->id, conn->dst, reason);
hci_conn_put(hcon);
} else if (hcon->cfm_pending) {
BT_DBG("<API key>");
ret = <API key>(conn);
}
return ret;
}
static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
struct smp_cmd_pairing rsp, *req = (void *) skb->data;
u8 key_size;
u8 auth = SMP_AUTH_NONE;
int ret;
BT_DBG("conn %p", conn);
hcon->preq[0] = SMP_CMD_PAIRING_REQ;
memcpy(&hcon->preq[1], req, sizeof(*req));
skb_pull(skb, sizeof(*req));
if (req->oob_flag && hcon->oob) {
/* By definition, OOB data pairing will have MITM protection */
auth = req->auth_req | SMP_AUTH_MITM;
} else if (req->auth_req & SMP_AUTH_BONDING) {
/* We will attempt MITM for all Bonding attempts */
<API key> | SMP_AUTH_MITM;
}
/* We didn't start the pairing, so no requirements */
build_pairing_cmd(conn, req, &rsp, auth);
key_size = min(req->max_key_size, rsp.max_key_size);
if (check_enc_key_size(conn, key_size))
return SMP_ENC_KEY_SIZE;
ret = smp_rand(hcon->prnd);
if (ret)
return SMP_UNSPECIFIED;
/* Request setup of TK */
ret = tk_request(conn, req->oob_flag, auth, rsp.io_capability,
req->io_capability);
if (ret)
return SMP_UNSPECIFIED;
hcon->prsp[0] = SMP_CMD_PAIRING_RSP;
memcpy(&hcon->prsp[1], &rsp, sizeof(rsp));
smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
mod_timer(&hcon->smp_timer, jiffies + msecs_to_jiffies(SMP_TIMEOUT));
return 0;
}
static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
u8 key_size, auth = SMP_AUTH_NONE;
int ret;
BT_DBG("conn %p", conn);
skb_pull(skb, sizeof(*rsp));
req = (void *) &hcon->preq[1];
key_size = min(req->max_key_size, rsp->max_key_size);
if (check_enc_key_size(conn, key_size))
return SMP_ENC_KEY_SIZE;
hcon->prsp[0] = SMP_CMD_PAIRING_RSP;
memcpy(&hcon->prsp[1], rsp, sizeof(*rsp));
ret = smp_rand(hcon->prnd);
if (ret)
return SMP_UNSPECIFIED;
if ((req->auth_req & SMP_AUTH_BONDING) &&
(rsp->auth_req & SMP_AUTH_BONDING))
<API key>;
auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM;
ret = tk_request(conn, req->oob_flag, auth, rsp->io_capability,
req->io_capability);
if (ret)
return SMP_UNSPECIFIED;
hcon->cfm_pending = TRUE;
/* Can't compose response until we have been confirmed */
if (!hcon->tk_valid)
return 0;
ret = <API key>(conn);
if (ret)
return SMP_CONFIRM_FAILED;
return 0;
}
static u8 <API key>(struct l2cap_conn *conn, struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
int ret;
BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
memcpy(hcon->pcnf, skb->data, sizeof(hcon->pcnf));
skb_pull(skb, sizeof(hcon->pcnf));
if (conn->hcon->out) {
u8 random[16];
swap128(hcon->prnd, random);
smp_send_cmd(conn, <API key>, sizeof(random),
random);
} else if (hcon->tk_valid) {
ret = <API key>(conn);
if (ret)
return SMP_CONFIRM_FAILED;
} else
hcon->cfm_pending = TRUE;
mod_timer(&hcon->smp_timer, jiffies + msecs_to_jiffies(SMP_TIMEOUT));
return 0;
}
static u8 <API key>(struct l2cap_conn *conn, struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
struct crypto_blkcipher *tfm = hcon->hdev->tfm;
int ret;
u8 key[16], res[16], random[16], confirm[16];
swap128(skb->data, random);
skb_pull(skb, sizeof(random));
if (conn->hcon->out)
ret = smp_c1(tfm, hcon->tk, random, hcon->preq, hcon->prsp, 0,
conn->src, hcon->dst_type, conn->dst,
res);
else
ret = smp_c1(tfm, hcon->tk, random, hcon->preq, hcon->prsp,
hcon->dst_type, conn->dst, 0, conn->src,
res);
if (ret)
return SMP_UNSPECIFIED;
BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
swap128(res, confirm);
if (memcmp(hcon->pcnf, confirm, sizeof(hcon->pcnf)) != 0) {
BT_ERR("Pairing failed (confirmation values mismatch)");
return SMP_CONFIRM_FAILED;
}
if (conn->hcon->out) {
u8 stk[16], rand[8];
__le16 ediv;
memset(rand, 0, sizeof(rand));
ediv = 0;
smp_s1(tfm, hcon->tk, random, hcon->prnd, key);
swap128(key, stk);
memset(stk + hcon->smp_key_size, 0,
<API key> - hcon->smp_key_size);
hci_le_start_enc(hcon, ediv, rand, stk);
hcon->enc_key_size = hcon->smp_key_size;
} else {
u8 stk[16], r[16], rand[8];
__le16 ediv;
memset(rand, 0, sizeof(rand));
ediv = 0;
swap128(hcon->prnd, r);
smp_send_cmd(conn, <API key>, sizeof(r), r);
smp_s1(tfm, hcon->tk, hcon->prnd, random, key);
swap128(key, stk);
memset(stk + hcon->smp_key_size, 0,
<API key> - hcon->smp_key_size);
hci_add_ltk(conn->hcon->hdev, 0, conn->dst, hcon->dst_type,
hcon->smp_key_size, hcon->auth, ediv, rand, stk);
}
return 0;
}
static int smp_encrypt_link(struct hci_conn *hcon, struct link_key *key)
{
struct key_master_id *master;
u8 sec_level;
u8 zerobuf[8];
if (!hcon || !key || !key->data)
return -EINVAL;
memset(zerobuf, 0, sizeof(zerobuf));
master = (void *) key->data;
if (!master->ediv && !memcmp(master->rand, zerobuf, sizeof(zerobuf)))
return -EINVAL;
hcon->enc_key_size = key->pin_len;
hcon->sec_req = TRUE;
sec_level = authreq_to_seclevel(key->auth);
BT_DBG("cur %d, req: %d", hcon->sec_level, sec_level);
if (sec_level > hcon->sec_level)
hcon->pending_sec_level = sec_level;
if (!(hcon->link_mode & HCI_LM_ENCRYPT))
hci_conn_hold(hcon);
hci_le_start_enc(hcon, master->ediv, master->rand, key->val);
return 0;
}
static u8 <API key>(struct l2cap_conn *conn, struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
struct <API key> *rp = (void *) skb->data;
struct smp_cmd_pairing cp;
struct link_key *key;
BT_DBG("conn %p", conn);
if (test_bit(<API key>, &hcon->pend))
return 0;
key = <API key>(hcon->hdev, conn->dst, KEY_TYPE_LTK);
if (key && ((key->auth & SMP_AUTH_MITM) ||
!(rp->auth_req & SMP_AUTH_MITM))) {
if (smp_encrypt_link(hcon, key) < 0)
goto invalid_key;
return 0;
}
invalid_key:
hcon->sec_req = FALSE;
/* Switch to Pairing Connection Parameters */
hci_le_conn_update(hcon, <API key>, <API key>,
<API key>, <API key>);
skb_pull(skb, sizeof(*rp));
memset(&cp, 0, sizeof(cp));
build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req);
hcon->preq[0] = SMP_CMD_PAIRING_REQ;
memcpy(&hcon->preq[1], &cp, sizeof(cp));
smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
mod_timer(&hcon->smp_timer, jiffies + msecs_to_jiffies(SMP_TIMEOUT));
set_bit(<API key>, &hcon->pend);
hci_conn_hold(hcon);
return 0;
}
int smp_conn_security(struct l2cap_conn *conn, __u8 sec_level)
{
struct hci_conn *hcon = conn->hcon;
__u8 authreq;
BT_DBG("conn %p hcon %p %d req: %d",
conn, hcon, hcon->sec_level, sec_level);
if (IS_ERR(hcon->hdev->tfm))
return 1;
if (test_bit(<API key>, &hcon->pend))
return -EINPROGRESS;
if (sec_level == BT_SECURITY_LOW)
return 1;
if (hcon->sec_level >= sec_level)
return 1;
authreq = seclevel_to_authreq(sec_level);
hcon->smp_conn = conn;
hcon->pending_sec_level = sec_level;
if (hcon->link_mode & HCI_LM_MASTER) {
struct link_key *key;
key = <API key>(hcon->hdev, conn->dst,
KEY_TYPE_LTK);
if (smp_encrypt_link(hcon, key) == 0)
goto done;
}
hcon->sec_req = FALSE;
if (hcon->link_mode & HCI_LM_MASTER) {
struct smp_cmd_pairing cp;
/* Switch to Pairing Connection Parameters */
hci_le_conn_update(hcon, <API key>,
<API key>, <API key>,
<API key>);
build_pairing_cmd(conn, &cp, NULL, authreq);
hcon->preq[0] = SMP_CMD_PAIRING_REQ;
memcpy(&hcon->preq[1], &cp, sizeof(cp));
mod_timer(&hcon->smp_timer, jiffies +
msecs_to_jiffies(SMP_TIMEOUT));
smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
hci_conn_hold(hcon);
} else {
struct <API key> cp;
cp.auth_req = authreq;
smp_send_cmd(conn, <API key>, sizeof(cp), &cp);
}
done:
set_bit(<API key>, &hcon->pend);
return 0;
}
static int <API key>(struct l2cap_conn *conn, struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
struct <API key> *rp = (void *) skb->data;
u8 rand[8];
int err;
skb_pull(skb, sizeof(*rp));
BT_DBG("conn %p", conn);
memset(rand, 0, sizeof(rand));
err = hci_add_ltk(hcon->hdev, 0, conn->dst, hcon->dst_type,
0, 0, 0, rand, rp->ltk);
if (err)
return SMP_UNSPECIFIED;
return 0;
}
static int <API key>(struct l2cap_conn *conn, struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
struct <API key> *rp = (void *) skb->data;
struct smp_cmd_pairing *paircmd = (void *) &hcon->prsp[1];
struct link_key *key;
u8 *keydist;
skb_pull(skb, sizeof(*rp));
key = <API key>(hcon->hdev, conn->dst, KEY_TYPE_LTK);
if (key == NULL)
return SMP_UNSPECIFIED;
if (hcon->out)
keydist = &paircmd->resp_key_dist;
else
keydist = &paircmd->init_key_dist;
BT_DBG("keydist 0x%x", *keydist);
hci_add_ltk(hcon->hdev, 1, conn->dst, hcon->dst_type,
hcon->smp_key_size, hcon->auth, rp->ediv,
rp->rand, key->val);
*keydist &= ~SMP_DIST_ENC_KEY;
if (hcon->out) {
if (!(*keydist))
smp_distribute_keys(conn, 1);
}
return 0;
}
int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
__u8 code = skb->data[0];
__u8 reason;
int err = 0;
if (IS_ERR(hcon->hdev->tfm)) {
err = PTR_ERR(hcon->hdev->tfm);
reason = SMP_PAIRING_NOTSUPP;
BT_ERR("SMP_PAIRING_NOTSUPP %p", hcon->hdev->tfm);
goto done;
}
hcon->smp_conn = conn;
skb_pull(skb, sizeof(code));
switch (code) {
case SMP_CMD_PAIRING_REQ:
reason = smp_cmd_pairing_req(conn, skb);
break;
case <API key>:
reason = 0;
err = -EPERM;
del_timer(&hcon->smp_timer);
clear_bit(<API key>, &hcon->pend);
mgmt_auth_failed(hcon->hdev->id, conn->dst, skb->data[0]);
hci_conn_put(hcon);
break;
case SMP_CMD_PAIRING_RSP:
reason = smp_cmd_pairing_rsp(conn, skb);
break;
case <API key>:
reason = <API key>(conn, skb);
break;
case <API key>:
reason = <API key>(conn, skb);
break;
case <API key>:
reason = <API key>(conn, skb);
break;
case <API key>:
reason = <API key>(conn, skb);
break;
case <API key>:
reason = <API key>(conn, skb);
break;
case SMP_CMD_IDENT_INFO:
case <API key>:
case SMP_CMD_SIGN_INFO:
/* Just ignored */
reason = 0;
break;
default:
BT_DBG("Unknown command code 0x%2.2x", code);
reason = SMP_CMD_NOTSUPP;
err = -EOPNOTSUPP;
goto done;
}
done:
if (reason) {
BT_ERR("<API key>: %d", reason);
smp_send_cmd(conn, <API key>, sizeof(reason),
&reason);
del_timer(&hcon->smp_timer);
clear_bit(<API key>, &hcon->pend);
mgmt_auth_failed(hcon->hdev->id, conn->dst, reason);
hci_conn_put(hcon);
}
kfree_skb(skb);
return err;
}
static int smp_distribute_keys(struct l2cap_conn *conn, __u8 force)
{
struct hci_conn *hcon = conn->hcon;
struct smp_cmd_pairing *req, *rsp;
__u8 *keydist;
BT_DBG("conn %p force %d", conn, force);
if (IS_ERR(hcon->hdev->tfm))
return PTR_ERR(hcon->hdev->tfm);
rsp = (void *) &hcon->prsp[1];
/* The responder sends its keys first */
if (!force && hcon->out && (rsp->resp_key_dist & 0x07))
return 0;
req = (void *) &hcon->preq[1];
if (hcon->out) {
keydist = &rsp->init_key_dist;
*keydist &= req->init_key_dist;
} else {
keydist = &rsp->resp_key_dist;
*keydist &= req->resp_key_dist;
}
BT_DBG("keydist 0x%x", *keydist);
if (*keydist & SMP_DIST_ENC_KEY) {
struct <API key> enc;
struct <API key> ident;
__le16 ediv;
get_random_bytes(enc.ltk, sizeof(enc.ltk));
get_random_bytes(&ediv, sizeof(ediv));
get_random_bytes(ident.rand, sizeof(ident.rand));
smp_send_cmd(conn, <API key>, sizeof(enc), &enc);
hci_add_ltk(hcon->hdev, 1, conn->dst, hcon->dst_type,
hcon->smp_key_size, hcon->auth, ediv,
ident.rand, enc.ltk);
ident.ediv = cpu_to_le16(ediv);
smp_send_cmd(conn, <API key>, sizeof(ident), &ident);
*keydist &= ~SMP_DIST_ENC_KEY;
}
if (*keydist & SMP_DIST_ID_KEY) {
struct <API key> addrinfo;
struct smp_cmd_ident_info idinfo;
/* Send a dummy key */
get_random_bytes(idinfo.irk, sizeof(idinfo.irk));
smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
/* Just public address */
memset(&addrinfo, 0, sizeof(addrinfo));
bacpy(&addrinfo.bdaddr, conn->src);
smp_send_cmd(conn, <API key>, sizeof(addrinfo),
&addrinfo);
*keydist &= ~SMP_DIST_ID_KEY;
}
if (*keydist & SMP_DIST_SIGN) {
struct smp_cmd_sign_info sign;
/* Send a dummy key */
get_random_bytes(sign.csrk, sizeof(sign.csrk));
smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
*keydist &= ~SMP_DIST_SIGN;
}
if (hcon->out) {
if (hcon->disconn_cfm_cb)
hcon->disconn_cfm_cb(hcon, 0);
del_timer(&hcon->smp_timer);
clear_bit(<API key>, &hcon->pend);
hci_conn_put(hcon);
} else if (rsp->resp_key_dist) {
if (hcon->disconn_cfm_cb)
hcon->disconn_cfm_cb(hcon, SMP_UNSPECIFIED);
clear_bit(<API key>, &hcon->pend);
mgmt_auth_failed(hcon->hdev->id, conn->dst, SMP_UNSPECIFIED);
hci_conn_put(hcon);
}
return 0;
}
void <API key>(struct l2cap_conn *conn, u8 code, u8 reason)
{
BT_DBG("smp: %d %d ", code, reason);
smp_send_cmd(conn, <API key>, sizeof(reason), &reason);
}
int <API key>(struct l2cap_conn *conn, u8 status, u8 encrypt)
{
struct hci_conn *hcon = conn->hcon;
BT_DBG("smp: %d %d %d", status, encrypt, hcon->sec_req);
clear_bit(<API key>, &hcon->pend);
if (!status && encrypt && hcon->sec_level < hcon->pending_sec_level)
hcon->sec_level = hcon->pending_sec_level;
if (!status && encrypt && !hcon->sec_req)
return smp_distribute_keys(conn, 0);
/* Fall back to Pairing request if failed a Link Security request */
else if (hcon->sec_req && (status || !encrypt))
smp_conn_security(conn, hcon->pending_sec_level);
hci_conn_put(hcon);
return 0;
}
void smp_timeout(unsigned long arg)
{
struct l2cap_conn *conn = (void *) arg;
u8 reason = SMP_UNSPECIFIED;
BT_DBG("%p", conn);
smp_send_cmd(conn, <API key>, sizeof(reason), &reason);
clear_bit(<API key>, &conn->hcon->pend);
mgmt_auth_failed(conn->hcon->hdev->id, conn->dst, SMP_UNSPECIFIED);
hci_conn_put(conn->hcon);
} |
include $(TOPDIR)/rules.mk
PKG_NAME:=zabbix
PKG_VERSION:=2.4.5
PKG_RELEASE:=2
PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz
PKG_SOURCE_URL:=@SF/zabbix
PKG_MD5SUM:=<API key>
PKG_LICENSE:=GPL-2.0
PKG_LICENSE_FILES:=COPYING
PKG_INSTALL:=1
PKG_FIXUP:=autoreconf
include $(INCLUDE_DIR)/package.mk
include $(INCLUDE_DIR)/nls.mk
define Package/zabbix/Default
SECTION:=admin
CATEGORY:=Administration
TITLE:=Zabbix
URL:=http:
SUBMENU:=zabbix
MAINTAINER:=Etienne CHAMPETIER <champetier.etienne@gmail.com>
USERID:=zabbix=53:zabbix=53
endef
define Package/zabbix-agent
$(call Package/zabbix/Default)
TITLE+= agent
endef
define Package/zabbix-agentd
$(call Package/zabbix/Default)
TITLE+= agentd
endef
define Package/<API key>
$(call Package/zabbix/Default)
TITLE+= discovery/userparameters for mac80211
DEPENDS += +zabbix-agentd @<API key> @KERNEL_DEBUG_FS
endef
define Package/<API key>
$(call Package/zabbix/Default)
TITLE+= discovery/userparameters for network
DEPENDS += +zabbix-agentd +libuci-lua +lua
endef
define Package/zabbix-extra-wifi
$(call Package/zabbix/Default)
TITLE+= discovery/userparameters for wifi
DEPENDS += +zabbix-agentd +libiwinfo-lua +libuci-lua +lua
endef
define Package/zabbix-sender
$(call Package/zabbix/Default)
TITLE+= sender
endef
define Package/zabbix-get
$(call Package/zabbix/Default)
TITLE+= get
endef
define Package/zabbix-server
$(call Package/zabbix/Default)
TITLE+= server
DEPENDS += +libsqlite3
endef
define Package/zabbix-proxy
$(call Package/zabbix/Default)
TITLE+= proxy
DEPENDS += +libsqlite3
endef
define Package/<API key>/description
An extra package for zabbix-agentd that adds a discovery rule for mac80211 wifi phy and many userparameters.
It contains an suid helper to allow zabbix-agentd to still run as zabbix user and not as root.
See http://wiki.openwrt.org/doc/howto/zabbix for ready to use zabbix templates.
endef
define Package/<API key>/description
An extra package for zabbix-agentd that adds a discovery rule for openwrt network interfaces.
The idea here is to discover only interfaces listed in /etc/config/network (discover br-lan and not eth0.1 and wlan0)
See http://wiki.openwrt.org/doc/howto/zabbix for ready to use zabbix templates.
endef
define Package/zabbix-extra-wifi/description
An extra package for zabbix-agentd that adds a discovery rule for wifi interfaces and many userparameters.
As it uses libiwinfo, it works with all wifi devices supported by openwrt.
See http://wiki.openwrt.org/doc/howto/zabbix for ready to use zabbix templates.
endef
CONFIGURE_ARGS+= \
--enable-agent \
--enable-server \
--enable-proxy \
--disable-java \
--with-sqlite3="$(STAGING_DIR)/usr"
MAKE_FLAGS += ARCH="linux"
define Package/zabbix/install/sbin
$(INSTALL_DIR) \
$(1)/usr/sbin
$(INSTALL_BIN) \
$(PKG_INSTALL_DIR)/usr/sbin/zabbix_$(2) \
$(1)/usr/sbin/
endef
define Package/zabbix/install/bin
$(INSTALL_DIR) \
$(1)/usr/bin
$(INSTALL_BIN) \
$(PKG_INSTALL_DIR)/usr/bin/zabbix_$(2) \
$(1)/usr/bin/
endef
define Package/zabbix/install/etc
$(INSTALL_DIR) \
$(1)/etc
$(INSTALL_CONF) \
$(PKG_INSTALL_DIR)/etc/zabbix_$(2).conf \
$(1)/etc/
endef
define Package/zabbix/install/init.d
$(INSTALL_DIR) \
$(1)/etc/init.d
$(INSTALL_BIN) \
./files/zabbix_$(2).init \
$(1)/etc/init.d/zabbix_$(2)
endef
define Package/zabbix/install/zabbix.conf.d
$(INSTALL_DIR) \
$(1)/etc/zabbix_agentd.conf.d
$(INSTALL_BIN) \
./files/$(2) \
$(1)/etc/zabbix_agentd.conf.d/$(2)
endef
define Package/zabbix-agent/conffiles
/etc/zabbix_agent.conf
endef
define Package/zabbix-agentd/conffiles
/etc/zabbix_agentd.conf
endef
define Package/zabbix-server/conffiles
/etc/zabbix_server.conf
endef
define Package/zabbix-proxy/conffiles
/etc/zabbix_proxy.conf
endef
ifdef <API key>
define Build/Prepare/<API key>
mkdir -p $(PKG_BUILD_DIR)/<API key>
$(CP) ./files/<API key>.c $(PKG_BUILD_DIR)/<API key>/
endef
define Build/Compile/<API key>
$(TARGET_CC) $(TARGET_CFLAGS) $(PKG_BUILD_DIR)/<API key>/<API key>.c -o $(PKG_BUILD_DIR)/<API key>/<API key>
endef
endif
define Build/Prepare
$(call Build/Prepare/Default)
$(call Build/Prepare/<API key>)
endef
define Build/Compile
$(call Build/Compile/Default)
$(call Build/Compile/<API key>)
endef
define Package/zabbix-agent/install
$(call Package/zabbix/install/sbin,$(1),agent)
$(call Package/zabbix/install/etc,$(1),agent)
endef
define Package/zabbix-agentd/install
$(INSTALL_DIR) $(1)/etc/zabbix_agentd.conf.d
$(call Package/zabbix/install/sbin,$(1),agentd)
$(call Package/zabbix/install/etc,$(1),agentd)
$(call Package/zabbix/install/init.d,$(1),agentd)
endef
define Package/<API key>/install
$(call Package/zabbix/install/zabbix.conf.d,$(1),mac80211)
$(INSTALL_DIR) $(1)/usr/bin
$(INSTALL_BIN) $(PKG_BUILD_DIR)/<API key>/<API key> $(1)/usr/bin/
chmod 4755 $(1)/usr/bin/<API key>
endef
define Package/<API key>/install
$(call Package/zabbix/install/zabbix.conf.d,$(1),network)
endef
define Package/zabbix-extra-wifi/install
$(call Package/zabbix/install/zabbix.conf.d,$(1),wifi)
endef
define Package/zabbix-sender/install
$(call Package/zabbix/install/bin,$(1),sender)
endef
define Package/zabbix-get/install
$(call Package/zabbix/install/bin,$(1),get)
endef
define Package/zabbix-server/install
$(call Package/zabbix/install/sbin,$(1),server)
$(call Package/zabbix/install/etc,$(1),server)
endef
define Package/zabbix-proxy/install
$(call Package/zabbix/install/sbin,$(1),proxy)
$(call Package/zabbix/install/etc,$(1),proxy)
endef
$(eval $(call BuildPackage,zabbix-agent))
$(eval $(call BuildPackage,zabbix-agentd))
$(eval $(call BuildPackage,<API key>))
$(eval $(call BuildPackage,<API key>))
$(eval $(call BuildPackage,zabbix-extra-wifi))
$(eval $(call BuildPackage,zabbix-sender))
$(eval $(call BuildPackage,zabbix-server))
$(eval $(call BuildPackage,zabbix-proxy))
$(eval $(call BuildPackage,zabbix-get)) |
function c31849106.initial_effect(c)
--Activate
local e1=Effect.CreateEffect(c)
e1:SetType(<API key>)
e1:SetCode(EVENT_FREE_CHAIN)
e1:SetOperation(c31849106.activate)
c:RegisterEffect(e1)
end
function c31849106.activate(e,tp,eg,ep,ev,re,r,rp)
local e1=Effect.CreateEffect(e:GetHandler())
e1:SetType(EFFECT_TYPE_FIELD)
e1:SetProperty(<API key>+<API key>+<API key>)
e1:SetCode(<API key>)
e1:SetTarget(c31849106.rmtarget)
e1:SetTargetRange(0xff, 0xff)
e1:SetValue(LOCATION_REMOVED)
e1:SetReset(RESET_PHASE+PHASE_END)
Duel.RegisterEffect(e1,tp)
end
function c31849106.rmtarget(e,c)
return not c:IsLocation(0x80) and not c:IsType(TYPE_SPELL+TYPE_TRAP)
end |
/** @file
*
* VBox frontends: Qt GUI ("VirtualBox"):
* UIDownloader class declaration
*/
#ifndef __UIDownloader_h__
#define __UIDownloader_h__
/* Global includes: */
#include <QUrl>
#include <QList>
/* Local includes: */
#include "UINetworkDefs.h"
#include "UINetworkCustomer.h"
/* Forward declarations: */
class UINetworkReply;
/* Downloader interface.
* UINetworkCustomer class extension which allows background http downloading. */
class UIDownloader : public UINetworkCustomer
{
Q_OBJECT;
signals:
/* Signal to start acknowledging: */
void <API key>();
/* Signal to start downloading: */
void <API key>();
public:
/* Starting routine: */
void start();
protected slots:
/* Acknowledging part: */
void <API key>();
/* Downloading part: */
void sltStartDownloading();
protected:
/* UIDownloader states: */
enum UIDownloaderState
{
<API key>,
<API key>,
<API key>
};
/* Constructor: */
UIDownloader();
/* Source stuff,
* allows to set/get one or more sources to try to download from: */
void addSource(const QString &strSource) { m_sources << QUrl(strSource); }
void setSource(const QString &strSource) { m_sources.clear(); addSource(strSource); }
const QList<QUrl>& sources() const { return m_sources; }
const QUrl& source() const { return m_source; }
/* Target stuff,
* allows to set/get downloaded file destination: */
void setTarget(const QString &strTarget) { m_strTarget = strTarget; }
const QString& target() const { return m_strTarget; }
/* Description stuff,
* allows to set/get Network Customer description for Network Access Manager: */
void setDescription(const QString &strDescription) { m_strDescription = strDescription; }
/* Start delayed acknowledging: */
void <API key>() { emit <API key>(); }
/* Start delayed downloading: */
void <API key>() { emit <API key>(); }
/* Network-reply progress handler: */
void <API key>(qint64 iReceived, qint64 iTotal);
/* Network-reply cancel handler: */
void <API key>(UINetworkReply *pNetworkReply);
/* Network-reply finish handler: */
void <API key>(UINetworkReply *pNetworkReply);
/* Handle acknowledging result: */
virtual void <API key>(UINetworkReply *pNetworkReply);
/* Handle downloading result: */
virtual void <API key>(UINetworkReply *pNetworkReply);
/* Pure virtual function to ask user about downloading confirmation: */
virtual bool <API key>(UINetworkReply *pNetworkReply) = 0;
/* Pure virtual function to handle downloaded object: */
virtual void <API key>(UINetworkReply *pNetworkReply) = 0;
private:
/* Private variables: */
UIDownloaderState m_state;
QList<QUrl> m_sources;
QUrl m_source;
QString m_strTarget;
QString m_strDescription;
};
#endif // __UIDownloader_h__ |
#include "GestureLook.hpp"
#include "Screen/Layout.hpp"
void
GestureLook::Initialise()
{
color = COLOR_RED;
pen.Set(Layout::ScalePenWidth(5), color);
invalid_color = LightColor(color);
invalid_pen.Set(Layout::ScalePenWidth(5), invalid_color);
} |
#ifdef BOND_CLASS
BondStyle(fene/expand,BondFENEExpand)
#else
#ifndef <API key>
#define <API key>
#include <cstdio>
#include "bond.h"
namespace LAMMPS_NS {
class BondFENEExpand : public Bond {
public:
BondFENEExpand(class LAMMPS *);
virtual ~BondFENEExpand();
virtual void compute(int, int);
void coeff(int, char **);
void init_style();
double <API key>(int);
void write_restart(FILE *);
void read_restart(FILE *);
void write_data(FILE *);
double single(int, double, int, int, double &);
protected:
double TWO_1_3;
double *k,*r0,*epsilon,*sigma,*shift;
void allocate();
};
}
#endif
#endif
/* ERROR/WARNING messages:
W: FENE bond too long: %ld %d %d %g
A FENE bond has stretched dangerously far. It's interaction strength
will be truncated to attempt to prevent the bond from blowing up.
E: Bad FENE bond
Two atoms in a FENE bond have become so far apart that the bond cannot
be computed.
E: Incorrect args for bond coefficients
Self-explanatory. Check the input script or data file.
W: Use special bonds = 0,1,1 with bond style fene/expand
Most FENE models need this setting for the special_bonds command.
W: FENE bond too long: %ld %g
A FENE bond has stretched dangerously far. It's interaction strength
will be truncated to attempt to prevent the bond from blowing up.
*/ |
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>app/js/view.js - YUI 3</title>
<link rel="stylesheet" href="http://yui.yahooapis.com/3.5.0pr4/build/cssgrids/cssgrids-min.css">
<link rel="stylesheet" href="../assets/vendor/prettify/prettify-min.css">
<link rel="stylesheet" href="../assets/css/main.css" id="site_styles">
<script src="http://yui.yahooapis.com/3.5.0pr4/build/yui/yui-min.js"></script>
</head>
<body class="yui3-skin-sam">
<div id="doc">
<div id="hd" class="yui3-g header">
<div class="yui3-u-3-4">
<h1><img src="../assets/css/logo.png" title="YUI 3"></h1>
</div>
<div class="yui3-u-1-4 version">
<em>API Docs for: 3.5.0</em>
</div>
</div>
<div id="bd" class="yui3-g">
<div class="yui3-u-1-4">
<div id="docs-sidebar" class="sidebar apidocs">
<div id="api-list">
<h2 class="off-left">APIs</h2>
<div id="api-tabview" class="tabview">
<ul class="tabs">
<li><a href="#api-classes">Classes</a></li>
<li><a href="#api-modules">Modules</a></li>
</ul>
<div id="api-tabview-filter">
<input type="search" id="api-filter" placeholder="Type to filter APIs">
</div>
<div id="api-tabview-panel">
<ul id="api-classes" class="apis classes">
<li><a href="../classes/Anim.html">Anim</a></li>
<li><a href="../classes/App.html">App</a></li>
<li><a href="../classes/App.Base.html">App.Base</a></li>
<li><a href="../classes/App.Transitions.html">App.Transitions</a></li>
<li><a href="../classes/App.TransitionsNative.html">App.TransitionsNative</a></li>
<li><a href="../classes/AreaSeries.html">AreaSeries</a></li>
<li><a href="../classes/AreaSplineSeries.html">AreaSplineSeries</a></li>
<li><a href="../classes/Array.html">Array</a></li>
<li><a href="../classes/ArrayList.html">ArrayList</a></li>
<li><a href="../classes/ArraySort.html">ArraySort</a></li>
<li><a href="../classes/AsyncQueue.html">AsyncQueue</a></li>
<li><a href="../classes/Attribute.html">Attribute</a></li>
<li><a href="../classes/AttributeCore.html">AttributeCore</a></li>
<li><a href="../classes/AttributeEvents.html">AttributeEvents</a></li>
<li><a href="../classes/AttributeExtras.html">AttributeExtras</a></li>
<li><a href="../classes/AttributeLite.html">AttributeLite</a></li>
<li><a href="../classes/AutoComplete.html">AutoComplete</a></li>
<li><a href="../classes/AutoCompleteBase.html">AutoCompleteBase</a></li>
<li><a href="../classes/AutoCompleteFilters.html">AutoCompleteFilters</a></li>
<li><a href="../classes/<API key>.html"><API key></a></li>
<li><a href="../classes/AutoCompleteList.html">AutoCompleteList</a></li>
<li><a href="../classes/Axis.html">Axis</a></li>
<li><a href="../classes/AxisType.html">AxisType</a></li>
<li><a href="../classes/BarSeries.html">BarSeries</a></li>
<li><a href="../classes/Base.html">Base</a></li>
<li><a href="../classes/BaseCore.html">BaseCore</a></li>
<li><a href="../classes/BottomAxisLayout.html">BottomAxisLayout</a></li>
<li><a href="../classes/Button.html">Button</a></li>
<li><a href="../classes/ButtonCore.html">ButtonCore</a></li>
<li><a href="../classes/ButtonGroup.html">ButtonGroup</a></li>
<li><a href="../classes/ButtonPlugin.html">ButtonPlugin</a></li>
<li><a href="../classes/Cache.html">Cache</a></li>
<li><a href="../classes/CacheOffline.html">CacheOffline</a></li>
<li><a href="../classes/Calendar.html">Calendar</a></li>
<li><a href="../classes/CalendarBase.html">CalendarBase</a></li>
<li><a href="../classes/CanvasCircle.html">CanvasCircle</a></li>
<li><a href="../classes/CanvasDrawing.html">CanvasDrawing</a></li>
<li><a href="../classes/CanvasEllipse.html">CanvasEllipse</a></li>
<li><a href="../classes/CanvasGraphic.html">CanvasGraphic</a></li>
<li><a href="../classes/CanvasPath.html">CanvasPath</a></li>
<li><a href="../classes/CanvasPieSlice.html">CanvasPieSlice</a></li>
<li><a href="../classes/CanvasRect.html">CanvasRect</a></li>
<li><a href="../classes/CanvasShape.html">CanvasShape</a></li>
<li><a href="../classes/CartesianChart.html">CartesianChart</a></li>
<li><a href="../classes/CartesianSeries.html">CartesianSeries</a></li>
<li><a href="../classes/CategoryAxis.html">CategoryAxis</a></li>
<li><a href="../classes/Chart.html">Chart</a></li>
<li><a href="../classes/ChartBase.html">ChartBase</a></li>
<li><a href="../classes/ChartLegend.html">ChartLegend</a></li>
<li><a href="../classes/Circle.html">Circle</a></li>
<li><a href="../classes/ClassNameManager.html">ClassNameManager</a></li>
<li><a href="../classes/ClickableRail.html">ClickableRail</a></li>
<li><a href="../classes/ColumnSeries.html">ColumnSeries</a></li>
<li><a href="../classes/ComboSeries.html">ComboSeries</a></li>
<li><a href="../classes/ComboSplineSeries.html">ComboSplineSeries</a></li>
<li><a href="../classes/config.html">config</a></li>
<li><a href="../classes/Console.html">Console</a></li>
<li><a href="../classes/Controller.html">Controller</a></li>
<li><a href="../classes/Cookie.html">Cookie</a></li>
<li><a href="../classes/CurveUtil.html">CurveUtil</a></li>
<li><a href="../classes/CustomEvent.html">CustomEvent</a></li>
<li><a href="../classes/DataSchema.Array.html">DataSchema.Array</a></li>
<li><a href="../classes/DataSchema.Base.html">DataSchema.Base</a></li>
<li><a href="../classes/DataSchema.JSON.html">DataSchema.JSON</a></li>
<li><a href="../classes/DataSchema.Text.html">DataSchema.Text</a></li>
<li><a href="../classes/DataSchema.XML.html">DataSchema.XML</a></li>
<li><a href="../classes/DataSource.Function.html">DataSource.Function</a></li>
<li><a href="../classes/DataSource.Get.html">DataSource.Get</a></li>
<li><a href="../classes/DataSource.IO.html">DataSource.IO</a></li>
<li><a href="../classes/DataSource.Local.html">DataSource.Local</a></li>
<li><a href="../classes/<API key>.html"><API key></a></li>
<li><a href="../classes/DataSourceCache.html">DataSourceCache</a></li>
<li><a href="../classes/<API key>.html"><API key></a></li>
<li><a href="../classes/<API key>.html"><API key></a></li>
<li><a href="../classes/<API key>.html"><API key></a></li>
<li><a href="../classes/DataSourceXMLSchema.html">DataSourceXMLSchema</a></li>
<li><a href="../classes/DataTable.html">DataTable</a></li>
<li><a href="../classes/DataTable.Base.html">DataTable.Base</a></li>
<li><a href="../classes/DataTable.BodyView.html">DataTable.BodyView</a></li>
<li><a href="../classes/DataTable.ColumnWidths.html">DataTable.ColumnWidths</a></li>
<li><a href="../classes/DataTable.Core.html">DataTable.Core</a></li>
<li><a href="../classes/DataTable.HeaderView.html">DataTable.HeaderView</a></li>
<li><a href="../classes/DataTable.Message.html">DataTable.Message</a></li>
<li><a href="../classes/DataTable.Mutable.html">DataTable.Mutable</a></li>
<li><a href="../classes/DataTable.Scrollable.html">DataTable.Scrollable</a></li>
<li><a href="../classes/DataTable.Sortable.html">DataTable.Sortable</a></li>
<li><a href="../classes/DataType.Date.html">DataType.Date</a></li>
<li><a href="../classes/DataType.Date.Locale.html">DataType.Date.Locale</a></li>
<li><a href="../classes/DataType.Number.html">DataType.Number</a></li>
<li><a href="../classes/DataType.XML.html">DataType.XML</a></li>
<li><a href="../classes/DD.DDM.html">DD.DDM</a></li>
<li><a href="../classes/DD.Delegate.html">DD.Delegate</a></li>
<li><a href="../classes/DD.Drag.html">DD.Drag</a></li>
<li><a href="../classes/DD.Drop.html">DD.Drop</a></li>
<li><a href="../classes/DD.Plugin.DDWindowScroll.html">DD.Plugin.DDWindowScroll</a></li>
<li><a href="../classes/DD.Scroll.html">DD.Scroll</a></li>
<li><a href="../classes/Dial.html">Dial</a></li>
<li><a href="../classes/Do.html">Do</a></li>
<li><a href="../classes/Do.AlterArgs.html">Do.AlterArgs</a></li>
<li><a href="../classes/Do.AlterReturn.html">Do.AlterReturn</a></li>
<li><a href="../classes/Do.Error.html">Do.Error</a></li>
<li><a href="../classes/Do.Halt.html">Do.Halt</a></li>
<li><a href="../classes/Do.Method.html">Do.Method</a></li>
<li><a href="../classes/Do.Prevent.html">Do.Prevent</a></li>
<li><a href="../classes/DOM.html">DOM</a></li>
<li><a href="../classes/DOMEventFacade.html">DOMEventFacade</a></li>
<li><a href="../classes/Drawing.html">Drawing</a></li>
<li><a href="../classes/Easing.html">Easing</a></li>
<li><a href="../classes/EditorBase.html">EditorBase</a></li>
<li><a href="../classes/EditorSelection.html">EditorSelection</a></li>
<li><a href="../classes/Ellipse.html">Ellipse</a></li>
<li><a href="../classes/EllipseGroup.html">EllipseGroup</a></li>
<li><a href="../classes/Escape.html">Escape</a></li>
<li><a href="../classes/Event.html">Event</a></li>
<li><a href="../classes/EventFacade.html">EventFacade</a></li>
<li><a href="../classes/EventHandle.html">EventHandle</a></li>
<li><a href="../classes/EventTarget.html">EventTarget</a></li>
<li><a href="../classes/ExecCommand.html">ExecCommand</a></li>
<li><a href="../classes/Features.html">Features</a></li>
<li><a href="../classes/File.html">File</a></li>
<li><a href="../classes/FileFlash.html">FileFlash</a></li>
<li><a href="../classes/FileHTML5.html">FileHTML5</a></li>
<li><a href="../classes/Fills.html">Fills</a></li>
<li><a href="../classes/Frame.html">Frame</a></li>
<li><a href="../classes/Get.html">Get</a></li>
<li><a href="../classes/Get.Transaction.html">Get.Transaction</a></li>
<li><a href="../classes/GetNodeJS.html">GetNodeJS</a></li>
<li><a href="../classes/Graph.html">Graph</a></li>
<li><a href="../classes/Graphic.html">Graphic</a></li>
<li><a href="../classes/GraphicBase.html">GraphicBase</a></li>
<li><a href="../classes/Gridlines.html">Gridlines</a></li>
<li><a href="../classes/GroupCircle.html">GroupCircle</a></li>
<li><a href="../classes/GroupDiamond.html">GroupDiamond</a></li>
<li><a href="../classes/GroupRect.html">GroupRect</a></li>
<li><a href="../classes/Handlebars.html">Handlebars</a></li>
<li><a href="../classes/Highlight.html">Highlight</a></li>
<li><a href="../classes/Histogram.html">Histogram</a></li>
<li><a href="../classes/HistoryBase.html">HistoryBase</a></li>
<li><a href="../classes/HistoryHash.html">HistoryHash</a></li>
<li><a href="../classes/HistoryHTML5.html">HistoryHTML5</a></li>
<li><a href="../classes/<API key>.html"><API key></a></li>
<li><a href="../classes/ImgLoadGroup.html">ImgLoadGroup</a></li>
<li><a href="../classes/ImgLoadImgObj.html">ImgLoadImgObj</a></li>
<li><a href="../classes/Intl.html">Intl</a></li>
<li><a href="../classes/IO.html">IO</a></li>
<li><a href="../classes/json.html">json</a></li>
<li><a href="../classes/JSONPRequest.html">JSONPRequest</a></li>
<li><a href="../classes/Lang.html">Lang</a></li>
<li><a href="../classes/LeftAxisLayout.html">LeftAxisLayout</a></li>
<li><a href="../classes/Lines.html">Lines</a></li>
<li><a href="../classes/LineSeries.html">LineSeries</a></li>
<li><a href="../classes/Loader.html">Loader</a></li>
<li><a href="../classes/MarkerSeries.html">MarkerSeries</a></li>
<li><a href="../classes/Matrix.html">Matrix</a></li>
<li><a href="../classes/Model.html">Model</a></li>
<li><a href="../classes/ModelList.html">ModelList</a></li>
<li><a href="../classes/Node.html">Node</a></li>
<li><a href="../classes/NodeList.html">NodeList</a></li>
<li><a href="../classes/NumericAxis.html">NumericAxis</a></li>
<li><a href="../classes/Object.html">Object</a></li>
<li><a href="../classes/Overlay.html">Overlay</a></li>
<li><a href="../classes/Panel.html">Panel</a></li>
<li><a href="../classes/Parallel.html">Parallel</a></li>
<li><a href="../classes/Path.html">Path</a></li>
<li><a href="../classes/PieChart.html">PieChart</a></li>
<li><a href="../classes/PieSeries.html">PieSeries</a></li>
<li><a href="../classes/Pjax.html">Pjax</a></li>
<li><a href="../classes/PjaxBase.html">PjaxBase</a></li>
<li><a href="../classes/Plots.html">Plots</a></li>
<li><a href="../classes/Plugin.Align.html">Plugin.Align</a></li>
<li><a href="../classes/Plugin.AutoComplete.html">Plugin.AutoComplete</a></li>
<li><a href="../classes/Plugin.Base.html">Plugin.Base</a></li>
<li><a href="../classes/Plugin.Cache.html">Plugin.Cache</a></li>
<li><a href="../classes/Plugin.CalendarNavigator.html">Plugin.CalendarNavigator</a></li>
<li><a href="../classes/Plugin.ConsoleFilters.html">Plugin.ConsoleFilters</a></li>
<li><a href="../classes/Plugin.CreateLinkBase.html">Plugin.CreateLinkBase</a></li>
<li><a href="../classes/Plugin.DataTableDataSource.html">Plugin.DataTableDataSource</a></li>
<li><a href="../classes/Plugin.DDConstrained.html">Plugin.DDConstrained</a></li>
<li><a href="../classes/Plugin.DDNodeScroll.html">Plugin.DDNodeScroll</a></li>
<li><a href="../classes/Plugin.DDProxy.html">Plugin.DDProxy</a></li>
<li><a href="../classes/Plugin.Drag.html">Plugin.Drag</a></li>
<li><a href="../classes/Plugin.Drop.html">Plugin.Drop</a></li>
<li><a href="../classes/Plugin.EditorBidi.html">Plugin.EditorBidi</a></li>
<li><a href="../classes/Plugin.EditorBR.html">Plugin.EditorBR</a></li>
<li><a href="../classes/Plugin.EditorLists.html">Plugin.EditorLists</a></li>
<li><a href="../classes/Plugin.EditorPara.html">Plugin.EditorPara</a></li>
<li><a href="../classes/Plugin.EditorParaBase.html">Plugin.EditorParaBase</a></li>
<li><a href="../classes/Plugin.EditorParaIE.html">Plugin.EditorParaIE</a></li>
<li><a href="../classes/Plugin.EditorTab.html">Plugin.EditorTab</a></li>
<li><a href="../classes/Plugin.ExecCommand.html">Plugin.ExecCommand</a></li>
<li><a href="../classes/Plugin.Flick.html">Plugin.Flick</a></li>
<li><a href="../classes/Plugin.Host.html">Plugin.Host</a></li>
<li><a href="../classes/plugin.NodeFocusManager.html">plugin.NodeFocusManager</a></li>
<li><a href="../classes/Plugin.NodeFX.html">Plugin.NodeFX</a></li>
<li><a href="../classes/plugin.NodeMenuNav.html">plugin.NodeMenuNav</a></li>
<li><a href="../classes/Plugin.Pjax.html">Plugin.Pjax</a></li>
<li><a href="../classes/Plugin.Resize.html">Plugin.Resize</a></li>
<li><a href="../classes/Plugin.ResizeConstrained.html">Plugin.ResizeConstrained</a></li>
<li><a href="../classes/Plugin.ResizeProxy.html">Plugin.ResizeProxy</a></li>
<li><a href="../classes/Plugin.ScrollViewList.html">Plugin.ScrollViewList</a></li>
<li><a href="../classes/Plugin.ScrollViewPaginator.html">Plugin.ScrollViewPaginator</a></li>
<li><a href="../classes/Plugin.<API key>.html">Plugin.<API key></a></li>
<li><a href="../classes/Plugin.Shim.html">Plugin.Shim</a></li>
<li><a href="../classes/Plugin.SortScroll.html">Plugin.SortScroll</a></li>
<li><a href="../classes/Plugin.WidgetAnim.html">Plugin.WidgetAnim</a></li>
<li><a href="../classes/Pollable.html">Pollable</a></li>
<li><a href="../classes/Profiler.html">Profiler</a></li>
<li><a href="../classes/QueryString.html">QueryString</a></li>
<li><a href="../classes/Queue.html">Queue</a></li>
<li><a href="../classes/Record.html">Record</a></li>
<li><a href="../classes/Recordset.html">Recordset</a></li>
<li><a href="../classes/RecordsetFilter.html">RecordsetFilter</a></li>
<li><a href="../classes/RecordsetIndexer.html">RecordsetIndexer</a></li>
<li><a href="../classes/RecordsetSort.html">RecordsetSort</a></li>
<li><a href="../classes/Rect.html">Rect</a></li>
<li><a href="../classes/Renderer.html">Renderer</a></li>
<li><a href="../classes/Resize.html">Resize</a></li>
<li><a href="../classes/RightAxisLayout.html">RightAxisLayout</a></li>
<li><a href="../classes/Router.html">Router</a></li>
<li><a href="../classes/ScrollView.html">ScrollView</a></li>
<li><a href="../classes/Selector.html">Selector</a></li>
<li><a href="../classes/Shape.html">Shape</a></li>
<li><a href="../classes/ShapeGroup.html">ShapeGroup</a></li>
<li><a href="../classes/Slider.html">Slider</a></li>
<li><a href="../classes/SliderBase.html">SliderBase</a></li>
<li><a href="../classes/SliderValueRange.html">SliderValueRange</a></li>
<li><a href="../classes/Sortable.html">Sortable</a></li>
<li><a href="../classes/SplineSeries.html">SplineSeries</a></li>
<li><a href="../classes/StackedAreaSeries.html">StackedAreaSeries</a></li>
<li><a href="../classes/<API key>.html"><API key></a></li>
<li><a href="../classes/StackedAxis.html">StackedAxis</a></li>
<li><a href="../classes/StackedBarSeries.html">StackedBarSeries</a></li>
<li><a href="../classes/StackedColumnSeries.html">StackedColumnSeries</a></li>
<li><a href="../classes/StackedComboSeries.html">StackedComboSeries</a></li>
<li><a href="../classes/<API key>.html"><API key></a></li>
<li><a href="../classes/StackedLineSeries.html">StackedLineSeries</a></li>
<li><a href="../classes/StackedMarkerSeries.html">StackedMarkerSeries</a></li>
<li><a href="../classes/StackedSplineSeries.html">StackedSplineSeries</a></li>
<li><a href="../classes/StackingUtil.html">StackingUtil</a></li>
<li><a href="../classes/State.html">State</a></li>
<li><a href="../classes/StyleSheet.html">StyleSheet</a></li>
<li><a href="../classes/Subscriber.html">Subscriber</a></li>
<li><a href="../classes/SVGCircle.html">SVGCircle</a></li>
<li><a href="../classes/SVGDrawing.html">SVGDrawing</a></li>
<li><a href="../classes/SVGEllipse.html">SVGEllipse</a></li>
<li><a href="../classes/SVGGraphic.html">SVGGraphic</a></li>
<li><a href="../classes/SVGPath.html">SVGPath</a></li>
<li><a href="../classes/SVGPieSlice.html">SVGPieSlice</a></li>
<li><a href="../classes/SVGRect.html">SVGRect</a></li>
<li><a href="../classes/SVGShape.html">SVGShape</a></li>
<li><a href="../classes/SWF.html">SWF</a></li>
<li><a href="../classes/SWFDetect.html">SWFDetect</a></li>
<li><a href="../classes/SyntheticEvent.html">SyntheticEvent</a></li>
<li><a href="../classes/SyntheticEvent.Notifier.html">SyntheticEvent.Notifier</a></li>
<li><a href="../classes/SynthRegistry.html">SynthRegistry</a></li>
<li><a href="../classes/Tab.html">Tab</a></li>
<li><a href="../classes/TabView.html">TabView</a></li>
<li><a href="../classes/Test.html">Test</a></li>
<li><a href="../classes/Test.ArrayAssert.html">Test.ArrayAssert</a></li>
<li><a href="../classes/Test.Assert.html">Test.Assert</a></li>
<li><a href="../classes/Test.AssertionError.html">Test.AssertionError</a></li>
<li><a href="../classes/Test.ComparisonFailure.html">Test.ComparisonFailure</a></li>
<li><a href="../classes/Test.Console.html">Test.Console</a></li>
<li><a href="../classes/Test.CoverageFormat.CoverageFormat.html">Test.CoverageFormat.CoverageFormat</a></li>
<li><a href="../classes/Test.DateAssert.html">Test.DateAssert</a></li>
<li><a href="../classes/Test.EventTarget.html">Test.EventTarget</a></li>
<li><a href="../classes/Test.Mock.Mock.html">Test.Mock.Mock</a></li>
<li><a href="../classes/Test.Mock.Value.html">Test.Mock.Value</a></li>
<li><a href="../classes/Test.ObjectAssert.html">Test.ObjectAssert</a></li>
<li><a href="../classes/Test.Reporter.html">Test.Reporter</a></li>
<li><a href="../classes/Test.Results.html">Test.Results</a></li>
<li><a href="../classes/Test.Runner.html">Test.Runner</a></li>
<li><a href="../classes/Test.ShouldError.html">Test.ShouldError</a></li>
<li><a href="../classes/Test.ShouldFail.html">Test.ShouldFail</a></li>
<li><a href="../classes/Test.TestCase.html">Test.TestCase</a></li>
<li><a href="../classes/Test.TestFormat.html">Test.TestFormat</a></li>
<li><a href="../classes/Test.TestNode.html">Test.TestNode</a></li>
<li><a href="../classes/Test.TestRunner.html">Test.TestRunner</a></li>
<li><a href="../classes/Test.TestSuite.html">Test.TestSuite</a></li>
<li><a href="../classes/Test.UnexpectedError.html">Test.UnexpectedError</a></li>
<li><a href="../classes/Test.UnexpectedValue.html">Test.UnexpectedValue</a></li>
<li><a href="../classes/Test.Wait.html">Test.Wait</a></li>
<li><a href="../classes/Text.AccentFold.html">Text.AccentFold</a></li>
<li><a href="../classes/Text.WordBreak.html">Text.WordBreak</a></li>
<li><a href="../classes/TimeAxis.html">TimeAxis</a></li>
<li><a href="../classes/ToggleButton.html">ToggleButton</a></li>
<li><a href="../classes/TopAxisLayout.html">TopAxisLayout</a></li>
<li><a href="../classes/Transition.html">Transition</a></li>
<li><a href="../classes/UA.html">UA</a></li>
<li><a href="../classes/Uploader.html">Uploader</a></li>
<li><a href="../classes/Uploader.Queue.html">Uploader.Queue</a></li>
<li><a href="../classes/UploaderFlash.html">UploaderFlash</a></li>
<li><a href="../classes/UploaderHTML5.html">UploaderHTML5</a></li>
<li><a href="../classes/ValueChange.html">ValueChange</a></li>
<li><a href="../classes/<API key>.html"><API key></a></li>
<li><a href="../classes/View.html">View</a></li>
<li><a href="../classes/View.NodeMap.html">View.NodeMap</a></li>
<li><a href="../classes/VMLCircle.html">VMLCircle</a></li>
<li><a href="../classes/VMLDrawing.html">VMLDrawing</a></li>
<li><a href="../classes/VMLEllipse.html">VMLEllipse</a></li>
<li><a href="../classes/VMLGraphic.html">VMLGraphic</a></li>
<li><a href="../classes/VMLPath.html">VMLPath</a></li>
<li><a href="../classes/VMLPieSlice.html">VMLPieSlice</a></li>
<li><a href="../classes/VMLRect.html">VMLRect</a></li>
<li><a href="../classes/VMLShape.html">VMLShape</a></li>
<li><a href="../classes/Widget.html">Widget</a></li>
<li><a href="../classes/WidgetAutohide.html">WidgetAutohide</a></li>
<li><a href="../classes/WidgetButtons.html">WidgetButtons</a></li>
<li><a href="../classes/WidgetChild.html">WidgetChild</a></li>
<li><a href="../classes/WidgetModality.html">WidgetModality</a></li>
<li><a href="../classes/WidgetParent.html">WidgetParent</a></li>
<li><a href="../classes/WidgetPosition.html">WidgetPosition</a></li>
<li><a href="../classes/WidgetPositionAlign.html">WidgetPositionAlign</a></li>
<li><a href="../classes/<API key>.html"><API key></a></li>
<li><a href="../classes/WidgetStack.html">WidgetStack</a></li>
<li><a href="../classes/WidgetStdMod.html">WidgetStdMod</a></li>
<li><a href="../classes/YQL.html">YQL</a></li>
<li><a href="../classes/YQLRequest.html">YQLRequest</a></li>
<li><a href="../classes/YUI.html">YUI</a></li>
<li><a href="../classes/YUI~substitute.html">YUI~substitute</a></li>
</ul>
<ul id="api-modules" class="apis modules">
<li><a href="../modules/align-plugin.html">align-plugin</a></li>
<li><a href="../modules/anim.html">anim</a></li>
<li><a href="../modules/anim-base.html">anim-base</a></li>
<li><a href="../modules/anim-color.html">anim-color</a></li>
<li><a href="../modules/anim-curve.html">anim-curve</a></li>
<li><a href="../modules/anim-easing.html">anim-easing</a></li>
<li><a href="../modules/anim-node-plugin.html">anim-node-plugin</a></li>
<li><a href="../modules/anim-scroll.html">anim-scroll</a></li>
<li><a href="../modules/anim-xy.html">anim-xy</a></li>
<li><a href="../modules/app.html">app</a></li>
<li><a href="../modules/app-base.html">app-base</a></li>
<li><a href="../modules/app-transitions.html">app-transitions</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/array-extras.html">array-extras</a></li>
<li><a href="../modules/array-invoke.html">array-invoke</a></li>
<li><a href="../modules/arraylist.html">arraylist</a></li>
<li><a href="../modules/arraylist-add.html">arraylist-add</a></li>
<li><a href="../modules/arraylist-filter.html">arraylist-filter</a></li>
<li><a href="../modules/arraysort.html">arraysort</a></li>
<li><a href="../modules/async-queue.html">async-queue</a></li>
<li><a href="../modules/attribute.html">attribute</a></li>
<li><a href="../modules/attribute-base.html">attribute-base</a></li>
<li><a href="../modules/attribute-complex.html">attribute-complex</a></li>
<li><a href="../modules/attribute-core.html">attribute-core</a></li>
<li><a href="../modules/attribute-events.html">attribute-events</a></li>
<li><a href="../modules/attribute-extras.html">attribute-extras</a></li>
<li><a href="../modules/autocomplete.html">autocomplete</a></li>
<li><a href="../modules/autocomplete-base.html">autocomplete-base</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/autocomplete-list.html">autocomplete-list</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/autocomplete-plugin.html">autocomplete-plugin</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/base.html">base</a></li>
<li><a href="../modules/base-base.html">base-base</a></li>
<li><a href="../modules/base-build.html">base-build</a></li>
<li><a href="../modules/base-core.html">base-core</a></li>
<li><a href="../modules/base-pluginhost.html">base-pluginhost</a></li>
<li><a href="../modules/button.html">button</a></li>
<li><a href="../modules/button-core.html">button-core</a></li>
<li><a href="../modules/button-group.html">button-group</a></li>
<li><a href="../modules/button-plugin.html">button-plugin</a></li>
<li><a href="../modules/cache.html">cache</a></li>
<li><a href="../modules/cache-base.html">cache-base</a></li>
<li><a href="../modules/cache-offline.html">cache-offline</a></li>
<li><a href="../modules/cache-plugin.html">cache-plugin</a></li>
<li><a href="../modules/calendar.html">calendar</a></li>
<li><a href="../modules/calendar-base.html">calendar-base</a></li>
<li><a href="../modules/calendarnavigator.html">calendarnavigator</a></li>
<li><a href="../modules/charts.html">charts</a></li>
<li><a href="../modules/charts-legend.html">charts-legend</a></li>
<li><a href="../modules/classnamemanager.html">classnamemanager</a></li>
<li><a href="../modules/clickable-rail.html">clickable-rail</a></li>
<li><a href="../modules/collection.html">collection</a></li>
<li><a href="../modules/console.html">console</a></li>
<li><a href="../modules/console-filters.html">console-filters</a></li>
<li><a href="../modules/cookie.html">cookie</a></li>
<li><a href="../modules/createlink-base.html">createlink-base</a></li>
<li><a href="../modules/dataschema.html">dataschema</a></li>
<li><a href="../modules/dataschema-array.html">dataschema-array</a></li>
<li><a href="../modules/dataschema-base.html">dataschema-base</a></li>
<li><a href="../modules/dataschema-json.html">dataschema-json</a></li>
<li><a href="../modules/dataschema-text.html">dataschema-text</a></li>
<li><a href="../modules/dataschema-xml.html">dataschema-xml</a></li>
<li><a href="../modules/datasource.html">datasource</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/datasource-cache.html">datasource-cache</a></li>
<li><a href="../modules/datasource-function.html">datasource-function</a></li>
<li><a href="../modules/datasource-get.html">datasource-get</a></li>
<li><a href="../modules/datasource-io.html">datasource-io</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/datasource-local.html">datasource-local</a></li>
<li><a href="../modules/datasource-polling.html">datasource-polling</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/datatable.html">datatable</a></li>
<li><a href="../modules/datatable-base.html">datatable-base</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/datatable-body.html">datatable-body</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/datatable-core.html">datatable-core</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/datatable-head.html">datatable-head</a></li>
<li><a href="../modules/datatable-message.html">datatable-message</a></li>
<li><a href="../modules/datatable-mutable.html">datatable-mutable</a></li>
<li><a href="../modules/datatable-scroll.html">datatable-scroll</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/datatable-sort.html">datatable-sort</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/datatype.html">datatype</a></li>
<li><a href="../modules/datatype-date.html">datatype-date</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/datatype-date-math.html">datatype-date-math</a></li>
<li><a href="../modules/datatype-date-parse.html">datatype-date-parse</a></li>
<li><a href="../modules/datatype-number.html">datatype-number</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/datatype-xml.html">datatype-xml</a></li>
<li><a href="../modules/datatype-xml-format.html">datatype-xml-format</a></li>
<li><a href="../modules/datatype-xml-parse.html">datatype-xml-parse</a></li>
<li><a href="../modules/dd.html">dd</a></li>
<li><a href="../modules/dd-constrain.html">dd-constrain</a></li>
<li><a href="../modules/dd-ddm.html">dd-ddm</a></li>
<li><a href="../modules/dd-ddm-base.html">dd-ddm-base</a></li>
<li><a href="../modules/dd-ddm-drop.html">dd-ddm-drop</a></li>
<li><a href="../modules/dd-delegate.html">dd-delegate</a></li>
<li><a href="../modules/dd-drag.html">dd-drag</a></li>
<li><a href="../modules/dd-drop.html">dd-drop</a></li>
<li><a href="../modules/dd-drop-plugin.html">dd-drop-plugin</a></li>
<li><a href="../modules/dd-plugin.html">dd-plugin</a></li>
<li><a href="../modules/dd-proxy.html">dd-proxy</a></li>
<li><a href="../modules/dd-scroll.html">dd-scroll</a></li>
<li><a href="../modules/dial.html">dial</a></li>
<li><a href="../modules/dom.html">dom</a></li>
<li><a href="../modules/dom-base.html">dom-base</a></li>
<li><a href="../modules/dom-screen.html">dom-screen</a></li>
<li><a href="../modules/dom-style.html">dom-style</a></li>
<li><a href="../modules/dump.html">dump</a></li>
<li><a href="../modules/editor.html">editor</a></li>
<li><a href="../modules/editor-base.html">editor-base</a></li>
<li><a href="../modules/editor-bidi.html">editor-bidi</a></li>
<li><a href="../modules/editor-br.html">editor-br</a></li>
<li><a href="../modules/editor-lists.html">editor-lists</a></li>
<li><a href="../modules/editor-para.html">editor-para</a></li>
<li><a href="../modules/editor-para-base.html">editor-para-base</a></li>
<li><a href="../modules/editor-para-ie.html">editor-para-ie</a></li>
<li><a href="../modules/editor-tab.html">editor-tab</a></li>
<li><a href="../modules/escape.html">escape</a></li>
<li><a href="../modules/event.html">event</a></li>
<li><a href="../modules/event-base.html">event-base</a></li>
<li><a href="../modules/event-contextmenu.html">event-contextmenu</a></li>
<li><a href="../modules/event-custom.html">event-custom</a></li>
<li><a href="../modules/event-custom-base.html">event-custom-base</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/event-delegate.html">event-delegate</a></li>
<li><a href="../modules/event-flick.html">event-flick</a></li>
<li><a href="../modules/event-focus.html">event-focus</a></li>
<li><a href="../modules/event-gestures.html">event-gestures</a></li>
<li><a href="../modules/event-hover.html">event-hover</a></li>
<li><a href="../modules/event-key.html">event-key</a></li>
<li><a href="../modules/event-mouseenter.html">event-mouseenter</a></li>
<li><a href="../modules/event-mousewheel.html">event-mousewheel</a></li>
<li><a href="../modules/event-move.html">event-move</a></li>
<li><a href="../modules/event-outside.html">event-outside</a></li>
<li><a href="../modules/event-resize.html">event-resize</a></li>
<li><a href="../modules/event-simulate.html">event-simulate</a></li>
<li><a href="../modules/event-synthetic.html">event-synthetic</a></li>
<li><a href="../modules/event-touch.html">event-touch</a></li>
<li><a href="../modules/event-valuechange.html">event-valuechange</a></li>
<li><a href="../modules/exec-command.html">exec-command</a></li>
<li><a href="../modules/features.html">features</a></li>
<li><a href="../modules/file.html">file</a></li>
<li><a href="../modules/file-flash.html">file-flash</a></li>
<li><a href="../modules/file-html5.html">file-html5</a></li>
<li><a href="../modules/frame.html">frame</a></li>
<li><a href="../modules/get.html">get</a></li>
<li><a href="../modules/get-nodejs.html">get-nodejs</a></li>
<li><a href="../modules/graphics.html">graphics</a></li>
<li><a href="../modules/handlebars.html">handlebars</a></li>
<li><a href="../modules/handlebars-base.html">handlebars-base</a></li>
<li><a href="../modules/handlebars-compiler.html">handlebars-compiler</a></li>
<li><a href="../modules/highlight.html">highlight</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/highlight-base.html">highlight-base</a></li>
<li><a href="../modules/history.html">history</a></li>
<li><a href="../modules/history-base.html">history-base</a></li>
<li><a href="../modules/history-hash.html">history-hash</a></li>
<li><a href="../modules/history-hash-ie.html">history-hash-ie</a></li>
<li><a href="../modules/history-html5.html">history-html5</a></li>
<li><a href="../modules/imageloader.html">imageloader</a></li>
<li><a href="../modules/intl.html">intl</a></li>
<li><a href="../modules/io.html">io</a></li>
<li><a href="../modules/io-base.html">io-base</a></li>
<li><a href="../modules/io-form.html">io-form</a></li>
<li><a href="../modules/io-queue.html">io-queue</a></li>
<li><a href="../modules/io-upload-iframe.html">io-upload-iframe</a></li>
<li><a href="../modules/io-xdr.html">io-xdr</a></li>
<li><a href="../modules/json.html">json</a></li>
<li><a href="../modules/json-parse.html">json-parse</a></li>
<li><a href="../modules/json-stringify.html">json-stringify</a></li>
<li><a href="../modules/jsonp.html">jsonp</a></li>
<li><a href="../modules/jsonp-url.html">jsonp-url</a></li>
<li><a href="../modules/loader.html">loader</a></li>
<li><a href="../modules/loader-base.html">loader-base</a></li>
<li><a href="../modules/matrix.html">matrix</a></li>
<li><a href="../modules/model.html">model</a></li>
<li><a href="../modules/model-list.html">model-list</a></li>
<li><a href="../modules/node.html">node</a></li>
<li><a href="../modules/node-base.html">node-base</a></li>
<li><a href="../modules/node-core.html">node-core</a></li>
<li><a href="../modules/node-data.html">node-data</a></li>
<li><a href="../modules/node-deprecated.html">node-deprecated</a></li>
<li><a href="../modules/node-event-delegate.html">node-event-delegate</a></li>
<li><a href="../modules/node-event-html5.html">node-event-html5</a></li>
<li><a href="../modules/node-event-simulate.html">node-event-simulate</a></li>
<li><a href="../modules/node-flick.html">node-flick</a></li>
<li><a href="../modules/node-focusmanager.html">node-focusmanager</a></li>
<li><a href="../modules/node-load.html">node-load</a></li>
<li><a href="../modules/node-menunav.html">node-menunav</a></li>
<li><a href="../modules/node-pluginhost.html">node-pluginhost</a></li>
<li><a href="../modules/node-screen.html">node-screen</a></li>
<li><a href="../modules/node-style.html">node-style</a></li>
<li><a href="../modules/oop.html">oop</a></li>
<li><a href="../modules/overlay.html">overlay</a></li>
<li><a href="../modules/panel.html">panel</a></li>
<li><a href="../modules/parallel.html">parallel</a></li>
<li><a href="../modules/pjax.html">pjax</a></li>
<li><a href="../modules/pjax-base.html">pjax-base</a></li>
<li><a href="../modules/pjax-plugin.html">pjax-plugin</a></li>
<li><a href="../modules/plugin.html">plugin</a></li>
<li><a href="../modules/pluginhost.html">pluginhost</a></li>
<li><a href="../modules/pluginhost-base.html">pluginhost-base</a></li>
<li><a href="../modules/pluginhost-config.html">pluginhost-config</a></li>
<li><a href="../modules/profiler.html">profiler</a></li>
<li><a href="../modules/querystring.html">querystring</a></li>
<li><a href="../modules/querystring-parse.html">querystring-parse</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/queue-promote.html">queue-promote</a></li>
<li><a href="../modules/range-slider.html">range-slider</a></li>
<li><a href="../modules/recordset.html">recordset</a></li>
<li><a href="../modules/recordset-base.html">recordset-base</a></li>
<li><a href="../modules/recordset-filter.html">recordset-filter</a></li>
<li><a href="../modules/recordset-indexer.html">recordset-indexer</a></li>
<li><a href="../modules/recordset-sort.html">recordset-sort</a></li>
<li><a href="../modules/resize.html">resize</a></li>
<li><a href="../modules/resize-contrain.html">resize-contrain</a></li>
<li><a href="../modules/resize-plugin.html">resize-plugin</a></li>
<li><a href="../modules/resize-proxy.html">resize-proxy</a></li>
<li><a href="../modules/rollup.html">rollup</a></li>
<li><a href="../modules/router.html">router</a></li>
<li><a href="../modules/scrollview.html">scrollview</a></li>
<li><a href="../modules/scrollview-base.html">scrollview-base</a></li>
<li><a href="../modules/scrollview-base-ie.html">scrollview-base-ie</a></li>
<li><a href="../modules/scrollview-list.html">scrollview-list</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/selection.html">selection</a></li>
<li><a href="../modules/selector-css2.html">selector-css2</a></li>
<li><a href="../modules/selector-css3.html">selector-css3</a></li>
<li><a href="../modules/selector-native.html">selector-native</a></li>
<li><a href="../modules/shim-plugin.html">shim-plugin</a></li>
<li><a href="../modules/slider.html">slider</a></li>
<li><a href="../modules/slider-base.html">slider-base</a></li>
<li><a href="../modules/slider-value-range.html">slider-value-range</a></li>
<li><a href="../modules/sortable.html">sortable</a></li>
<li><a href="../modules/sortable-scroll.html">sortable-scroll</a></li>
<li><a href="../modules/stylesheet.html">stylesheet</a></li>
<li><a href="../modules/substitute.html">substitute</a></li>
<li><a href="../modules/swf.html">swf</a></li>
<li><a href="../modules/swfdetect.html">swfdetect</a></li>
<li><a href="../modules/tabview.html">tabview</a></li>
<li><a href="../modules/test.html">test</a></li>
<li><a href="../modules/test-console.html">test-console</a></li>
<li><a href="../modules/text.html">text</a></li>
<li><a href="../modules/text-accentfold.html">text-accentfold</a></li>
<li><a href="../modules/text-wordbreak.html">text-wordbreak</a></li>
<li><a href="../modules/transition.html">transition</a></li>
<li><a href="../modules/uploader.html">uploader</a></li>
<li><a href="../modules/uploader-deprecated.html">uploader-deprecated</a></li>
<li><a href="../modules/uploader-flash.html">uploader-flash</a></li>
<li><a href="../modules/uploader-html5.html">uploader-html5</a></li>
<li><a href="../modules/uploader-queue.html">uploader-queue</a></li>
<li><a href="../modules/view.html">view</a></li>
<li><a href="../modules/view-node-map.html">view-node-map</a></li>
<li><a href="../modules/widget.html">widget</a></li>
<li><a href="../modules/widget-anim.html">widget-anim</a></li>
<li><a href="../modules/widget-autohide.html">widget-autohide</a></li>
<li><a href="../modules/widget-base.html">widget-base</a></li>
<li><a href="../modules/widget-base-ie.html">widget-base-ie</a></li>
<li><a href="../modules/widget-buttons.html">widget-buttons</a></li>
<li><a href="../modules/widget-child.html">widget-child</a></li>
<li><a href="../modules/widget-htmlparser.html">widget-htmlparser</a></li>
<li><a href="../modules/widget-locale.html">widget-locale</a></li>
<li><a href="../modules/widget-modality.html">widget-modality</a></li>
<li><a href="../modules/widget-parent.html">widget-parent</a></li>
<li><a href="../modules/widget-position.html">widget-position</a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/<API key>.html"><API key></a></li>
<li><a href="../modules/widget-skin.html">widget-skin</a></li>
<li><a href="../modules/widget-stack.html">widget-stack</a></li>
<li><a href="../modules/widget-stdmod.html">widget-stdmod</a></li>
<li><a href="../modules/widget-uievents.html">widget-uievents</a></li>
<li><a href="../modules/yql.html">yql</a></li>
<li><a href="../modules/yui.html">yui</a></li>
<li><a href="../modules/yui-base.html">yui-base</a></li>
<li><a href="../modules/yui-later.html">yui-later</a></li>
<li><a href="../modules/yui-log.html">yui-log</a></li>
<li><a href="../modules/yui-throttle.html">yui-throttle</a></li>
<li><a href="../modules/yui3.html">yui3</a></li>
</ul>
</div>
</div>
</div>
</div>
</div>
<div class="yui3-u-3-4">
<div id="api-options">
Show:
<label for="api-show-inherited">
<input type="checkbox" id="api-show-inherited" checked>
Inherited
</label>
<label for="api-show-protected">
<input type="checkbox" id="api-show-protected">
Protected
</label>
<label for="api-show-private">
<input type="checkbox" id="api-show-private">
Private
</label>
</div>
<div class="apidocs">
<div id="docs-main">
<div class="content">
<h1 class="file-heading">File: app/js/view.js</h1>
<div class="file">
<pre class="code prettyprint linenums">
/**
Represents a logical piece of an application's user interface, and provides a
lightweight, overridable API for rendering content and handling delegated DOM
events on a container element.
@module app
@submodule view
@since 3.4.0
**/
/**
Represents a logical piece of an application's user interface, and provides a
lightweight, overridable API for rendering content and handling delegated DOM
events on a container element.
The View class imposes little structure and provides only minimal functionality
of its own: it's basically just an overridable API interface that helps you
implement custom views.
As of YUI 3.5.0, View allows ad-hoc attributes to be specified at instantiation
time, so you don't need to subclass `Y.View` to add custom attributes. Just pass
them to the constructor:
var view = new Y.View({foo: 'bar'});
view.get('foo'); // => "bar"
@class View
@constructor
@extends Base
@since 3.4.0
**/
function View() {
View.superclass.constructor.apply(this, arguments);
}
Y.View = Y.extend(View, Y.Base, {
&
/**
Template for this view's container.
@property containerTemplate
@type String
@default "<div/>"
@since 3.5.0
**/
containerTemplate: '<div/>',
/**
Hash of CSS selectors mapped to events to delegate to elements matching
those selectors.
CSS selectors are relative to the `container` element. Events are attached
to the container, and delegation is used so that subscribers are only
notified of events that occur on elements inside the container that match
the specified selectors. This allows the container's contents to be re-
rendered as needed without losing event subscriptions.
Event handlers can be specified either as functions or as strings that map
to function names on this view instance or its prototype.
The `this` object in event handlers will refer to this view instance. If
you'd prefer `this` to be something else, use `Y.bind()` to bind a custom
`this` object.
@example
var view = new Y.View({
events: {
// Call `this.toggle()` whenever the element with the id
// "toggle-button" is clicked.
'#toggle-button': {click: 'toggle'},
// Call `this.hoverOn()` when the mouse moves over any element
// with the "hoverable" class, and `this.hoverOff()` when the
// mouse moves out of any element with the "hoverable" class.
'.hoverable': {
mouseover: 'hoverOn',
mouseout : 'hoverOff'
}
}
});
@property events
@type Object
@default {}
**/
events: {},
/**
Template for this view's contents.
This is a convenience property that has no default behavior of its own.
It's only provided as a convention to allow you to store whatever you
consider to be a template, whether that's an HTML string, a `Y.Node`
instance, a Mustache template, or anything else your little heart
desires.
How this template gets used is entirely up to you and your custom
`render()` method.
@property template
@type mixed
@default ''
**/
template: '',
&
/**
This tells `Y.Base` that it should create ad-hoc attributes for config
properties passed to View's constructor. This makes it possible to
instantiate a view and set a bunch of attributes without having to subclass
`Y.View` and declare all those attributes first.
@property _allowAdHocAttrs
@type Boolean
@default true
@protected
@since 3.5.0
**/
_allowAdHocAttrs: true,
&
initializer: function (config) {
config || (config = {});
// Set instance properties specified in the config.
config.containerTemplate &&
(this.containerTemplate = config.containerTemplate);
config.template && (this.template = config.template);
// Merge events from the config into events in `this.events`.
this.events = config.events ? Y.merge(this.events, config.events) :
this.events;
// When the container node changes (or when it's set for the first
// time), we'll attach events to it, but not until then. This allows the
// container to be created lazily the first time it's accessed rather
// than always on init.
this.after('containerChange', this.<API key>);
},
/**
Destroys this View, detaching any DOM events and optionally also destroying
its container node.
By default, the container node will not be destroyed. Pass an _options_
object with a truthy `remove` property to destroy the container as well.
@method destroy
@param {Object} [options] Options.
@param {Boolean} [options.remove=false] If `true`, this View's container
will be removed from the DOM and destroyed as well.
@chainable
*/
destroy: function (options) {
// We also accept `delete` as a synonym for `remove`.
if (options && (options.remove || options['delete'])) {
// Attaching an event handler here because the `destroy` event is
// preventable. If we destroyed the container before calling the
// superclass's `destroy()` method and the event was prevented, the
// class would end up in a broken state.
this.onceAfter('destroy', function () {
this._destroyContainer();
});
}
return View.superclass.destroy.call(this);
},
destructor: function () {
this.detachEvents();
delete this._container;
},
&
/**
Attaches delegated event handlers to this view's container element. This
method is called internally to subscribe to events configured in the
`events` attribute when the view is initialized.
You may override this method to customize the event attaching logic.
@method attachEvents
@param {Object} [events] Hash of events to attach. See the docs for the
`events` attribute for details on the format. If not specified, this
view's `events` property will be used.
@chainable
@see detachEvents
**/
attachEvents: function (events) {
var container = this.get('container'),
owns = Y.Object.owns,
handler, handlers, name, selector;
this.detachEvents();
events || (events = this.events);
for (selector in events) {
if (!owns(events, selector)) { continue; }
handlers = events[selector];
for (name in handlers) {
if (!owns(handlers, name)) { continue; }
handler = handlers[name];
if (typeof handler === 'string') {
handler = this[handler];
}
this._attachedViewEvents.push(
container.delegate(name, handler, selector, this));
}
}
return this;
},
/**
Creates and returns a container node for this view.
By default, the container is created from the HTML template specified in the
`containerTemplate` property, and is _not_ added to the DOM automatically.
You may override this method to customize how the container node is created
(such as by rendering it from a custom template format). Your method must
return a `Y.Node` instance.
@method create
@param {HTMLElement|Node|String} [container] Selector string, `Y.Node`
instance, or DOM element to use at the container node.
@return {Node} Node instance of the created container node.
**/
create: function (container) {
return container ? Y.one(container) :
Y.Node.create(this.containerTemplate);
},
/**
Detaches DOM events that have previously been attached to the container by
`attachEvents()`.
@method detachEvents
@chainable
@see attachEvents
**/
detachEvents: function () {
Y.Array.each(this._attachedViewEvents, function (handle) {
handle.detach();
});
this._attachedViewEvents = [];
return this;
},
/**
Removes this view's container element from the DOM (if it's in the DOM),
but doesn't destroy it or any event listeners attached to it.
@method remove
@chainable
**/
remove: function () {
var container = this.get('container');
container && container.remove();
return this;
},
/**
Renders this view.
This method is a noop by default. Override it to provide a custom
implementation that renders this view's content and appends it to the
container element. Ideally your `render` method should also return `this` as
the end to allow chaining, but that's up to you.
Since there's no default renderer, you're free to render your view however
you see fit, whether that means manipulating the DOM directly, dumping
strings into `innerHTML`, or using a template language of some kind.
For basic templating needs, `Y.Node.create()` and `Y.Lang.sub()` may
suffice, but there are no restrictions on what tools or techniques you can
use to render your view. All you need to do is append something to the
container element at some point, and optionally append the container
to the DOM if it's not there already.
@method render
@chainable
**/
render: function () {
return this;
},
&
/**
Removes the `container` from the DOM and purges all its event listeners.
@method _destroyContainer
@protected
**/
_destroyContainer: function () {
var container = this.get('container');
container && container.remove(true);
},
/**
Getter for the `container` attribute.
@method _getContainer
@param {Node|null} value Current attribute value.
@return {Node} Container node.
@protected
@since 3.5.0
**/
_getContainer: function (value) {
// This wackiness is necessary to enable fully lazy creation of the
// container node both when no container is specified and when one is
// specified via a valueFn.
if (!this._container) {
if (value) {
// Attach events to the container when it's specified via a
// valueFn, which won't fire the containerChange event.
this._container = value;
this.attachEvents();
} else {
// Create a default container and set that as the new attribute
// value. The `this._container` property prevents infinite
// recursion.
value = this._container = this.create();
this._set('container', value);
}
}
return value;
},
&
/**
Handles `containerChange` events. Detaches event handlers from the old
container (if any) and attaches them to the new container.
Right now the `container` attr is initOnly so this event should only ever
fire the first time the container is created, but in the future (once Y.App
can handle it) we may allow runtime container changes.
@method <API key>
@protected
@since 3.5.0
**/
<API key>: function () {
this.attachEvents(this.events);
}
}, {
NAME: 'view',
ATTRS: {
/**
Container node into which this view's content will be rendered.
The container node serves as the host for all DOM events attached by the
view. Delegation is used to handle events on children of the container,
allowing the container's contents to be re-rendered at any time without
losing event subscriptions.
The default container is a `<div>` Node, but you can override this in
a subclass, or by passing in a custom `container` config value at
instantiation time.
When `container` is overridden by a subclass or passed as a config
option at instantiation time, it may be provided as a selector string, a
DOM element, or a `Y.Node` instance. The value will be converted into a
`Y.Node` instance if it isn't one already.
The container is not added to the page automatically. This allows you to
have full control over how and when your view is actually rendered to
the page.
@attribute container
@type HTMLElement|Node|String
@default Y.Node.create(this.containerTemplate)
@writeOnce
**/
container: {
getter : '_getContainer',
setter : Y.one,
writeOnce: true
}
},
/**
Properties that shouldn't be turned into ad-hoc attributes when passed to
View's constructor.
@property _NON_ATTRS_CFG
@type Array
@static
@protected
@since 3.5.0
**/
_NON_ATTRS_CFG: [
'containerTemplate',
'events',
'template'
]
});
</pre>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
<script src="../assets/vendor/prettify/prettify-min.js"></script>
<script>prettyPrint();</script>
<script src="../assets/js/yui-prettify.js"></script>
<script src="../assets/../api.js"></script>
<script src="../assets/js/api-filter.js"></script>
<script src="../assets/js/api-list.js"></script>
<script src="../assets/js/api-search.js"></script>
<script src="../assets/js/apidocs.js"></script>
</body>
</html> |
#!/usr/bin/perl
#writen 11/1/2000 by chris@katipo.oc.nz
#script to display borrowers account details
# This file is part of Koha.
# Koha is free software; you can redistribute it and/or modify it under the
# version.
# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
# with Koha; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
use strict;
use warnings;
use C4::Auth;
use C4::Output;
use C4::Dates qw/format_date/;
use CGI;
use C4::Members;
use C4::Branch;
use C4::Accounts;
use C4::Members::Attributes qw(<API key>);
my $input=new CGI;
my ($template, $loggedinuser, $cookie)
= <API key>({template_name => "members/boraccount.tmpl",
query => $input,
type => "intranet",
authnotrequired => 0,
flagsrequired => {borrowers => 1, updatecharges => 1},
debug => 1,
});
my $borrowernumber=$input->param('borrowernumber');
my $action = $input->param('action') || '';
#get borrower details
my $data=GetMember('borrowernumber' => $borrowernumber);
if ( $action eq 'reverse' ) {
ReversePayment( $borrowernumber, $input->param('accountno') );
}
if ( $data->{'category_type'} eq 'C') {
my ( $catcodes, $labels ) = <API key>( 'A', 'WHERE category_type = ?' );
my $cnt = scalar(@$catcodes);
$template->param( 'CATCODE_MULTI' => 1) if $cnt > 1;
$template->param( 'catcode' => $catcodes->[0]) if $cnt == 1;
}
#get account details
my ($total,$accts,undef)=<API key>($borrowernumber);
my $totalcredit;
if($total <= 0){
$totalcredit = 1;
}
my $reverse_col = 0; # Flag whether we need to show the reverse column
foreach my $accountline ( @{$accts}) {
$accountline->{amount} += 0.00;
if ($accountline->{amount} <= 0 ) {
$accountline->{amountcredit} = 1;
}
$accountline->{amountoutstanding} += 0.00;
if ( $accountline->{amountoutstanding} <= 0 ) {
$accountline->{<API key>} = 1;
}
$accountline->{date} = format_date($accountline->{date});
$accountline->{amount} = sprintf '%.2f', $accountline->{amount};
$accountline->{amountoutstanding} = sprintf '%.2f', $accountline->{amountoutstanding};
if ($accountline->{accounttype} eq 'Pay') {
$accountline->{payment} = 1;
$reverse_col = 1;
}
}
$template->param( adultborrower => 1 ) if ( $data->{'category_type'} eq 'A' );
my ($picture, $dberror) = GetPatronImage($data->{'cardnumber'});
$template->param( picture => 1 ) if $picture;
if (C4::Context->preference('<API key>')) {
my $attributes = <API key>($borrowernumber);
$template->param(
<API key> => 1,
extendedattributes => $attributes
);
}
$template->param(
finesview => 1,
firstname => $data->{'firstname'},
surname => $data->{'surname'},
othernames => $data->{'othernames'},
borrowernumber => $borrowernumber,
cardnumber => $data->{'cardnumber'},
categorycode => $data->{'categorycode'},
category_type => $data->{'category_type'},
categoryname => $data->{'description'},
address => $data->{'address'},
address2 => $data->{'address2'},
city => $data->{'city'},
state => $data->{'state'},
zipcode => $data->{'zipcode'},
country => $data->{'country'},
phone => $data->{'phone'},
email => $data->{'email'},
branchcode => $data->{'branchcode'},
branchname => GetBranchName($data->{'branchcode'}),
total => sprintf("%.2f",$total),
totalcredit => $totalcredit,
is_child => ($data->{'category_type'} eq 'C'),
reverse_col => $reverse_col,
accounts => $accts,
<API key> => (C4::Context->preference('<API key>') ne ''),
);
<API key> $input, $cookie, $template->output; |
#include <stdio.h>
#include "config.h"
#ifdef HAVE_STRING_H
#include <string.h>
#else
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#endif
#include "misc.h"
#include "lf.h"
#include "filter.h"
struct _filter
{
char *member;
filter *next;
};
void
filter_parse (filter **filters, const char *filt)
{
while (strlen (filt) > 0)
{
filter *new_filter;
filter **last;
/* break out a member of the filter list */
const char *flag = filt;
unsigned /*size_t */ len;
filt = strchr (filt, ',');
if (filt == NULL)
{
filt = strchr (flag, '\0');
len = strlen (flag);
}
else
{
len = filt - flag;
filt = filt + 1;
}
/* find an insertion point - sorted order */
last = filters;
while (*last != NULL && strncmp (flag, (*last)->member, len) > 0)
last = &(*last)->next;
if (*last != NULL
&& strncmp (flag, (*last)->member, len) == 0
&& strlen ((*last)->member) == len)
continue; /* duplicate */
/* create an entry for that member */
new_filter = ZALLOC (filter);
new_filter->member = NZALLOC (char, len + 1);
strncpy (new_filter->member, flag, len);
/* insert it */
new_filter->next = *last;
*last = new_filter;
}
}
void
filter_add (filter **set, filter *add)
{
while (add != NULL)
{
int cmp;
if (*set == NULL)
cmp = 1; /* set->member > add->member */
else
cmp = strcmp ((*set)->member, add->member);
if (cmp > 0)
{
/* insert it here */
filter *new = ZALLOC (filter);
new->member = NZALLOC (char, strlen (add->member) + 1);
strcpy (new->member, add->member);
new->next = *set;
*set = new;
add = add->next;
}
else if (cmp == 0)
{
/* already in set */
add = add->next;
}
else /* cmp < 0 */
{
/* not reached insertion point */
set = &(*set)->next;
}
}
}
int
filter_is_subset (filter *superset, filter *subset)
{
while (1)
{
int cmp;
if (subset == NULL)
return 1;
if (superset == NULL)
return 0; /* subset isn't finished */
cmp = strcmp (subset->member, superset->member);
if (cmp < 0)
return 0; /* not found */
else if (cmp == 0)
subset = subset->next; /* found */
else if (cmp > 0)
superset = superset->next; /* later in list? */
}
}
int
filter_is_common (filter *l, filter *r)
{
while (1)
{
int cmp;
if (l == NULL)
return 0;
if (r == NULL)
return 0;
cmp = strcmp (l->member, r->member);
if (cmp < 0)
l = l->next;
else if (cmp == 0)
return 1; /* common member */
else if (cmp > 0)
r = r->next;
}
}
int
filter_is_member (filter *filt, const char *flag)
{
int index = 1;
while (filt != NULL)
{
if (strcmp (flag, filt->member) == 0)
return index;
filt = filt->next;
index++;
}
return 0;
}
int
is_filtered_out (filter *filters, const char *flags)
{
while (strlen (flags) > 0)
{
int present;
filter *filt = filters;
/* break the string up */
char *end = strchr (flags, ',');
char *next;
unsigned /*size_t */ len;
if (end == NULL)
{
end = strchr (flags, '\0');
next = end;
}
else
{
next = end + 1;
}
len = end - flags;
/* check that it is present */
present = 0;
filt = filters;
while (filt != NULL)
{
if (strncmp (flags, filt->member, len) == 0
&& strlen (filt->member) == len)
{
present = 1;
break;
}
filt = filt->next;
}
if (!present)
return 1;
flags = next;
}
return 0;
}
#if 0
int
it_is (const char *flag, const char *flags)
{
int flag_len = strlen (flag);
while (*flags != '\0')
{
if (!strncmp (flags, flag, flag_len)
&& (flags[flag_len] == ',' || flags[flag_len] == '\0'))
return 1;
while (*flags != ',')
{
if (*flags == '\0')
return 0;
flags++;
}
flags++;
}
return 0;
}
#endif
char *
filter_next (filter *set, char *member)
{
while (set != NULL)
{
if (strcmp (set->member, member) > 0)
return set->member;
set = set->next;
}
return NULL;
}
void
dump_filter (lf *file, char *prefix, filter *set, char *suffix)
{
char *member;
lf_printf (file, "%s", prefix);
member = filter_next (set, "");
if (member != NULL)
{
while (1)
{
lf_printf (file, "%s", member);
member = filter_next (set, member);
if (member == NULL)
break;
lf_printf (file, ",");
}
}
lf_printf (file, "%s", suffix);
}
#ifdef MAIN
int
main (int argc, char **argv)
{
filter *subset = NULL;
filter *superset = NULL;
lf *l;
int i;
if (argc < 2)
{
printf ("Usage: filter <subset> <filter> ...\n");
exit (1);
}
/* load the filter up */
filter_parse (&subset, argv[1]);
for (i = 2; i < argc; i++)
filter_parse (&superset, argv[i]);
/* dump various info */
l = lf_open ("-", "stdout", lf_omit_references, lf_is_text, "tmp-filter");
#if 0
if (is_filtered_out (argv[1], superset))
lf_printf (l, "excluded\n");
else
lf_printf (l, "included\n");
#endif
/* subset */
{
dump_filter (l, "{", subset, " }");
if (filter_is_subset (superset, subset))
lf_printf (l, " subset of ");
else
lf_printf (l, " !subset of ");
dump_filter (l, "{", superset, " }");
lf_printf (l, "\n");
}
/* intersection */
{
dump_filter (l, "{", subset, " }");
if (filter_is_common (subset, superset))
lf_printf (l, " intersects ");
else
lf_printf (l, " !intersects ");
dump_filter (l, "{", superset, " }");
lf_printf (l, "\n");
}
/* membership */
{
filter *memb = subset;
while (memb != NULL)
{
lf_printf (l, "%s", memb->member);
if (filter_is_member (superset, memb->member))
lf_printf (l, " in ");
else
lf_printf (l, " !in ");
dump_filter (l, "{", superset, " }");
lf_printf (l, "\n");
memb = memb->next;
}
}
/* addition */
{
filter *add = NULL;
filter_add (&add, superset);
filter_add (&add, subset);
dump_filter (l, "{", add, " }");
lf_printf (l, " = ");
dump_filter (l, "{", subset, " }");
lf_printf (l, " + ");
dump_filter (l, "{", superset, " }");
lf_printf (l, "\n");
}
return 0;
}
#endif |
#include <linux/input.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/gpio.h>
#include <linux/platform_device.h>
#include <linux/mfd/intel_msic.h>
#include <asm/intel-mid.h>
#include <asm/intel_mid_gpadc.h>
#include <asm/intel_mid_thermal.h>
#include <linux/platform_data/<API key>.h>
#include "platform_msic.h"
#include "<API key>.h"
/* ctp thermal sensor list */
static struct <API key> ctp_sensors[] = {
{
.name = SKIN0_NAME,
.index = 0,
.slope = 410,
.intercept = 16808,
.adc_channel = 0x04 | CH_NEED_VREF | CH_NEED_VCALIB,
.temp_correlation = <API key>,
.direct = false,
},
{
.name = SKIN1_NAME,
.index = 1,
.slope = 665,
.intercept = 8375,
.adc_channel = 0x04 | CH_NEED_VREF | CH_NEED_VCALIB,
.temp_correlation = <API key>,
.direct = false,
},
{
.name = MSIC_DIE_NAME,
.index = 2,
.slope = 368,
.intercept = 219560,
.adc_channel = 0x03 | CH_NEED_VCALIB,
.direct = true,
},
{
.name = BPTHERM_NAME,
.index = 3,
.slope = 788,
.intercept = 5065,
.adc_channel = 0x09 | CH_NEED_VREF | CH_NEED_VCALIB,
.temp_correlation = <API key>,
.direct = false,
},
/*+++ ASUS_BSP : Eric*/
{
.name = GPADC8_NAME,
.index = 4,
.slope = 788,
.intercept = 5065,
.adc_channel = 0x08 | CH_NEED_VREF | CH_NEED_VCALIB,
.direct = false,
}
/*+++ ASUS_BSP : Eric*/
};
/* mfld thermal sensor list */
static struct <API key> mfld_sensors[] = {
{
.name = SKIN0_NAME,
.index = 0,
.slope = 851,
.intercept = 2800,
.adc_channel = 0x08 | CH_NEED_VREF | CH_NEED_VCALIB,
.temp_correlation = <API key>,
.direct = false,
},
{
.name = SKIN1_NAME,
.index = 1,
.slope = 806,
.intercept = 1800,
.adc_channel = 0x08 | CH_NEED_VREF | CH_NEED_VCALIB,
.temp_correlation = <API key>,
.direct = false,
},
{
.name = MSIC_SYS_NAME,
.index = 2,
.slope = 0,
.intercept = 0,
.adc_channel = 0x0A | CH_NEED_VREF | CH_NEED_VCALIB,
.direct = false,
},
{
.name = MSIC_DIE_NAME,
.index = 3,
.slope = 368,
.intercept = 219560,
.adc_channel = 0x03 | CH_NEED_VCALIB,
.direct = true,
},
};
/* LEX thermal sensor list */
static struct <API key> lex_sensors[] = {
{
.name = SKIN0_NAME,
.index = 0,
.slope = 851,
.intercept = 2800,
.adc_channel = 0x08 | CH_NEED_VREF | CH_NEED_VCALIB,
.temp_correlation = <API key>,
.direct = false,
},
{
.name = SKIN1_NAME,
.index = 1,
.slope = 806,
.intercept = 1800,
.adc_channel = 0x08 | CH_NEED_VREF | CH_NEED_VCALIB,
.temp_correlation = <API key>,
.direct = false,
},
{
.name = MSIC_SYS_NAME,
.index = 2,
.slope = 0,
.intercept = 0,
.adc_channel = 0x0A | CH_NEED_VREF | CH_NEED_VCALIB,
.direct = false,
},
{
.name = MSIC_DIE_NAME,
.index = 3,
.slope = 368,
.intercept = 219560,
.adc_channel = 0x03 | CH_NEED_VCALIB,
.direct = true,
},
};
static struct <API key> pdata[] = {
[mfld_thermal] = {
.num_sensors = 4,
.sensors = mfld_sensors,
.gpu_cooling = false,
},
[ctp_thermal] = {
.num_sensors = 5,
.sensors = ctp_sensors,
.gpu_cooling = true,
},
[lex_thermal] = {
.num_sensors = 4,
.sensors = lex_sensors,
.gpu_cooling = false,
},
};
void __init *<API key>(void *info)
{
struct platform_device *pdev;
pdev = <API key>(MSIC_THERM_DEV_NAME, -1);
if (!pdev) {
pr_err("out of memory for SFI platform dev %s\n",
MSIC_THERM_DEV_NAME);
return NULL;
}
if (platform_device_add(pdev)) {
pr_err("failed to add thermal platform device\n");
platform_device_put(pdev);
return NULL;
}
if (INTEL_MID_BOARD(2, PHONE, CLVTP, VB, PRO) ||
INTEL_MID_BOARD(2, PHONE, CLVTP, VB, ENG))
pdev->dev.platform_data = &pdata[vb_thermal];
else if (INTEL_MID_BOARD(1, PHONE, CLVTP) ||
(INTEL_MID_BOARD(1, TABLET, CLVT)))
pdev->dev.platform_data = &pdata[ctp_thermal];
else if (INTEL_MID_BOARD(2, PHONE, MFLD, LEX, ENG) ||
(INTEL_MID_BOARD(2, PHONE, MFLD, LEX, PRO)))
pdev->dev.platform_data = &pdata[lex_thermal];
else
pdev->dev.platform_data = &pdata[mfld_thermal];
<API key>("rpmsg_mid_thermal", RPROC_SCU, RP_MSIC_THERMAL);
return 0;
} |
#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/firmware.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/videodev2.h>
#include "vpdma.h"
#include "vpdma_priv.h"
#define VPDMA_FIRMWARE "vpdma-1b8.bin"
const struct vpdma_data_format vpdma_yuv_fmts[] = {
[VPDMA_DATA_FMT_Y444] = {
.type = <API key>,
.data_type = DATA_TYPE_Y444,
.depth = 8,
},
[VPDMA_DATA_FMT_Y422] = {
.type = <API key>,
.data_type = DATA_TYPE_Y422,
.depth = 8,
},
[VPDMA_DATA_FMT_Y420] = {
.type = <API key>,
.data_type = DATA_TYPE_Y420,
.depth = 8,
},
[VPDMA_DATA_FMT_C444] = {
.type = <API key>,
.data_type = DATA_TYPE_C444,
.depth = 8,
},
[VPDMA_DATA_FMT_C422] = {
.type = <API key>,
.data_type = DATA_TYPE_C422,
.depth = 8,
},
[VPDMA_DATA_FMT_C420] = {
.type = <API key>,
.data_type = DATA_TYPE_C420,
.depth = 4,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_YCR422,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_YC444,
.depth = 24,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_CRY422,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_CBY422,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_YCB422,
.depth = 16,
},
};
EXPORT_SYMBOL(vpdma_yuv_fmts);
const struct vpdma_data_format vpdma_rgb_fmts[] = {
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_RGB16_565,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_ARGB_1555,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_ARGB_4444,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_RGBA_5551,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_RGBA_4444,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = <API key>,
.depth = 24,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_RGB24_888,
.depth = 24,
},
[<API key>] = {
.type = <API key>,
.data_type = <API key>,
.depth = 32,
},
[<API key>] = {
.type = <API key>,
.data_type = <API key>,
.depth = 24,
},
[<API key>] = {
.type = <API key>,
.data_type = <API key>,
.depth = 32,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_BGR16_565,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_ABGR_1555,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_ABGR_4444,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_BGRA_5551,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_BGRA_4444,
.depth = 16,
},
[<API key>] = {
.type = <API key>,
.data_type = <API key>,
.depth = 24,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_BGR24_888,
.depth = 24,
},
[<API key>] = {
.type = <API key>,
.data_type = <API key>,
.depth = 32,
},
[<API key>] = {
.type = <API key>,
.data_type = <API key>,
.depth = 24,
},
[<API key>] = {
.type = <API key>,
.data_type = <API key>,
.depth = 32,
},
};
EXPORT_SYMBOL(vpdma_rgb_fmts);
/*
* To handle RAW format we are re-using the CBY422
* vpdma data type so that we use the vpdma to re-order
* the incoming bytes, as the parser assumes that the
* first byte presented on the bus is the MSB of a 2
* bytes value.
* RAW8 handles from 1 to 8 bits
* RAW16 handles from 9 to 16 bits
*/
const struct vpdma_data_format vpdma_raw_fmts[] = {
[VPDMA_DATA_FMT_RAW8] = {
.type = <API key>,
.data_type = DATA_TYPE_CBY422,
.depth = 8,
},
[<API key>] = {
.type = <API key>,
.data_type = DATA_TYPE_CBY422,
.depth = 16,
},
};
EXPORT_SYMBOL(vpdma_raw_fmts);
const struct vpdma_data_format vpdma_misc_fmts[] = {
[VPDMA_DATA_FMT_MV] = {
.type = <API key>,
.data_type = DATA_TYPE_MV,
.depth = 4,
},
};
EXPORT_SYMBOL(vpdma_misc_fmts);
struct vpdma_channel_info {
int num; /* VPDMA channel number */
int cstat_offset; /* client CSTAT register offset */
};
static const struct vpdma_channel_info chan_info[] = {
[VPE_CHAN_LUMA1_IN] = {
.num = <API key>,
.cstat_offset = <API key>,
},
[VPE_CHAN_CHROMA1_IN] = {
.num = <API key>,
.cstat_offset = <API key>,
},
[VPE_CHAN_LUMA2_IN] = {
.num = <API key>,
.cstat_offset = <API key>,
},
[VPE_CHAN_CHROMA2_IN] = {
.num = <API key>,
.cstat_offset = <API key>,
},
[VPE_CHAN_LUMA3_IN] = {
.num = <API key>,
.cstat_offset = <API key>,
},
[VPE_CHAN_CHROMA3_IN] = {
.num = <API key>,
.cstat_offset = <API key>,
},
[VPE_CHAN_MV_IN] = {
.num = VPE_CHAN_NUM_MV_IN,
.cstat_offset = <API key>,
},
[VPE_CHAN_MV_OUT] = {
.num = VPE_CHAN_NUM_MV_OUT,
.cstat_offset = <API key>,
},
[VPE_CHAN_LUMA_OUT] = {
.num = <API key>,
.cstat_offset = <API key>,
},
[VPE_CHAN_CHROMA_OUT] = {
.num = <API key>,
.cstat_offset = <API key>,
},
[VPE_CHAN_RGB_OUT] = {
.num = <API key>,
.cstat_offset = <API key>,
},
};
static u32 read_reg(struct vpdma_data *vpdma, int offset)
{
return ioread32(vpdma->base + offset);
}
static void write_reg(struct vpdma_data *vpdma, int offset, u32 value)
{
iowrite32(value, vpdma->base + offset);
}
static int read_field_reg(struct vpdma_data *vpdma, int offset,
u32 mask, int shift)
{
return (read_reg(vpdma, offset) & (mask << shift)) >> shift;
}
static void write_field_reg(struct vpdma_data *vpdma, int offset, u32 field,
u32 mask, int shift)
{
u32 val = read_reg(vpdma, offset);
val &= ~(mask << shift);
val |= (field & mask) << shift;
write_reg(vpdma, offset, val);
}
void vpdma_dump_regs(struct vpdma_data *vpdma)
{
struct device *dev = &vpdma->pdev->dev;
#define DUMPREG(r) dev_dbg(dev, "%-35s %08x\n", #r, read_reg(vpdma, VPDMA_##r))
dev_dbg(dev, "VPDMA Registers:\n");
DUMPREG(PID);
DUMPREG(LIST_ADDR);
DUMPREG(LIST_ATTR);
DUMPREG(LIST_STAT_SYNC);
DUMPREG(BG_RGB);
DUMPREG(BG_YUV);
DUMPREG(SETUP);
DUMPREG(MAX_SIZE1);
DUMPREG(MAX_SIZE2);
DUMPREG(MAX_SIZE3);
/*
* dumping registers of only group0 and group3, because VPE channels
* lie within group0 and group3 registers
*/
DUMPREG(INT_CHAN_STAT(0));
DUMPREG(INT_CHAN_MASK(0));
DUMPREG(INT_CHAN_STAT(3));
DUMPREG(INT_CHAN_MASK(3));
DUMPREG(INT_CLIENT0_STAT);
DUMPREG(INT_CLIENT0_MASK);
DUMPREG(INT_CLIENT1_STAT);
DUMPREG(INT_CLIENT1_MASK);
DUMPREG(INT_LIST0_STAT);
DUMPREG(INT_LIST0_MASK);
/*
* these are registers specific to VPE clients, we can make this
* function dump client registers specific to VPE or VIP based on
* who is using it
*/
DUMPREG(DEI_CHROMA1_CSTAT);
DUMPREG(DEI_LUMA1_CSTAT);
DUMPREG(DEI_CHROMA2_CSTAT);
DUMPREG(DEI_LUMA2_CSTAT);
DUMPREG(DEI_CHROMA3_CSTAT);
DUMPREG(DEI_LUMA3_CSTAT);
DUMPREG(DEI_MV_IN_CSTAT);
DUMPREG(DEI_MV_OUT_CSTAT);
DUMPREG(VIP_UP_Y_CSTAT);
DUMPREG(VIP_UP_UV_CSTAT);
DUMPREG(VPI_CTL_CSTAT);
}
EXPORT_SYMBOL(vpdma_dump_regs);
/*
* Allocate a DMA buffer
*/
int <API key>(struct vpdma_buf *buf, size_t size)
{
buf->size = size;
buf->mapped = false;
buf->addr = kzalloc(size, GFP_KERNEL);
if (!buf->addr)
return -ENOMEM;
WARN_ON(((unsigned long)buf->addr & VPDMA_DESC_ALIGN) != 0);
return 0;
}
EXPORT_SYMBOL(<API key>);
void vpdma_free_desc_buf(struct vpdma_buf *buf)
{
WARN_ON(buf->mapped);
kfree(buf->addr);
buf->addr = NULL;
buf->size = 0;
}
EXPORT_SYMBOL(vpdma_free_desc_buf);
/*
* map descriptor/payload DMA buffer, enabling DMA access
*/
int vpdma_map_desc_buf(struct vpdma_data *vpdma, struct vpdma_buf *buf)
{
struct device *dev = &vpdma->pdev->dev;
WARN_ON(buf->mapped);
buf->dma_addr = dma_map_single(dev, buf->addr, buf->size,
DMA_BIDIRECTIONAL);
if (dma_mapping_error(dev, buf->dma_addr)) {
dev_err(dev, "failed to map buffer\n");
return -EINVAL;
}
buf->mapped = true;
return 0;
}
EXPORT_SYMBOL(vpdma_map_desc_buf);
/*
* unmap descriptor/payload DMA buffer, disabling DMA access and
* allowing the main processor to acces the data
*/
void <API key>(struct vpdma_data *vpdma, struct vpdma_buf *buf)
{
struct device *dev = &vpdma->pdev->dev;
if (buf->mapped)
dma_unmap_single(dev, buf->dma_addr, buf->size,
DMA_BIDIRECTIONAL);
buf->mapped = false;
}
EXPORT_SYMBOL(<API key>);
/*
* Cleanup all pending descriptors of a list
* First, stop the current list being processed.
* If the VPDMA was busy, this step makes vpdma to accept post lists.
* To cleanup the internal FSM, post abort list descriptor for all the
* channels from @channels array of size @size.
*/
int vpdma_list_cleanup(struct vpdma_data *vpdma, int list_num,
int *channels, int size)
{
struct vpdma_desc_list abort_list;
int i, ret, timeout = 500;
write_reg(vpdma, VPDMA_LIST_ATTR,
(list_num << VPDMA_LIST_NUM_SHFT) |
(1 << <API key>));
if (size <= 0 || !channels)
return 0;
ret = <API key>(&abort_list,
size * sizeof(struct vpdma_dtd), <API key>);
if (ret)
return ret;
for (i = 0; i < size; i++)
<API key>(&abort_list, channels[i]);
ret = vpdma_map_desc_buf(vpdma, &abort_list.buf);
if (ret)
return ret;
ret = vpdma_submit_descs(vpdma, &abort_list, list_num);
if (ret)
return ret;
while (vpdma_list_busy(vpdma, list_num) && timeout
;
if (timeout == 0) {
dev_err(&vpdma->pdev->dev, "Timed out cleaning up VPDMA list\n");
return -EBUSY;
}
<API key>(vpdma, &abort_list.buf);
vpdma_free_desc_buf(&abort_list.buf);
return 0;
}
EXPORT_SYMBOL(vpdma_list_cleanup);
/*
* create a descriptor list, the user of this list will append configuration,
* control and data descriptors to this list, this list will be submitted to
* VPDMA. VPDMA's list parser will go through each descriptor and perform the
* required DMA operations
*/
int <API key>(struct vpdma_desc_list *list, size_t size, int type)
{
int r;
r = <API key>(&list->buf, size);
if (r)
return r;
list->next = list->buf.addr;
list->type = type;
return 0;
}
EXPORT_SYMBOL(<API key>);
/*
* once a descriptor list is parsed by VPDMA, we reset the list by emptying it,
* to allow new descriptors to be added to the list.
*/
void <API key>(struct vpdma_desc_list *list)
{
list->next = list->buf.addr;
}
EXPORT_SYMBOL(<API key>);
/*
* free the buffer allocated fot the VPDMA descriptor list, this should be
* called when the user doesn't want to use VPDMA any more.
*/
void <API key>(struct vpdma_desc_list *list)
{
vpdma_free_desc_buf(&list->buf);
list->next = NULL;
}
EXPORT_SYMBOL(<API key>);
bool vpdma_list_busy(struct vpdma_data *vpdma, int list_num)
{
return read_reg(vpdma, <API key>) & BIT(list_num + 16);
}
EXPORT_SYMBOL(vpdma_list_busy);
/*
* submit a list of DMA descriptors to the VPE VPDMA, do not wait for completion
*/
int vpdma_submit_descs(struct vpdma_data *vpdma,
struct vpdma_desc_list *list, int list_num)
{
int list_size;
unsigned long flags;
if (vpdma_list_busy(vpdma, list_num))
return -EBUSY;
/* 16-byte granularity */
list_size = (list->next - list->buf.addr) >> 4;
spin_lock_irqsave(&vpdma->lock, flags);
write_reg(vpdma, VPDMA_LIST_ADDR, (u32) list->buf.dma_addr);
write_reg(vpdma, VPDMA_LIST_ATTR,
(list_num << VPDMA_LIST_NUM_SHFT) |
(list->type << <API key>) |
list_size);
<API key>(&vpdma->lock, flags);
return 0;
}
EXPORT_SYMBOL(vpdma_submit_descs);
static void dump_dtd(struct vpdma_dtd *dtd);
void <API key>(struct vpdma_data *vpdma,
struct vpdma_desc_list *list, dma_addr_t dma_addr,
void *write_dtd, int drop, int idx)
{
struct vpdma_dtd *dtd = list->buf.addr;
dma_addr_t write_desc_addr;
int offset;
dtd += idx;
<API key>(vpdma, &list->buf);
dtd->start_addr = dma_addr;
/* Calculate write address from the offset of write_dtd from start
* of the list->buf
*/
offset = (void *)write_dtd - list->buf.addr;
write_desc_addr = list->buf.dma_addr + offset;
if (drop)
dtd->desc_write_addr = dtd_desc_write_addr(write_desc_addr,
1, 1, 0);
else
dtd->desc_write_addr = dtd_desc_write_addr(write_desc_addr,
1, 0, 0);
vpdma_map_desc_buf(vpdma, &list->buf);
dump_dtd(dtd);
}
EXPORT_SYMBOL(<API key>);
void vpdma_set_max_size(struct vpdma_data *vpdma, int reg_addr,
u32 width, u32 height)
{
if (reg_addr != VPDMA_MAX_SIZE1 && reg_addr != VPDMA_MAX_SIZE2 &&
reg_addr != VPDMA_MAX_SIZE3)
reg_addr = VPDMA_MAX_SIZE1;
write_field_reg(vpdma, reg_addr, width - 1,
<API key>, <API key>);
write_field_reg(vpdma, reg_addr, height - 1,
<API key>, <API key>);
}
EXPORT_SYMBOL(vpdma_set_max_size);
static void dump_cfd(struct vpdma_cfd *cfd)
{
int class;
class = cfd_get_class(cfd);
pr_debug("config descriptor of payload class: %s\n",
class == CFD_CLS_BLOCK ? "simple block" :
"address data block");
if (class == CFD_CLS_BLOCK)
pr_debug("word0: dst_addr_offset = 0x%08x\n",
cfd->dest_addr_offset);
if (class == CFD_CLS_BLOCK)
pr_debug("word1: num_data_wrds = %d\n", cfd->block_len);
pr_debug("word2: payload_addr = 0x%08x\n", cfd->payload_addr);
pr_debug("word3: pkt_type = %d, direct = %d, class = %d, dest = %d, "
"payload_len = %d\n", cfd_get_pkt_type(cfd),
cfd_get_direct(cfd), class, cfd_get_dest(cfd),
cfd_get_payload_len(cfd));
}
/*
* append a configuration descriptor to the given descriptor list, where the
* payload is in the form of a simple data block specified in the descriptor
* header, this is used to upload scaler coefficients to the scaler module
*/
void vpdma_add_cfd_block(struct vpdma_desc_list *list, int client,
struct vpdma_buf *blk, u32 dest_offset)
{
struct vpdma_cfd *cfd;
int len = blk->size;
WARN_ON(blk->dma_addr & VPDMA_DESC_ALIGN);
cfd = list->next;
WARN_ON((void *)(cfd + 1) > (list->buf.addr + list->buf.size));
cfd->dest_addr_offset = dest_offset;
cfd->block_len = len;
cfd->payload_addr = (u32) blk->dma_addr;
cfd->ctl_payload_len = cfd_pkt_payload_len(CFD_INDIRECT, CFD_CLS_BLOCK,
client, len >> 4);
list->next = cfd + 1;
dump_cfd(cfd);
}
EXPORT_SYMBOL(vpdma_add_cfd_block);
/*
* append a configuration descriptor to the given descriptor list, where the
* payload is in the address data block format, this is used to a configure a
* discontiguous set of MMRs
*/
void vpdma_add_cfd_adb(struct vpdma_desc_list *list, int client,
struct vpdma_buf *adb)
{
struct vpdma_cfd *cfd;
unsigned int len = adb->size;
WARN_ON(len & <API key>);
WARN_ON(adb->dma_addr & VPDMA_DESC_ALIGN);
cfd = list->next;
BUG_ON((void *)(cfd + 1) > (list->buf.addr + list->buf.size));
cfd->w0 = 0;
cfd->w1 = 0;
cfd->payload_addr = (u32) adb->dma_addr;
cfd->ctl_payload_len = cfd_pkt_payload_len(CFD_INDIRECT, CFD_CLS_ADB,
client, len >> 4);
list->next = cfd + 1;
dump_cfd(cfd);
};
EXPORT_SYMBOL(vpdma_add_cfd_adb);
/*
* control descriptor format change based on what type of control descriptor it
* is, we only use 'sync on channel' control descriptors for now, so assume it's
* that
*/
static void dump_ctd(struct vpdma_ctd *ctd)
{
pr_debug("control descriptor\n");
pr_debug("word3: pkt_type = %d, source = %d, ctl_type = %d\n",
ctd_get_pkt_type(ctd), ctd_get_source(ctd), ctd_get_ctl(ctd));
}
/*
* append a 'sync on channel' type control descriptor to the given descriptor
* list, this descriptor stalls the VPDMA list till the time DMA is completed
* on the specified channel
*/
void <API key>(struct vpdma_desc_list *list,
enum vpdma_channel chan)
{
struct vpdma_ctd *ctd;
ctd = list->next;
WARN_ON((void *)(ctd + 1) > (list->buf.addr + list->buf.size));
ctd->w0 = 0;
ctd->w1 = 0;
ctd->w2 = 0;
ctd->type_source_ctl = ctd_type_source_ctl(chan_info[chan].num,
<API key>);
list->next = ctd + 1;
dump_ctd(ctd);
}
EXPORT_SYMBOL(<API key>);
/*
* append an 'abort_channel' type control descriptor to the given descriptor
* list, this descriptor aborts any DMA transaction happening using the
* specified channel
*/
void <API key>(struct vpdma_desc_list *list,
int chan_num)
{
struct vpdma_ctd *ctd;
ctd = list->next;
WARN_ON((void *)(ctd + 1) > (list->buf.addr + list->buf.size));
ctd->w0 = 0;
ctd->w1 = 0;
ctd->w2 = 0;
ctd->type_source_ctl = ctd_type_source_ctl(chan_num,
<API key>);
list->next = ctd + 1;
dump_ctd(ctd);
}
EXPORT_SYMBOL(<API key>);
static void dump_dtd(struct vpdma_dtd *dtd)
{
int dir, chan;
dir = dtd_get_dir(dtd);
chan = dtd_get_chan(dtd);
pr_debug("%s data transfer descriptor for channel %d\n",
dir == DTD_DIR_OUT ? "outbound" : "inbound", chan);
pr_debug("word0: data_type = %d, notify = %d, field = %d, 1D = %d, "
"even_ln_skp = %d, odd_ln_skp = %d, line_stride = %d\n",
dtd_get_data_type(dtd), dtd_get_notify(dtd), dtd_get_field(dtd),
dtd_get_1d(dtd), <API key>(dtd),
<API key>(dtd), dtd_get_line_stride(dtd));
if (dir == DTD_DIR_IN)
pr_debug("word1: line_length = %d, xfer_height = %d\n",
dtd_get_line_length(dtd), dtd_get_xfer_height(dtd));
pr_debug("word2: start_addr = %pad\n", &dtd->start_addr);
pr_debug("word3: pkt_type = %d, mode = %d, dir = %d, chan = %d, "
"pri = %d, next_chan = %d\n", dtd_get_pkt_type(dtd),
dtd_get_mode(dtd), dir, chan, dtd_get_priority(dtd),
dtd_get_next_chan(dtd));
if (dir == DTD_DIR_IN)
pr_debug("word4: frame_width = %d, frame_height = %d\n",
dtd_get_frame_width(dtd), <API key>(dtd));
else
pr_debug("word4: desc_write_addr = 0x%08x, write_desc = %d, "
"drp_data = %d, use_desc_reg = %d\n",
<API key>(dtd), dtd_get_write_desc(dtd),
dtd_get_drop_data(dtd), dtd_get_use_desc(dtd));
if (dir == DTD_DIR_IN)
pr_debug("word5: hor_start = %d, ver_start = %d\n",
dtd_get_h_start(dtd), dtd_get_v_start(dtd));
else
pr_debug("word5: max_width %d, max_height %d\n",
dtd_get_max_width(dtd), dtd_get_max_height(dtd));
pr_debug("word6: client specific attr0 = 0x%08x\n", dtd->client_attr0);
pr_debug("word7: client specific attr1 = 0x%08x\n", dtd->client_attr1);
}
/*
* append an outbound data transfer descriptor to the given descriptor list,
* this sets up a 'client to memory' VPDMA transfer for the given VPDMA channel
*
* @list: vpdma desc list to which we add this decriptor
* @width: width of the image in pixels in memory
* @c_rect: compose params of output image
* @fmt: vpdma data format of the buffer
* dma_addr: dma address as seen by VPDMA
* max_width: enum for maximum width of data transfer
* max_height: enum for maximum height of data transfer
* chan: VPDMA channel
* flags: VPDMA flags to configure some descriptor fileds
*/
void vpdma_add_out_dtd(struct vpdma_desc_list *list, int width,
const struct v4l2_rect *c_rect,
const struct vpdma_data_format *fmt, dma_addr_t dma_addr,
int max_w, int max_h, enum vpdma_channel chan, u32 flags)
{
<API key>(list, width, c_rect, fmt, dma_addr,
max_w, max_h, chan_info[chan].num, flags);
}
EXPORT_SYMBOL(vpdma_add_out_dtd);
void <API key>(struct vpdma_desc_list *list, int width,
const struct v4l2_rect *c_rect,
const struct vpdma_data_format *fmt, dma_addr_t dma_addr,
int max_w, int max_h, int raw_vpdma_chan, u32 flags)
{
int priority = 0;
int field = 0;
int notify = 1;
int channel, next_chan;
struct v4l2_rect rect = *c_rect;
int depth = fmt->depth;
int stride;
struct vpdma_dtd *dtd;
channel = next_chan = raw_vpdma_chan;
if (fmt->type == <API key> &&
fmt->data_type == DATA_TYPE_C420) {
rect.height >>= 1;
rect.top >>= 1;
depth = 8;
}
stride = ALIGN((depth * width) >> 3, VPDMA_STRIDE_ALIGN);
dma_addr += rect.top * stride + (rect.left * depth >> 3);
dtd = list->next;
WARN_ON((void *)(dtd + 1) > (list->buf.addr + list->buf.size));
dtd->type_ctl_stride = dtd_type_ctl_stride(fmt->data_type,
notify,
field,
!!(flags & VPDMA_DATA_FRAME_1D),
!!(flags & <API key>),
!!(flags & <API key>),
stride);
dtd->w1 = 0;
dtd->start_addr = (u32) dma_addr;
dtd->pkt_ctl = dtd_pkt_ctl(!!(flags & <API key>),
DTD_DIR_OUT, channel, priority, next_chan);
dtd->desc_write_addr = dtd_desc_write_addr(0, 0, 0, 0);
dtd->max_width_height = <API key>(max_w, max_h);
dtd->client_attr0 = 0;
dtd->client_attr1 = 0;
list->next = dtd + 1;
dump_dtd(dtd);
}
EXPORT_SYMBOL(<API key>);
/*
* append an inbound data transfer descriptor to the given descriptor list,
* this sets up a 'memory to client' VPDMA transfer for the given VPDMA channel
*
* @list: vpdma desc list to which we add this decriptor
* @width: width of the image in pixels in memory(not the cropped width)
* @c_rect: crop params of input image
* @fmt: vpdma data format of the buffer
* dma_addr: dma address as seen by VPDMA
* chan: VPDMA channel
* field: top or bottom field info of the input image
* flags: VPDMA flags to configure some descriptor fileds
* frame_width/height: the complete width/height of the image presented to the
* client (this makes sense when multiple channels are
* connected to the same client, forming a larger frame)
* start_h, start_v: position where the given channel starts providing pixel
* data to the client (makes sense when multiple channels
* contribute to the client)
*/
void vpdma_add_in_dtd(struct vpdma_desc_list *list, int width,
const struct v4l2_rect *c_rect,
const struct vpdma_data_format *fmt, dma_addr_t dma_addr,
enum vpdma_channel chan, int field, u32 flags, int frame_width,
int frame_height, int start_h, int start_v)
{
int priority = 0;
int notify = 1;
int depth = fmt->depth;
int channel, next_chan;
struct v4l2_rect rect = *c_rect;
int stride;
struct vpdma_dtd *dtd;
channel = next_chan = chan_info[chan].num;
if (fmt->type == <API key> &&
fmt->data_type == DATA_TYPE_C420) {
rect.height >>= 1;
rect.top >>= 1;
depth = 8;
}
stride = ALIGN((depth * width) >> 3, VPDMA_STRIDE_ALIGN);
dma_addr += rect.top * stride + (rect.left * depth >> 3);
dtd = list->next;
WARN_ON((void *)(dtd + 1) > (list->buf.addr + list->buf.size));
dtd->type_ctl_stride = dtd_type_ctl_stride(fmt->data_type,
notify,
field,
!!(flags & VPDMA_DATA_FRAME_1D),
!!(flags & <API key>),
!!(flags & <API key>),
stride);
dtd->xfer_length_height = <API key>(rect.width,
rect.height);
dtd->start_addr = (u32) dma_addr;
dtd->pkt_ctl = dtd_pkt_ctl(!!(flags & <API key>),
DTD_DIR_IN, channel, priority, next_chan);
dtd->frame_width_height = <API key>(frame_width,
frame_height);
dtd->start_h_v = dtd_start_h_v(start_h, start_v);
dtd->client_attr0 = 0;
dtd->client_attr1 = 0;
list->next = dtd + 1;
dump_dtd(dtd);
}
EXPORT_SYMBOL(vpdma_add_in_dtd);
int vpdma_hwlist_alloc(struct vpdma_data *vpdma, void *priv)
{
int i, list_num = -1;
unsigned long flags;
spin_lock_irqsave(&vpdma->lock, flags);
for (i = 0; i < VPDMA_MAX_NUM_LIST &&
vpdma->hwlist_used[i] == true; i++)
;
if (i < VPDMA_MAX_NUM_LIST) {
list_num = i;
vpdma->hwlist_used[i] = true;
vpdma->hwlist_priv[i] = priv;
}
<API key>(&vpdma->lock, flags);
return list_num;
}
EXPORT_SYMBOL(vpdma_hwlist_alloc);
void *<API key>(struct vpdma_data *vpdma, int list_num)
{
if (!vpdma || list_num >= VPDMA_MAX_NUM_LIST)
return NULL;
return vpdma->hwlist_priv[list_num];
}
EXPORT_SYMBOL(<API key>);
void *<API key>(struct vpdma_data *vpdma, int list_num)
{
void *priv;
unsigned long flags;
spin_lock_irqsave(&vpdma->lock, flags);
vpdma->hwlist_used[list_num] = false;
priv = vpdma->hwlist_priv;
<API key>(&vpdma->lock, flags);
return priv;
}
EXPORT_SYMBOL(<API key>);
/* set or clear the mask for list complete interrupt */
void <API key>(struct vpdma_data *vpdma, int irq_num,
int list_num, bool enable)
{
u32 reg_addr = <API key> + VPDMA_INTX_OFFSET * irq_num;
u32 val;
val = read_reg(vpdma, reg_addr);
if (enable)
val |= (1 << (list_num * 2));
else
val &= ~(1 << (list_num * 2));
write_reg(vpdma, reg_addr, val);
}
EXPORT_SYMBOL(<API key>);
/* set or clear the mask for list complete interrupt */
void <API key>(struct vpdma_data *vpdma, int irq_num,
int list_num, bool enable)
{
u32 reg_addr = <API key> + VPDMA_INTX_OFFSET * irq_num;
u32 val;
val = read_reg(vpdma, reg_addr);
if (enable)
val |= (1 << ((list_num * 2) + 1));
else
val &= ~(1 << ((list_num * 2) + 1));
write_reg(vpdma, reg_addr, val);
}
EXPORT_SYMBOL(<API key>);
/* get the LIST_STAT register */
unsigned int vpdma_get_list_stat(struct vpdma_data *vpdma, int irq_num)
{
u32 reg_addr = <API key> + VPDMA_INTX_OFFSET * irq_num;
return read_reg(vpdma, reg_addr);
}
EXPORT_SYMBOL(vpdma_get_list_stat);
/* get the LIST_MASK register */
unsigned int vpdma_get_list_mask(struct vpdma_data *vpdma, int irq_num)
{
u32 reg_addr = <API key> + VPDMA_INTX_OFFSET * irq_num;
return read_reg(vpdma, reg_addr);
}
EXPORT_SYMBOL(vpdma_get_list_mask);
/* clear previosuly occured list intterupts in the LIST_STAT register */
void <API key>(struct vpdma_data *vpdma, int irq_num,
int list_num)
{
u32 reg_addr = <API key> + VPDMA_INTX_OFFSET * irq_num;
write_reg(vpdma, reg_addr, 3 << (list_num * 2));
}
EXPORT_SYMBOL(<API key>);
void vpdma_set_bg_color(struct vpdma_data *vpdma,
struct vpdma_data_format *fmt, u32 color)
{
if (fmt->type == <API key>)
write_reg(vpdma, VPDMA_BG_RGB, color);
else if (fmt->type == <API key>)
write_reg(vpdma, VPDMA_BG_YUV, color);
}
EXPORT_SYMBOL(vpdma_set_bg_color);
/*
* configures the output mode of the line buffer for the given client, the
* line buffer content can either be mirrored(each line repeated twice) or
* passed to the client as is
*/
void vpdma_set_line_mode(struct vpdma_data *vpdma, int line_mode,
enum vpdma_channel chan)
{
int client_cstat = chan_info[chan].cstat_offset;
write_field_reg(vpdma, client_cstat, line_mode,
<API key>, <API key>);
}
EXPORT_SYMBOL(vpdma_set_line_mode);
/*
* configures the event which should trigger VPDMA transfer for the given
* client
*/
void <API key>(struct vpdma_data *vpdma,
enum <API key> fs_event,
enum vpdma_channel chan)
{
int client_cstat = chan_info[chan].cstat_offset;
write_field_reg(vpdma, client_cstat, fs_event,
<API key>, <API key>);
}
EXPORT_SYMBOL(<API key>);
static void vpdma_firmware_cb(const struct firmware *f, void *context)
{
struct vpdma_data *vpdma = context;
struct vpdma_buf fw_dma_buf;
int i, r;
dev_dbg(&vpdma->pdev->dev, "firmware callback\n");
if (!f || !f->data) {
dev_err(&vpdma->pdev->dev, "couldn't get firmware\n");
return;
}
/* already initialized */
if (read_field_reg(vpdma, VPDMA_LIST_ATTR, VPDMA_LIST_RDY_MASK,
VPDMA_LIST_RDY_SHFT)) {
vpdma->cb(vpdma->pdev);
return;
}
r = <API key>(&fw_dma_buf, f->size);
if (r) {
dev_err(&vpdma->pdev->dev,
"failed to allocate dma buffer for firmware\n");
goto rel_fw;
}
memcpy(fw_dma_buf.addr, f->data, f->size);
vpdma_map_desc_buf(vpdma, &fw_dma_buf);
write_reg(vpdma, VPDMA_LIST_ADDR, (u32) fw_dma_buf.dma_addr);
for (i = 0; i < 100; i++) { /* max 1 second */
<API key>(10);
if (read_field_reg(vpdma, VPDMA_LIST_ATTR, VPDMA_LIST_RDY_MASK,
VPDMA_LIST_RDY_SHFT))
break;
}
if (i == 100) {
dev_err(&vpdma->pdev->dev, "firmware upload failed\n");
goto free_buf;
}
vpdma->cb(vpdma->pdev);
free_buf:
<API key>(vpdma, &fw_dma_buf);
vpdma_free_desc_buf(&fw_dma_buf);
rel_fw:
release_firmware(f);
}
static int vpdma_load_firmware(struct vpdma_data *vpdma)
{
int r;
struct device *dev = &vpdma->pdev->dev;
r = <API key>(THIS_MODULE, 1,
(const char *) VPDMA_FIRMWARE, dev, GFP_KERNEL, vpdma,
vpdma_firmware_cb);
if (r) {
dev_err(dev, "firmware not available %s\n", VPDMA_FIRMWARE);
return r;
} else {
dev_info(dev, "loading firmware %s\n", VPDMA_FIRMWARE);
}
return 0;
}
int vpdma_create(struct platform_device *pdev, struct vpdma_data *vpdma,
void (*cb)(struct platform_device *pdev))
{
struct resource *res;
int r;
dev_dbg(&pdev->dev, "vpdma_create\n");
vpdma->pdev = pdev;
vpdma->cb = cb;
spin_lock_init(&vpdma->lock);
res = <API key>(pdev, IORESOURCE_MEM, "vpdma");
if (res == NULL) {
dev_err(&pdev->dev, "missing platform resources data\n");
return -ENODEV;
}
vpdma->base = devm_ioremap(&pdev->dev, res->start, resource_size(res));
if (!vpdma->base) {
dev_err(&pdev->dev, "failed to ioremap\n");
return -ENOMEM;
}
r = vpdma_load_firmware(vpdma);
if (r) {
pr_err("failed to load firmware %s\n", VPDMA_FIRMWARE);
return r;
}
return 0;
}
EXPORT_SYMBOL(vpdma_create);
MODULE_AUTHOR("Texas Instruments Inc.");
MODULE_FIRMWARE(VPDMA_FIRMWARE);
MODULE_LICENSE("GPL v2"); |
.mceVisualAid {
border: 1px dashed #BBBBBB;
width: inherit;
margin: 2px;
}
p.mceVisualAid, div.mceVisualAid, code.mceVisualAid, pre.mceVisualAid, blockquote.mceVisualAid, address.mceVisualAid,
h1.mceVisualAid, h2.mceVisualAid, h3.mceVisualAid, h4.mceVisualAid, h5.mceVisualAid, h6.mceVisualAid {
padding: 10px 2px 2px 5px;
}
p.mceVisualAid {
background: url('../img/p.gif') no-repeat top left;
}
div.mceVisualAid {
background: url('../img/div.gif') no-repeat top left;
}
code.mceVisualAid {
background: url('../img/code.gif') no-repeat top left;
}
pre.mceVisualAid {
background: url('../img/pre.gif') no-repeat top left;
}
blockquote.mceVisualAid {
background: url('../img/blockquote.gif') no-repeat top left;
}
address.mceVisualAid {
background: url('../img/address.gif') no-repeat top left;
}
h1.mceVisualAid {
background: url('../img/h1.gif') no-repeat top left;
}
h2.mceVisualAid {
background: url('../img/h2.gif') no-repeat top left;
}
h3.mceVisualAid {
background: url('../img/h3.gif') no-repeat top left;
}
h4.mceVisualAid {
background: url('../img/h4.gif') no-repeat top left;
}
h5.mceVisualAid {
background: url('../img/h5.gif') no-repeat top left;
}
h6.mceVisualAid {
background: url('../img/h6.gif') no-repeat top left;
}
ul.mceVisualAid {
background: url('../img/ul.gif') no-repeat top left;
}
ol.mceVisualAid {
background: url('../img/ol.gif') no-repeat top left;
} |
#include "gdb2384-base.h"
class derived1 : public base
{
public:
derived1 (int);
};
derived1::derived1 (int _x)
: base (_x)
{
}
class derived2 : public derived
{
public:
derived2 (int);
};
derived2::derived2 (int _x)
: derived (_x)
{
}
int g;
int
main ()
{
derived1 d1 (42);
derived2 d2 (24);
g = d1.meth (); // set breakpoint here
g = d2.meth (); // set breakpoint here (second)
return 0;
} |
/* accepts a named.conf or a zone as parameter and outputs heaps of sql */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <unistd.h>
#include <string>
#include <map>
#include <iostream>
#include <stdio.h>
#include "namespaces.hh"
#include "dns.hh"
#include "arguments.hh"
#include "bindparserclasses.hh"
#include "statbag.hh"
#include "misc.hh"
#include "dnspacket.hh"
#include "zoneparser-tng.hh"
#include "dnsrecords.hh"
#include <boost/algorithm/string.hpp>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "json11.hpp"
using namespace json11;
StatBag S;
static int g_numRecords;
static Json::object emitRecord(const string& zoneName, const DNSName &DNSqname, const string &qtype, const string &ocontent, int ttl)
{
int prio=0;
string retval;
g_numRecords++;
string content(ocontent);
if(qtype == "MX" || qtype == "SRV") {
prio=pdns_stou(content);
string::size_type pos = content.find_first_not_of("0123456789");
if(pos != string::npos)
boost::erase_head(content, pos);
boost::trim_left(content);
}
Json::object dict;
dict["name"] = DNSqname.toString();
dict["type"] = qtype;
dict["ttl"] = ttl;
dict["prio"] = prio;
dict["content"] = content;
return dict;
}
/* 2 modes of operation, either --named or --zone (the latter needs $ORIGIN)
1 further mode: --mysql
*/
ArgvMap &arg()
{
static ArgvMap theArg;
return theArg;
}
int main(int argc, char **argv)
try
{
vector<string> lines;
reportAllTypes();
std::ios_base::sync_with_stdio(false);
::arg().setSwitch("verbose","Verbose comments on operation")="no";
::arg().setSwitch("<API key>","Continue after errors")="no";
::arg().set("zone","Zonefile to parse")="";
::arg().set("zone-name","Specify an $ORIGIN in case it is not present")="";
::arg().set("named-conf","Bind 8/9 named.conf to parse")="";
::arg().set("max-generate-steps", "Maximum number of $GENERATE steps when loading a zone from a file")="0";
::arg().set("max-include-depth", "Maximum level of nested $INCLUDE depth when loading a zone from a file")="20";
::arg().setCmd("help","Provide a helpful message");
::arg().setCmd("version","Print the version");
S.declare("logmessages");
string namedfile="";
string zonefile="";
::arg().parse(argc, argv);
if(::arg().mustDo("version")){
cerr<<"zone2json "<<VERSION<<endl;
exit(0);
}
if(::arg().mustDo("help")) {
cout<<"syntax:"<<endl<<endl;
cout<<::arg().helpstring()<<endl;
exit(0);
}
if(argc<2) {
cerr<<"syntax:"<<endl<<endl;
cerr<<::arg().helpstring()<<endl;
exit(1);
}
namedfile=::arg()["named-conf"];
zonefile=::arg()["zone"];
int count=0, num_domainsdone=0;
if(zonefile.empty()) {
BindParser BP;
BP.setVerbose(::arg().mustDo("verbose"));
BP.parse(namedfile.empty() ? "./named.conf" : namedfile);
vector<BindDomainInfo> domains=BP.getDomains();
struct stat st;
for(auto & domain : domains) {
if(stat(domain.filename.c_str(), &st) == 0) {
domain.d_dev = st.st_dev;
domain.d_ino = st.st_ino;
}
}
sort(domains.begin(), domains.end()); // put stuff in inode order
int numdomains=domains.size();
int tick=numdomains/100;
cout << "[";
for(vector<BindDomainInfo>::const_iterator i=domains.begin();
i!=domains.end();
++i)
{
if(i->type!="master" && i->type!="slave") {
cerr<<" Warning! Skipping '"<<i->type<<"' zone '"<<i->name<<"'"<<endl;
continue;
}
lines.clear();
try {
Json::object obj;
Json::array recs;
ZoneParserTNG zpt(i->filename, i->name, BP.getDirectory());
zpt.setMaxGenerateSteps(::arg().asNum("max-generate-steps"));
zpt.setMaxIncludes(::arg().asNum("max-include-depth"));
DNSResourceRecord rr;
obj["name"] = i->name.toString();
while(zpt.get(rr))
recs.push_back(emitRecord(i->name.toString(), rr.qname, rr.qtype.toString(), rr.content, rr.ttl));
obj["records"] = recs;
Json tmp = obj;
cout<<tmp.dump();
if(i+1 < domains.end()) cout<<",";
num_domainsdone++;
}
catch(std::exception &ae) {
if(!::arg().mustDo("<API key>"))
throw;
else
cerr<<endl<<ae.what()<<endl;
}
catch(PDNSException &ae) {
if(!::arg().mustDo("<API key>"))
throw;
else
cerr<<ae.reason<<endl;
}
if(!tick || !((count++)%tick))
cerr<<"\r"<<count*100/numdomains<<"% done ("<<i->filename<<")\033\133\113";
}
cout << "]" << endl;
cerr<<"\r100% done\033\133\113"<<endl;
}
else {
ZoneParserTNG zpt(zonefile, DNSName(::arg()["zone-name"]));
zpt.setMaxGenerateSteps(::arg().asNum("max-generate-steps"));
DNSResourceRecord rr;
string zname;
Json::object obj;
Json::array records;
obj["name"] = ::arg()["zone-name"];
while(zpt.get(rr))
records.push_back(emitRecord(::arg()["zone-name"], rr.qname, rr.qtype.toString(), rr.content, rr.ttl));
obj["records"] = records;
Json tmp = obj;
cout<<tmp.dump()<<endl;
num_domainsdone=1;
}
cerr<<num_domainsdone<<" domains were fully parsed, containing "<<g_numRecords<<" records\n";
return 0;
}
catch(PDNSException &ae) {
cerr<<"\nFatal error: "<<ae.reason<<endl;
return 1;
}
catch(std::exception &e) {
cerr<<"\ndied because of STL error: "<<e.what()<<endl;
return 1;
}
catch(...) {
cerr<<"\ndied because of unknown exception"<<endl;
return 1;
} |
<html>
<head>
<title>Package <API key> Element Index</title>
<link rel="stylesheet" type="text/css" href="media/style.css">
</head>
<body>
<table border="0" cellspacing="0" cellpadding="0" height="48" width="100%">
<tr>
<td class="header_top"><API key></td>
</tr>
<tr><td class="header_line"><img src="media/empty.png" width="1" height="1" border="0" alt="" /></td></tr>
<tr>
<td class="header_menu">
[ <a href="<API key>.html" class="menu">class tree: <API key></a> ]
[ <a href="<API key>.html" class="menu">index: <API key></a> ]
[ <a href="elementindex.html" class="menu">all elements</a> ]
</td>
</tr>
<tr><td class="header_line"><img src="media/empty.png" width="1" height="1" border="0" alt="" /></td></tr>
</table>
<table width="100%" border="0" cellpadding="0" cellspacing="0">
<tr valign="top">
<td width="200" class="menu">
<div id="todolist">
<p><a href="todolist.html">Todo List</a></p>
</div>
<b>Packages:</b><br />
<a href="li_PHPExcel.html">PHPExcel</a><br />
<a href="<API key>.html"><API key></a><br />
<a href="<API key>.html"><API key></a><br />
<a href="li_PHPExcel_Cell.html">PHPExcel_Cell</a><br />
<a href="li_PHPExcel_Reader.html">PHPExcel_Reader</a><br />
<a href="<API key>.html"><API key></a><br />
<a href="<API key>.html"><API key></a><br />
<a href="<API key>.html">PHPExcel_RichText</a><br />
<a href="<API key>.html">PHPExcel_Settings</a><br />
<a href="li_PHPExcel_Shared.html">PHPExcel_Shared</a><br />
<a href="<API key>.html"><API key></a><br />
<a href="li_JAMA.html">JAMA</a><br />
<a href="li_Math_Stats.html">Math_Stats</a><br />
<a href="<API key>.html">PHPExcel_Shared_OLE</a><br />
<a href="<API key>.html">com-tecnick-tcpdf</a><br />
<a href="<API key>.html"><API key></a><br />
<a href="<API key>.html"><API key></a><br />
<a href="li_PHPExcel_Style.html">PHPExcel_Style</a><br />
<a href="<API key>.html">PHPExcel_Worksheet</a><br />
<a href="<API key>.html"><API key></a><br />
<a href="li_PHPExcel_Writer.html">PHPExcel_Writer</a><br />
<a href="<API key>.html"><API key></a><br />
<a href="<API key>.html"><API key></a><br />
<br /><br />
<b>Files:</b><br />
<div class="package">
<a href="<API key>/<API key>.php.html"> Comments.php
</a><br>
<a href="<API key>/<API key>.php.html"> ContentTypes.php
</a><br>
<a href="<API key>/<API key>.php.html"> DocProps.php
</a><br>
<a href="<API key>/<API key>.php.html"> Drawing.php
</a><br>
<a href="<API key>/<API key>.php.html"> Excel2007.php
</a><br>
<a href="<API key>/<API key>.php.html"> Rels.php
</a><br>
<a href="<API key>/<API key>.php.html"> StringTable.php
</a><br>
<a href="<API key>/<API key>.php.html"> Style.php
</a><br>
<a href="<API key>/<API key>.php.html"> Theme.php
</a><br>
<a href="<API key>/<API key>.php.html"> Workbook.php
</a><br>
<a href="<API key>/<API key>.php.html"> Worksheet.php
</a><br>
<a href="<API key>/<API key>.php.html"> WriterPart.php
</a><br>
</div><br />
<b>Classes:</b><br />
<div class="package">
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
<a href="<API key>/<API key>.html"><API key></a><br />
</div>
</td>
<td>
<table cellpadding="10" cellspacing="0" width="100%" border="0"><tr><td valign="top">
<a name="top"></a>
<h1>Element index for package <API key></h1>
[ <a href="<API key>.html#a">a</a> ]
[ <a href="<API key>.html#c">c</a> ]
[ <a href="<API key>.html#d">d</a> ]
[ <a href="<API key>.html#e">e</a> ]
[ <a href="<API key>.html#f">f</a> ]
[ <a href="<API key>.html#g">g</a> ]
[ <a href="<API key>.html#p">p</a> ]
[ <a href="<API key>.html#r">r</a> ]
[ <a href="<API key>.html#s">s</a> ]
[ <a href="<API key>.html#t">t</a> ]
[ <a href="<API key>.html#w">w</a> ]
[ <a href="<API key>.html
<hr />
<a name="_"></a>
<div>
<h2>_</h2>
<dl>
<dt><b>_writeComment</b></dt>
<dd>in file Comments.php, method <a href="<API key>/<API key>.html#method_writeComment"><API key>::_writeComment()</a><br> Write comment to XML format</dd>
<dt><b>_writeDrawing</b></dt>
<dd>in file Drawing.php, method <a href="<API key>/<API key>.html#method_writeDrawing"><API key>::_writeDrawing()</a><br> Write drawings to XML format</dd>
<dt><b>_writeVMLComment</b></dt>
<dd>in file Comments.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::_writeVMLComment()</a><br> Write VML comment to XML format</dd>
<dt><b><API key></b></dt>
<dd>in file Drawing.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Write VML comment to XML format</dd>
<dt><b>__construct</b></dt>
<dd>in file WriterPart.php, method <a href="<API key>/<API key>.html#method__construct"><API key>::__construct()</a><br> Set parent IWriter object</dd>
<dt><b>__construct</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#method__construct"><API key>::__construct()</a><br> Create a new <API key></dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="a"></a>
<div>
<h2>a</h2>
<dl>
<dt><b>allBorders</b></dt>
<dd>in file Style.php, method <a href="<API key>/<API key>.html#methodallBorders"><API key>::allBorders()</a><br> Get an array of all borders</dd>
<dt><b><API key></b></dt>
<dd>in file Style.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Get an array of all conditional styles</dd>
<dt><b>allDrawings</b></dt>
<dd>in file Drawing.php, method <a href="<API key>/<API key>.html#methodallDrawings"><API key>::allDrawings()</a><br> Get an array of all drawings</dd>
<dt><b>allFills</b></dt>
<dd>in file Style.php, method <a href="<API key>/<API key>.html#methodallFills"><API key>::allFills()</a><br> Get an array of all fills</dd>
<dt><b>allFonts</b></dt>
<dd>in file Style.php, method <a href="<API key>/<API key>.html#methodallFonts"><API key>::allFonts()</a><br> Get an array of all fonts</dd>
<dt><b>allNumberFormats</b></dt>
<dd>in file Style.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::allNumberFormats()</a><br> Get an array of all number formats</dd>
<dt><b>allStyles</b></dt>
<dd>in file Style.php, method <a href="<API key>/<API key>.html#methodallStyles"><API key>::allStyles()</a><br> Get an array of all styles</dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="c"></a>
<div>
<h2>c</h2>
<dl>
<dt><b>createStringTable</b></dt>
<dd>in file StringTable.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::createStringTable()</a><br> Create worksheet stringtable</dd>
<dt><b>Comments.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">Comments.php</a></dd>
<dt><b>ContentTypes.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">ContentTypes.php</a></dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="d"></a>
<div>
<h2>d</h2>
<dl>
<dt><b>DocProps.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">DocProps.php</a></dd>
<dt><b>Drawing.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">Drawing.php</a></dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="e"></a>
<div>
<h2>e</h2>
<dl>
<dt><b>Excel2007.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">Excel2007.php</a></dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="f"></a>
<div>
<h2>f</h2>
<dl>
<dt><b>flipStringTable</b></dt>
<dd>in file StringTable.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::flipStringTable()</a><br> Flip string table (for index searching)</dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="g"></a>
<div>
<h2>g</h2>
<dl>
<dt><b>getBordersHashTable</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::getBordersHashTable()</a><br> Get <API key> HashTable</dd>
<dt><b><API key></b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Get disk caching directory</dd>
<dt><b>getDrawingHashTable</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::getDrawingHashTable()</a><br> Get <API key> HashTable</dd>
<dt><b>getFillHashTable</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::getFillHashTable()</a><br> Get PHPExcel_Style_Fill HashTable</dd>
<dt><b>getFontHashTable</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::getFontHashTable()</a><br> Get PHPExcel_Style_Font HashTable</dd>
<dt><b>getNumFmtHashTable</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::getNumFmtHashTable()</a><br> Get <API key> HashTable</dd>
<dt><b><API key></b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Get Office2003 compatibility</dd>
<dt><b>getParentWriter</b></dt>
<dd>in file WriterPart.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::getParentWriter()</a><br> Get parent IWriter object</dd>
<dt><b>getPHPExcel</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#methodgetPHPExcel"><API key>::getPHPExcel()</a><br> Get PHPExcel object</dd>
<dt><b><API key></b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Get Pre-Calculate Formulas</dd>
<dt><b>getStringTable</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::getStringTable()</a><br> Get string table</dd>
<dt><b><API key></b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Get <API key> HashTable</dd>
<dt><b>getUseDiskCaching</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::getUseDiskCaching()</a><br> Get use disk caching where possible?</dd>
<dt><b>getWriterPart</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#methodgetWriterPart"><API key>::getWriterPart()</a><br> Get writer part</dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="p"></a>
<div>
<h2>p</h2>
<dl>
<dt><b><API key></b></dt>
<dd>in file Excel2007.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file Comments.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file ContentTypes.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file DocProps.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file Drawing.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file Rels.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file StringTable.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file Style.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file Theme.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file Workbook.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file Worksheet.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
<dt><b><API key></b></dt>
<dd>in file WriterPart.php, class <a href="<API key>/<API key>.html"><API key></a><br> <API key></dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="r"></a>
<div>
<h2>r</h2>
<dl>
<dt><b>Rels.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">Rels.php</a></dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="s"></a>
<div>
<h2>s</h2>
<dl>
<dt><b>StringTable.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">StringTable.php</a></dd>
<dt><b>Style.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">Style.php</a></dd>
<dt><b>save</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#methodsave"><API key>::save()</a><br> Save PHPExcel to file</dd>
<dt><b><API key></b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Set Pre-Calculate Formulas</dd>
<dt><b>setParentWriter</b></dt>
<dd>in file WriterPart.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::setParentWriter()</a><br> Set parent IWriter object</dd>
<dt><b>setPHPExcel</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#methodsetPHPExcel"><API key>::setPHPExcel()</a><br> Set PHPExcel object</dd>
<dt><b><API key></b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Set Pre-Calculate Formulas</dd>
<dt><b>setUseDiskCaching</b></dt>
<dd>in file Excel2007.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::setUseDiskCaching()</a><br> Set use disk caching where possible?</dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="t"></a>
<div>
<h2>t</h2>
<dl>
<dt><b>Theme.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">Theme.php</a></dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<hr />
<a name="w"></a>
<div>
<h2>w</h2>
<dl>
<dt><b>Workbook.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">Workbook.php</a></dd>
<dt><b>Worksheet.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">Worksheet.php</a></dd>
<dt><b>WriterPart.php</b></dt>
<dd>procedural page <a href="<API key>/<API key>.php.html">WriterPart.php</a></dd>
<dt><b>writeComments</b></dt>
<dd>in file Comments.php, method <a href="<API key>/<API key>.html#methodwriteComments"><API key>::writeComments()</a><br> Write comments to XML format</dd>
<dt><b>writeContentTypes</b></dt>
<dd>in file ContentTypes.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::writeContentTypes()</a><br> Write content types to XML format</dd>
<dt><b>writeDocPropsApp</b></dt>
<dd>in file DocProps.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::writeDocPropsApp()</a><br> Write docProps/app.xml to XML format</dd>
<dt><b>writeDocPropsCore</b></dt>
<dd>in file DocProps.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::writeDocPropsCore()</a><br> Write docProps/core.xml to XML format</dd>
<dt><b>writeDocPropsCustom</b></dt>
<dd>in file DocProps.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::writeDocPropsCustom()</a><br> Write docProps/custom.xml to XML format</dd>
<dt><b><API key></b></dt>
<dd>in file Rels.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Write drawing relationships to XML format</dd>
<dt><b>writeDrawings</b></dt>
<dd>in file Drawing.php, method <a href="<API key>/<API key>.html#methodwriteDrawings"><API key>::writeDrawings()</a><br> Write drawings to XML format</dd>
<dt><b><API key></b></dt>
<dd>in file Rels.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Write header/footer drawing relationships to XML format</dd>
<dt><b>writeRelationships</b></dt>
<dd>in file Rels.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::writeRelationships()</a><br> Write relationships to XML format</dd>
<dt><b>writeRichText</b></dt>
<dd>in file StringTable.php, method <a href="<API key>/<API key>.html#methodwriteRichText"><API key>::writeRichText()</a><br> Write Rich Text</dd>
<dt><b>writeStringTable</b></dt>
<dd>in file StringTable.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::writeStringTable()</a><br> Write string table to XML format</dd>
<dt><b>writeStyles</b></dt>
<dd>in file Style.php, method <a href="<API key>/<API key>.html#methodwriteStyles"><API key>::writeStyles()</a><br> Write styles to XML format</dd>
<dt><b>writeTheme</b></dt>
<dd>in file Theme.php, method <a href="<API key>/<API key>.html#methodwriteTheme"><API key>::writeTheme()</a><br> Write theme to XML format</dd>
<dt><b>writeVMLComments</b></dt>
<dd>in file Comments.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::writeVMLComments()</a><br> Write VML comments to XML format</dd>
<dt><b><API key></b></dt>
<dd>in file Drawing.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Write VML header/footer images to XML format</dd>
<dt><b>writeWorkbook</b></dt>
<dd>in file Workbook.php, method <a href="<API key>/<API key>.html#methodwriteWorkbook"><API key>::writeWorkbook()</a><br> Write workbook to XML format</dd>
<dt><b><API key></b></dt>
<dd>in file Rels.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Write workbook relationships to XML format</dd>
<dt><b>writeWorksheet</b></dt>
<dd>in file Worksheet.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::writeWorksheet()</a><br> Write worksheet to XML format</dd>
<dt><b><API key></b></dt>
<dd>in file Rels.php, method <a href="<API key>/<API key>.html#<API key>"><API key>::<API key>()</a><br> Write worksheet relationships to XML format</dd>
</dl>
</div>
<a href="<API key>.html#top">top</a><br>
<div class="credit">
<hr />
Documentation generated on Sun, 27 Feb 2011 16:26:38 -0800 by <a href="http:
</div>
</td></tr></table>
</td>
</tr>
</table>
</body>
</html> |
/* This file is machine generated. Do not edit. */
/* Allocators for known structs and unions. */
#define <API key>() ((vec<ivarref_entry,va_gc> *)(<API key> (sizeof (vec<ivarref_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<ivarref_entry,va_gc> *)(<API key> (sizeof (vec<ivarref_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<ivarref_entry,va_gc> *)(<API key> (sizeof (vec<ivarref_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<ivarref_entry,va_gc> *)(<API key> (sizeof (vec<ivarref_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct ivarref_entry *)(<API key> (sizeof (struct ivarref_entry) MEM_STAT_INFO)))
#define <API key>() ((struct ivarref_entry *)(<API key> (sizeof (struct ivarref_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct ivarref_entry *)(<API key> (sizeof (struct ivarref_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ivarref_entry *)(<API key> (sizeof (struct ivarref_entry), n MEM_STAT_INFO)))
#define <API key>() ((vec<prot_list_entry,va_gc> *)(<API key> (sizeof (vec<prot_list_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<prot_list_entry,va_gc> *)(<API key> (sizeof (vec<prot_list_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<prot_list_entry,va_gc> *)(<API key> (sizeof (vec<prot_list_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<prot_list_entry,va_gc> *)(<API key> (sizeof (vec<prot_list_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct prot_list_entry *)(<API key> (sizeof (struct prot_list_entry) MEM_STAT_INFO)))
#define <API key>() ((struct prot_list_entry *)(<API key> (sizeof (struct prot_list_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct prot_list_entry *)(<API key> (sizeof (struct prot_list_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct prot_list_entry *)(<API key> (sizeof (struct prot_list_entry), n MEM_STAT_INFO)))
#define <API key>() ((vec<msgref_entry,va_gc> *)(<API key> (sizeof (vec<msgref_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<msgref_entry,va_gc> *)(<API key> (sizeof (vec<msgref_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<msgref_entry,va_gc> *)(<API key> (sizeof (vec<msgref_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<msgref_entry,va_gc> *)(<API key> (sizeof (vec<msgref_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct msgref_entry *)(<API key> (sizeof (struct msgref_entry) MEM_STAT_INFO)))
#define <API key>() ((struct msgref_entry *)(<API key> (sizeof (struct msgref_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct msgref_entry *)(<API key> (sizeof (struct msgref_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct msgref_entry *)(<API key> (sizeof (struct msgref_entry), n MEM_STAT_INFO)))
#define <API key>() ((vec<ident_data_tuple,va_gc> *)(<API key> (sizeof (vec<ident_data_tuple,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<ident_data_tuple,va_gc> *)(<API key> (sizeof (vec<ident_data_tuple,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<ident_data_tuple,va_gc> *)(<API key> (sizeof (vec<ident_data_tuple,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<ident_data_tuple,va_gc> *)(<API key> (sizeof (vec<ident_data_tuple,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct ident_data_tuple *)(<API key> (sizeof (struct ident_data_tuple) MEM_STAT_INFO)))
#define <API key>() ((struct ident_data_tuple *)(<API key> (sizeof (struct ident_data_tuple) MEM_STAT_INFO)))
#define <API key>(n) ((struct ident_data_tuple *)(<API key> (sizeof (struct ident_data_tuple), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ident_data_tuple *)(<API key> (sizeof (struct ident_data_tuple), n MEM_STAT_INFO)))
#define <API key>() ((struct string_descriptor *)(<API key> (sizeof (struct string_descriptor) MEM_STAT_INFO)))
#define <API key>() ((struct string_descriptor *)(<API key> (sizeof (struct string_descriptor) MEM_STAT_INFO)))
#define <API key>(n) ((struct string_descriptor *)(<API key> (sizeof (struct string_descriptor), n MEM_STAT_INFO)))
#define <API key>(n) ((struct string_descriptor *)(<API key> (sizeof (struct string_descriptor), n MEM_STAT_INFO)))
#define ggc_alloc_imp_entry() ((struct imp_entry *)(<API key> (sizeof (struct imp_entry) MEM_STAT_INFO)))
#define <API key>() ((struct imp_entry *)(<API key> (sizeof (struct imp_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct imp_entry *)(<API key> (sizeof (struct imp_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct imp_entry *)(<API key> (sizeof (struct imp_entry), n MEM_STAT_INFO)))
#define <API key>() ((struct hashed_attribute *)(<API key> (sizeof (struct hashed_attribute) MEM_STAT_INFO)))
#define <API key>() ((struct hashed_attribute *)(<API key> (sizeof (struct hashed_attribute) MEM_STAT_INFO)))
#define <API key>(n) ((struct hashed_attribute *)(<API key> (sizeof (struct hashed_attribute), n MEM_STAT_INFO)))
#define <API key>(n) ((struct hashed_attribute *)(<API key> (sizeof (struct hashed_attribute), n MEM_STAT_INFO)))
#define <API key>() ((struct hashed_entry *)(<API key> (sizeof (struct hashed_entry) MEM_STAT_INFO)))
#define <API key>() ((struct hashed_entry *)(<API key> (sizeof (struct hashed_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct hashed_entry *)(<API key> (sizeof (struct hashed_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct hashed_entry *)(<API key> (sizeof (struct hashed_entry), n MEM_STAT_INFO)))
#define <API key>() ((struct objc_map_private *)(<API key> (sizeof (struct objc_map_private) MEM_STAT_INFO)))
#define <API key>() ((struct objc_map_private *)(<API key> (sizeof (struct objc_map_private) MEM_STAT_INFO)))
#define <API key>(n) ((struct objc_map_private *)(<API key> (sizeof (struct objc_map_private), n MEM_STAT_INFO)))
#define <API key>(n) ((struct objc_map_private *)(<API key> (sizeof (struct objc_map_private), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct builtin_record *)(<API key> (sizeof (struct builtin_record) MEM_STAT_INFO)))
#define <API key>() ((struct builtin_record *)(<API key> (sizeof (struct builtin_record) MEM_STAT_INFO)))
#define <API key>(n) ((struct builtin_record *)(<API key> (sizeof (struct builtin_record), n MEM_STAT_INFO)))
#define <API key>(n) ((struct builtin_record *)(<API key> (sizeof (struct builtin_record), n MEM_STAT_INFO)))
#define <API key>() ((union string_or_tree *)(<API key> (sizeof (union string_or_tree) MEM_STAT_INFO)))
#define <API key>() ((union string_or_tree *)(<API key> (sizeof (union string_or_tree) MEM_STAT_INFO)))
#define <API key>(n) ((union string_or_tree *)(<API key> (sizeof (union string_or_tree), n MEM_STAT_INFO)))
#define <API key>(n) ((union string_or_tree *)(<API key> (sizeof (union string_or_tree), n MEM_STAT_INFO)))
#define <API key>() ((struct BootstrapMethods *)(<API key> (sizeof (struct BootstrapMethods) MEM_STAT_INFO)))
#define <API key>() ((struct BootstrapMethods *)(<API key> (sizeof (struct BootstrapMethods) MEM_STAT_INFO)))
#define <API key>(n) ((struct BootstrapMethods *)(<API key> (sizeof (struct BootstrapMethods), n MEM_STAT_INFO)))
#define <API key>(n) ((struct BootstrapMethods *)(<API key> (sizeof (struct BootstrapMethods), n MEM_STAT_INFO)))
#define <API key>() ((struct bootstrap_method *)(<API key> (sizeof (struct bootstrap_method) MEM_STAT_INFO)))
#define <API key>() ((struct bootstrap_method *)(<API key> (sizeof (struct bootstrap_method) MEM_STAT_INFO)))
#define <API key>(n) ((struct bootstrap_method *)(<API key> (sizeof (struct bootstrap_method), n MEM_STAT_INFO)))
#define <API key>(n) ((struct bootstrap_method *)(<API key> (sizeof (struct bootstrap_method), n MEM_STAT_INFO)))
#define <API key>(SIZE) ((union cpool_entry *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE) ((union cpool_entry *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((union cpool_entry *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((union cpool_entry *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>() ((vec<method_entry,va_gc> *)(<API key> (sizeof (vec<method_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<method_entry,va_gc> *)(<API key> (sizeof (vec<method_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<method_entry,va_gc> *)(<API key> (sizeof (vec<method_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<method_entry,va_gc> *)(<API key> (sizeof (vec<method_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct method_entry_d *)(<API key> (sizeof (struct method_entry_d) MEM_STAT_INFO)))
#define <API key>() ((struct method_entry_d *)(<API key> (sizeof (struct method_entry_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct method_entry_d *)(<API key> (sizeof (struct method_entry_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct method_entry_d *)(<API key> (sizeof (struct method_entry_d), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_var *)(<API key> (sizeof (struct lang_decl_var) MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_var *)(<API key> (sizeof (struct lang_decl_var) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_var *)(<API key> (sizeof (struct lang_decl_var), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_var *)(<API key> (sizeof (struct lang_decl_var), n MEM_STAT_INFO)))
#define <API key>() ((struct type_assertion *)(<API key> (sizeof (struct type_assertion) MEM_STAT_INFO)))
#define <API key>() ((struct type_assertion *)(<API key> (sizeof (struct type_assertion) MEM_STAT_INFO)))
#define <API key>(n) ((struct type_assertion *)(<API key> (sizeof (struct type_assertion), n MEM_STAT_INFO)))
#define <API key>(n) ((struct type_assertion *)(<API key> (sizeof (struct type_assertion), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_func *)(<API key> (sizeof (struct lang_decl_func) MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_func *)(<API key> (sizeof (struct lang_decl_func) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_func *)(<API key> (sizeof (struct lang_decl_func), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_func *)(<API key> (sizeof (struct lang_decl_func), n MEM_STAT_INFO)))
#define <API key>() ((struct treetreehash_entry *)(<API key> (sizeof (struct treetreehash_entry) MEM_STAT_INFO)))
#define <API key>() ((struct treetreehash_entry *)(<API key> (sizeof (struct treetreehash_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct treetreehash_entry *)(<API key> (sizeof (struct treetreehash_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct treetreehash_entry *)(<API key> (sizeof (struct treetreehash_entry), n MEM_STAT_INFO)))
#define ggc_alloc_CPool() ((struct CPool *)(<API key> (sizeof (struct CPool) MEM_STAT_INFO)))
#define <API key>() ((struct CPool *)(<API key> (sizeof (struct CPool) MEM_STAT_INFO)))
#define ggc_alloc_vec_CPool(n) ((struct CPool *)(<API key> (sizeof (struct CPool), n MEM_STAT_INFO)))
#define <API key>(n) ((struct CPool *)(<API key> (sizeof (struct CPool), n MEM_STAT_INFO)))
#define ggc_alloc_JCF() ((struct JCF *)(<API key> (sizeof (struct JCF) MEM_STAT_INFO)))
#define <API key>() ((struct JCF *)(<API key> (sizeof (struct JCF) MEM_STAT_INFO)))
#define ggc_alloc_vec_JCF(n) ((struct JCF *)(<API key> (sizeof (struct JCF), n MEM_STAT_INFO)))
#define <API key>(n) ((struct JCF *)(<API key> (sizeof (struct JCF), n MEM_STAT_INFO)))
#define <API key>() ((struct gfc_powdecl_list *)(<API key> (sizeof (struct gfc_powdecl_list) MEM_STAT_INFO)))
#define <API key>() ((struct gfc_powdecl_list *)(<API key> (sizeof (struct gfc_powdecl_list) MEM_STAT_INFO)))
#define <API key>(n) ((struct gfc_powdecl_list *)(<API key> (sizeof (struct gfc_powdecl_list), n MEM_STAT_INFO)))
#define <API key>(n) ((struct gfc_powdecl_list *)(<API key> (sizeof (struct gfc_powdecl_list), n MEM_STAT_INFO)))
#define <API key>() ((struct gfc_st_parameter *)(<API key> (sizeof (struct gfc_st_parameter) MEM_STAT_INFO)))
#define <API key>() ((struct gfc_st_parameter *)(<API key> (sizeof (struct gfc_st_parameter) MEM_STAT_INFO)))
#define <API key>(n) ((struct gfc_st_parameter *)(<API key> (sizeof (struct gfc_st_parameter), n MEM_STAT_INFO)))
#define <API key>(n) ((struct gfc_st_parameter *)(<API key> (sizeof (struct gfc_st_parameter), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct gfc_intrinsic_map_t *)(<API key> (sizeof (struct gfc_intrinsic_map_t) MEM_STAT_INFO)))
#define <API key>() ((struct gfc_intrinsic_map_t *)(<API key> (sizeof (struct gfc_intrinsic_map_t) MEM_STAT_INFO)))
#define <API key>(n) ((struct gfc_intrinsic_map_t *)(<API key> (sizeof (struct gfc_intrinsic_map_t), n MEM_STAT_INFO)))
#define <API key>(n) ((struct gfc_intrinsic_map_t *)(<API key> (sizeof (struct gfc_intrinsic_map_t), n MEM_STAT_INFO)))
#define <API key>() ((struct module_htab_entry *)(<API key> (sizeof (struct module_htab_entry) MEM_STAT_INFO)))
#define <API key>() ((struct module_htab_entry *)(<API key> (sizeof (struct module_htab_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct module_htab_entry *)(<API key> (sizeof (struct module_htab_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct module_htab_entry *)(<API key> (sizeof (struct module_htab_entry), n MEM_STAT_INFO)))
#define <API key>() ((struct binding_level *)(<API key> (sizeof (struct binding_level) MEM_STAT_INFO)))
#define <API key>() ((struct binding_level *)(<API key> (sizeof (struct binding_level) MEM_STAT_INFO)))
#define <API key>(n) ((struct binding_level *)(<API key> (sizeof (struct binding_level), n MEM_STAT_INFO)))
#define <API key>(n) ((struct binding_level *)(<API key> (sizeof (struct binding_level), n MEM_STAT_INFO)))
#define <API key>() ((vec<pending_noexcept,va_gc> *)(<API key> (sizeof (vec<pending_noexcept,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<pending_noexcept,va_gc> *)(<API key> (sizeof (vec<pending_noexcept,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<pending_noexcept,va_gc> *)(<API key> (sizeof (vec<pending_noexcept,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<pending_noexcept,va_gc> *)(<API key> (sizeof (vec<pending_noexcept,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct pending_noexcept *)(<API key> (sizeof (struct pending_noexcept) MEM_STAT_INFO)))
#define <API key>() ((struct pending_noexcept *)(<API key> (sizeof (struct pending_noexcept) MEM_STAT_INFO)))
#define <API key>(n) ((struct pending_noexcept *)(<API key> (sizeof (struct pending_noexcept), n MEM_STAT_INFO)))
#define <API key>(n) ((struct pending_noexcept *)(<API key> (sizeof (struct pending_noexcept), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((vec<tree_int,va_gc> *)(<API key> (sizeof (vec<tree_int,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<tree_int,va_gc> *)(<API key> (sizeof (vec<tree_int,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<tree_int,va_gc> *)(<API key> (sizeof (vec<tree_int,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<tree_int,va_gc> *)(<API key> (sizeof (vec<tree_int,va_gc>), n MEM_STAT_INFO)))
#define ggc_alloc_tree_int() ((struct tree_int *)(<API key> (sizeof (struct tree_int) MEM_STAT_INFO)))
#define <API key>() ((struct tree_int *)(<API key> (sizeof (struct tree_int) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_int *)(<API key> (sizeof (struct tree_int), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_int *)(<API key> (sizeof (struct tree_int), n MEM_STAT_INFO)))
#define ggc_alloc_cp_parser() ((struct cp_parser *)(<API key> (sizeof (struct cp_parser) MEM_STAT_INFO)))
#define <API key>() ((struct cp_parser *)(<API key> (sizeof (struct cp_parser) MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_parser *)(<API key> (sizeof (struct cp_parser), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_parser *)(<API key> (sizeof (struct cp_parser), n MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct cp_parser_context *)(<API key> (sizeof (struct cp_parser_context) MEM_STAT_INFO)))
#define <API key>() ((struct cp_parser_context *)(<API key> (sizeof (struct cp_parser_context) MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_parser_context *)(<API key> (sizeof (struct cp_parser_context), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_parser_context *)(<API key> (sizeof (struct cp_parser_context), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define ggc_alloc_cp_lexer() ((struct cp_lexer *)(<API key> (sizeof (struct cp_lexer) MEM_STAT_INFO)))
#define <API key>() ((struct cp_lexer *)(<API key> (sizeof (struct cp_lexer) MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_lexer *)(<API key> (sizeof (struct cp_lexer), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_lexer *)(<API key> (sizeof (struct cp_lexer), n MEM_STAT_INFO)))
#define <API key>() ((vec<cp_token,va_gc> *)(<API key> (sizeof (vec<cp_token,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<cp_token,va_gc> *)(<API key> (sizeof (vec<cp_token,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<cp_token,va_gc> *)(<API key> (sizeof (vec<cp_token,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<cp_token,va_gc> *)(<API key> (sizeof (vec<cp_token,va_gc>), n MEM_STAT_INFO)))
#define ggc_alloc_cp_token() ((struct cp_token *)(<API key> (sizeof (struct cp_token) MEM_STAT_INFO)))
#define <API key>() ((struct cp_token *)(<API key> (sizeof (struct cp_token) MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_token *)(<API key> (sizeof (struct cp_token), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_token *)(<API key> (sizeof (struct cp_token), n MEM_STAT_INFO)))
#define <API key>() ((union cp_token_value *)(<API key> (sizeof (union cp_token_value) MEM_STAT_INFO)))
#define <API key>() ((union cp_token_value *)(<API key> (sizeof (union cp_token_value) MEM_STAT_INFO)))
#define <API key>(n) ((union cp_token_value *)(<API key> (sizeof (union cp_token_value), n MEM_STAT_INFO)))
#define <API key>(n) ((union cp_token_value *)(<API key> (sizeof (union cp_token_value), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_check *)(<API key> (sizeof (struct tree_check) MEM_STAT_INFO)))
#define <API key>() ((struct tree_check *)(<API key> (sizeof (struct tree_check) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_check *)(<API key> (sizeof (struct tree_check), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_check *)(<API key> (sizeof (struct tree_check), n MEM_STAT_INFO)))
#define <API key>() ((struct constexpr_call *)(<API key> (sizeof (struct constexpr_call) MEM_STAT_INFO)))
#define <API key>() ((struct constexpr_call *)(<API key> (sizeof (struct constexpr_call) MEM_STAT_INFO)))
#define <API key>(n) ((struct constexpr_call *)(<API key> (sizeof (struct constexpr_call), n MEM_STAT_INFO)))
#define <API key>(n) ((struct constexpr_call *)(<API key> (sizeof (struct constexpr_call), n MEM_STAT_INFO)))
#define <API key>() ((struct constexpr_fundef *)(<API key> (sizeof (struct constexpr_fundef) MEM_STAT_INFO)))
#define <API key>() ((struct constexpr_fundef *)(<API key> (sizeof (struct constexpr_fundef) MEM_STAT_INFO)))
#define <API key>(n) ((struct constexpr_fundef *)(<API key> (sizeof (struct constexpr_fundef), n MEM_STAT_INFO)))
#define <API key>(n) ((struct constexpr_fundef *)(<API key> (sizeof (struct constexpr_fundef), n MEM_STAT_INFO)))
#define <API key>() ((vec<deferred_access,va_gc> *)(<API key> (sizeof (vec<deferred_access,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<deferred_access,va_gc> *)(<API key> (sizeof (vec<deferred_access,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<deferred_access,va_gc> *)(<API key> (sizeof (vec<deferred_access,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<deferred_access,va_gc> *)(<API key> (sizeof (vec<deferred_access,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct deferred_access *)(<API key> (sizeof (struct deferred_access) MEM_STAT_INFO)))
#define <API key>() ((struct deferred_access *)(<API key> (sizeof (struct deferred_access) MEM_STAT_INFO)))
#define <API key>(n) ((struct deferred_access *)(<API key> (sizeof (struct deferred_access), n MEM_STAT_INFO)))
#define <API key>(n) ((struct deferred_access *)(<API key> (sizeof (struct deferred_access), n MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct spec_entry *)(<API key> (sizeof (struct spec_entry) MEM_STAT_INFO)))
#define <API key>() ((struct spec_entry *)(<API key> (sizeof (struct spec_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct spec_entry *)(<API key> (sizeof (struct spec_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct spec_entry *)(<API key> (sizeof (struct spec_entry), n MEM_STAT_INFO)))
#define <API key>() ((struct pending_template *)(<API key> (sizeof (struct pending_template) MEM_STAT_INFO)))
#define <API key>() ((struct pending_template *)(<API key> (sizeof (struct pending_template) MEM_STAT_INFO)))
#define <API key>(n) ((struct pending_template *)(<API key> (sizeof (struct pending_template), n MEM_STAT_INFO)))
#define <API key>(n) ((struct pending_template *)(<API key> (sizeof (struct pending_template), n MEM_STAT_INFO)))
#define <API key>() ((vec<incomplete_var,va_gc> *)(<API key> (sizeof (vec<incomplete_var,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<incomplete_var,va_gc> *)(<API key> (sizeof (vec<incomplete_var,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<incomplete_var,va_gc> *)(<API key> (sizeof (vec<incomplete_var,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<incomplete_var,va_gc> *)(<API key> (sizeof (vec<incomplete_var,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct incomplete_var_d *)(<API key> (sizeof (struct incomplete_var_d) MEM_STAT_INFO)))
#define <API key>() ((struct incomplete_var_d *)(<API key> (sizeof (struct incomplete_var_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct incomplete_var_d *)(<API key> (sizeof (struct incomplete_var_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct incomplete_var_d *)(<API key> (sizeof (struct incomplete_var_d), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((union lang_decl_u *)(<API key> (sizeof (union lang_decl_u) MEM_STAT_INFO)))
#define <API key>() ((union lang_decl_u *)(<API key> (sizeof (union lang_decl_u) MEM_STAT_INFO)))
#define <API key>(n) ((union lang_decl_u *)(<API key> (sizeof (union lang_decl_u), n MEM_STAT_INFO)))
#define <API key>(n) ((union lang_decl_u *)(<API key> (sizeof (union lang_decl_u), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_parm *)(<API key> (sizeof (struct lang_decl_parm) MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_parm *)(<API key> (sizeof (struct lang_decl_parm) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_parm *)(<API key> (sizeof (struct lang_decl_parm), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_parm *)(<API key> (sizeof (struct lang_decl_parm), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_ns *)(<API key> (sizeof (struct lang_decl_ns) MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_ns *)(<API key> (sizeof (struct lang_decl_ns) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_ns *)(<API key> (sizeof (struct lang_decl_ns), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_ns *)(<API key> (sizeof (struct lang_decl_ns), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_fn *)(<API key> (sizeof (struct lang_decl_fn) MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_fn *)(<API key> (sizeof (struct lang_decl_fn) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_fn *)(<API key> (sizeof (struct lang_decl_fn), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_fn *)(<API key> (sizeof (struct lang_decl_fn), n MEM_STAT_INFO)))
#define <API key>() ((union lang_decl_u3 *)(<API key> (sizeof (union lang_decl_u3) MEM_STAT_INFO)))
#define <API key>() ((union lang_decl_u3 *)(<API key> (sizeof (union lang_decl_u3) MEM_STAT_INFO)))
#define <API key>(n) ((union lang_decl_u3 *)(<API key> (sizeof (union lang_decl_u3), n MEM_STAT_INFO)))
#define <API key>(n) ((union lang_decl_u3 *)(<API key> (sizeof (union lang_decl_u3), n MEM_STAT_INFO)))
#define <API key>() ((union lang_decl_u5 *)(<API key> (sizeof (union lang_decl_u5) MEM_STAT_INFO)))
#define <API key>() ((union lang_decl_u5 *)(<API key> (sizeof (union lang_decl_u5) MEM_STAT_INFO)))
#define <API key>(n) ((union lang_decl_u5 *)(<API key> (sizeof (union lang_decl_u5), n MEM_STAT_INFO)))
#define <API key>(n) ((union lang_decl_u5 *)(<API key> (sizeof (union lang_decl_u5), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_min *)(<API key> (sizeof (struct lang_decl_min) MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_min *)(<API key> (sizeof (struct lang_decl_min) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_min *)(<API key> (sizeof (struct lang_decl_min), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_min *)(<API key> (sizeof (struct lang_decl_min), n MEM_STAT_INFO)))
#define <API key>() ((union lang_decl_u2 *)(<API key> (sizeof (union lang_decl_u2) MEM_STAT_INFO)))
#define <API key>() ((union lang_decl_u2 *)(<API key> (sizeof (union lang_decl_u2) MEM_STAT_INFO)))
#define <API key>(n) ((union lang_decl_u2 *)(<API key> (sizeof (union lang_decl_u2), n MEM_STAT_INFO)))
#define <API key>(n) ((union lang_decl_u2 *)(<API key> (sizeof (union lang_decl_u2), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_base *)(<API key> (sizeof (struct lang_decl_base) MEM_STAT_INFO)))
#define <API key>() ((struct lang_decl_base *)(<API key> (sizeof (struct lang_decl_base) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_base *)(<API key> (sizeof (struct lang_decl_base), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_decl_base *)(<API key> (sizeof (struct lang_decl_base), n MEM_STAT_INFO)))
#define <API key>() ((union lang_type_u *)(<API key> (sizeof (union lang_type_u) MEM_STAT_INFO)))
#define <API key>() ((union lang_type_u *)(<API key> (sizeof (union lang_type_u) MEM_STAT_INFO)))
#define <API key>(n) ((union lang_type_u *)(<API key> (sizeof (union lang_type_u), n MEM_STAT_INFO)))
#define <API key>(n) ((union lang_type_u *)(<API key> (sizeof (union lang_type_u), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_type_ptrmem *)(<API key> (sizeof (struct lang_type_ptrmem) MEM_STAT_INFO)))
#define <API key>() ((struct lang_type_ptrmem *)(<API key> (sizeof (struct lang_type_ptrmem) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_type_ptrmem *)(<API key> (sizeof (struct lang_type_ptrmem), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_type_ptrmem *)(<API key> (sizeof (struct lang_type_ptrmem), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_type_class *)(<API key> (sizeof (struct lang_type_class) MEM_STAT_INFO)))
#define <API key>() ((struct lang_type_class *)(<API key> (sizeof (struct lang_type_class) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_type_class *)(<API key> (sizeof (struct lang_type_class), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_type_class *)(<API key> (sizeof (struct lang_type_class), n MEM_STAT_INFO)))
#define <API key>() ((vec<tree_pair_s,va_gc> *)(<API key> (sizeof (vec<tree_pair_s,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<tree_pair_s,va_gc> *)(<API key> (sizeof (vec<tree_pair_s,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<tree_pair_s,va_gc> *)(<API key> (sizeof (vec<tree_pair_s,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<tree_pair_s,va_gc> *)(<API key> (sizeof (vec<tree_pair_s,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_type_header *)(<API key> (sizeof (struct lang_type_header) MEM_STAT_INFO)))
#define <API key>() ((struct lang_type_header *)(<API key> (sizeof (struct lang_type_header) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_type_header *)(<API key> (sizeof (struct lang_type_header), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_type_header *)(<API key> (sizeof (struct lang_type_header), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_pair_s *)(<API key> (sizeof (struct tree_pair_s) MEM_STAT_INFO)))
#define <API key>() ((struct tree_pair_s *)(<API key> (sizeof (struct tree_pair_s) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_pair_s *)(<API key> (sizeof (struct tree_pair_s), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_pair_s *)(<API key> (sizeof (struct tree_pair_s), n MEM_STAT_INFO)))
#define <API key>() ((struct named_label_entry *)(<API key> (sizeof (struct named_label_entry) MEM_STAT_INFO)))
#define <API key>() ((struct named_label_entry *)(<API key> (sizeof (struct named_label_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct named_label_entry *)(<API key> (sizeof (struct named_label_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct named_label_entry *)(<API key> (sizeof (struct named_label_entry), n MEM_STAT_INFO)))
#define <API key>() ((vec<cxx_saved_binding,va_gc> *)(<API key> (sizeof (vec<cxx_saved_binding,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<cxx_saved_binding,va_gc> *)(<API key> (sizeof (vec<cxx_saved_binding,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<cxx_saved_binding,va_gc> *)(<API key> (sizeof (vec<cxx_saved_binding,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<cxx_saved_binding,va_gc> *)(<API key> (sizeof (vec<cxx_saved_binding,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_template_info *)(<API key> (sizeof (struct tree_template_info) MEM_STAT_INFO)))
#define <API key>() ((struct tree_template_info *)(<API key> (sizeof (struct tree_template_info) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_template_info *)(<API key> (sizeof (struct tree_template_info), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_template_info *)(<API key> (sizeof (struct tree_template_info), n MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_lambda_expr *)(<API key> (sizeof (struct tree_lambda_expr) MEM_STAT_INFO)))
#define <API key>() ((struct tree_lambda_expr *)(<API key> (sizeof (struct tree_lambda_expr) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_lambda_expr *)(<API key> (sizeof (struct tree_lambda_expr), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_lambda_expr *)(<API key> (sizeof (struct tree_lambda_expr), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_trait_expr *)(<API key> (sizeof (struct tree_trait_expr) MEM_STAT_INFO)))
#define <API key>() ((struct tree_trait_expr *)(<API key> (sizeof (struct tree_trait_expr) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_trait_expr *)(<API key> (sizeof (struct tree_trait_expr), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_trait_expr *)(<API key> (sizeof (struct tree_trait_expr), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_static_assert *)(<API key> (sizeof (struct tree_static_assert) MEM_STAT_INFO)))
#define <API key>() ((struct tree_static_assert *)(<API key> (sizeof (struct tree_static_assert) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_static_assert *)(<API key> (sizeof (struct tree_static_assert), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_static_assert *)(<API key> (sizeof (struct tree_static_assert), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_default_arg *)(<API key> (sizeof (struct tree_default_arg) MEM_STAT_INFO)))
#define <API key>() ((struct tree_default_arg *)(<API key> (sizeof (struct tree_default_arg) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_default_arg *)(<API key> (sizeof (struct tree_default_arg), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_default_arg *)(<API key> (sizeof (struct tree_default_arg), n MEM_STAT_INFO)))
#define <API key>() ((struct cp_token_cache *)(<API key> (sizeof (struct cp_token_cache) MEM_STAT_INFO)))
#define <API key>() ((struct cp_token_cache *)(<API key> (sizeof (struct cp_token_cache) MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_token_cache *)(<API key> (sizeof (struct cp_token_cache), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_token_cache *)(<API key> (sizeof (struct cp_token_cache), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_baselink *)(<API key> (sizeof (struct tree_baselink) MEM_STAT_INFO)))
#define <API key>() ((struct tree_baselink *)(<API key> (sizeof (struct tree_baselink) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_baselink *)(<API key> (sizeof (struct tree_baselink), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_baselink *)(<API key> (sizeof (struct tree_baselink), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_overload *)(<API key> (sizeof (struct tree_overload) MEM_STAT_INFO)))
#define <API key>() ((struct tree_overload *)(<API key> (sizeof (struct tree_overload) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_overload *)(<API key> (sizeof (struct tree_overload), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_overload *)(<API key> (sizeof (struct tree_overload), n MEM_STAT_INFO)))
#define <API key>() ((struct ptrmem_cst *)(<API key> (sizeof (struct ptrmem_cst) MEM_STAT_INFO)))
#define <API key>() ((struct ptrmem_cst *)(<API key> (sizeof (struct ptrmem_cst) MEM_STAT_INFO)))
#define <API key>(n) ((struct ptrmem_cst *)(<API key> (sizeof (struct ptrmem_cst), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ptrmem_cst *)(<API key> (sizeof (struct ptrmem_cst), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct saved_scope *)(<API key> (sizeof (struct saved_scope) MEM_STAT_INFO)))
#define <API key>() ((struct saved_scope *)(<API key> (sizeof (struct saved_scope) MEM_STAT_INFO)))
#define <API key>(n) ((struct saved_scope *)(<API key> (sizeof (struct saved_scope), n MEM_STAT_INFO)))
#define <API key>(n) ((struct saved_scope *)(<API key> (sizeof (struct saved_scope), n MEM_STAT_INFO)))
#define <API key>() ((struct cxx_int_tree_map *)(<API key> (sizeof (struct cxx_int_tree_map) MEM_STAT_INFO)))
#define <API key>() ((struct cxx_int_tree_map *)(<API key> (sizeof (struct cxx_int_tree_map) MEM_STAT_INFO)))
#define <API key>(n) ((struct cxx_int_tree_map *)(<API key> (sizeof (struct cxx_int_tree_map), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cxx_int_tree_map *)(<API key> (sizeof (struct cxx_int_tree_map), n MEM_STAT_INFO)))
#define <API key>() ((vec<cp_label_binding,va_gc> *)(<API key> (sizeof (vec<cp_label_binding,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<cp_label_binding,va_gc> *)(<API key> (sizeof (vec<cp_label_binding,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<cp_label_binding,va_gc> *)(<API key> (sizeof (vec<cp_label_binding,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<cp_label_binding,va_gc> *)(<API key> (sizeof (vec<cp_label_binding,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((vec<cp_class_binding,va_gc> *)(<API key> (sizeof (vec<cp_class_binding,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<cp_class_binding,va_gc> *)(<API key> (sizeof (vec<cp_class_binding,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<cp_class_binding,va_gc> *)(<API key> (sizeof (vec<cp_class_binding,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<cp_class_binding,va_gc> *)(<API key> (sizeof (vec<cp_class_binding,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct cp_label_binding *)(<API key> (sizeof (struct cp_label_binding) MEM_STAT_INFO)))
#define <API key>() ((struct cp_label_binding *)(<API key> (sizeof (struct cp_label_binding) MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_label_binding *)(<API key> (sizeof (struct cp_label_binding), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_label_binding *)(<API key> (sizeof (struct cp_label_binding), n MEM_STAT_INFO)))
#define <API key>() ((struct cp_class_binding *)(<API key> (sizeof (struct cp_class_binding) MEM_STAT_INFO)))
#define <API key>() ((struct cp_class_binding *)(<API key> (sizeof (struct cp_class_binding) MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_class_binding *)(<API key> (sizeof (struct cp_class_binding), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_class_binding *)(<API key> (sizeof (struct cp_class_binding), n MEM_STAT_INFO)))
#define <API key>() ((struct cxx_saved_binding *)(<API key> (sizeof (struct cxx_saved_binding) MEM_STAT_INFO)))
#define <API key>() ((struct cxx_saved_binding *)(<API key> (sizeof (struct cxx_saved_binding) MEM_STAT_INFO)))
#define <API key>(n) ((struct cxx_saved_binding *)(<API key> (sizeof (struct cxx_saved_binding), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cxx_saved_binding *)(<API key> (sizeof (struct cxx_saved_binding), n MEM_STAT_INFO)))
#define <API key>() ((struct cp_binding_level *)(<API key> (sizeof (struct cp_binding_level) MEM_STAT_INFO)))
#define <API key>() ((struct cp_binding_level *)(<API key> (sizeof (struct cp_binding_level) MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_binding_level *)(<API key> (sizeof (struct cp_binding_level), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cp_binding_level *)(<API key> (sizeof (struct cp_binding_level), n MEM_STAT_INFO)))
#define <API key>() ((struct cxx_binding *)(<API key> (sizeof (struct cxx_binding) MEM_STAT_INFO)))
#define <API key>() ((struct cxx_binding *)(<API key> (sizeof (struct cxx_binding) MEM_STAT_INFO)))
#define <API key>(n) ((struct cxx_binding *)(<API key> (sizeof (struct cxx_binding), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cxx_binding *)(<API key> (sizeof (struct cxx_binding), n MEM_STAT_INFO)))
#define <API key>() ((struct binding_entry_s *)(<API key> (sizeof (struct binding_entry_s) MEM_STAT_INFO)))
#define <API key>() ((struct binding_entry_s *)(<API key> (sizeof (struct binding_entry_s) MEM_STAT_INFO)))
#define <API key>(n) ((struct binding_entry_s *)(<API key> (sizeof (struct binding_entry_s), n MEM_STAT_INFO)))
#define <API key>(n) ((struct binding_entry_s *)(<API key> (sizeof (struct binding_entry_s), n MEM_STAT_INFO)))
#define <API key>() ((struct binding_table_s *)(<API key> (sizeof (struct binding_table_s) MEM_STAT_INFO)))
#define <API key>() ((struct binding_table_s *)(<API key> (sizeof (struct binding_table_s) MEM_STAT_INFO)))
#define <API key>(n) ((struct binding_table_s *)(<API key> (sizeof (struct binding_table_s), n MEM_STAT_INFO)))
#define <API key>(n) ((struct binding_table_s *)(<API key> (sizeof (struct binding_table_s), n MEM_STAT_INFO)))
#define <API key>() ((struct tinst_level *)(<API key> (sizeof (struct tinst_level) MEM_STAT_INFO)))
#define <API key>() ((struct tinst_level *)(<API key> (sizeof (struct tinst_level) MEM_STAT_INFO)))
#define <API key>(n) ((struct tinst_level *)(<API key> (sizeof (struct tinst_level), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tinst_level *)(<API key> (sizeof (struct tinst_level), n MEM_STAT_INFO)))
#define ggc_alloc_globals() ((struct globals *)(<API key> (sizeof (struct globals) MEM_STAT_INFO)))
#define <API key>() ((struct globals *)(<API key> (sizeof (struct globals) MEM_STAT_INFO)))
#define <API key>(n) ((struct globals *)(<API key> (sizeof (struct globals), n MEM_STAT_INFO)))
#define <API key>(n) ((struct globals *)(<API key> (sizeof (struct globals), n MEM_STAT_INFO)))
#define <API key>() ((vec<tinfo_s,va_gc> *)(<API key> (sizeof (vec<tinfo_s,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<tinfo_s,va_gc> *)(<API key> (sizeof (vec<tinfo_s,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<tinfo_s,va_gc> *)(<API key> (sizeof (vec<tinfo_s,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<tinfo_s,va_gc> *)(<API key> (sizeof (vec<tinfo_s,va_gc>), n MEM_STAT_INFO)))
#define ggc_alloc_tinfo_s() ((struct tinfo_s *)(<API key> (sizeof (struct tinfo_s) MEM_STAT_INFO)))
#define <API key>() ((struct tinfo_s *)(<API key> (sizeof (struct tinfo_s) MEM_STAT_INFO)))
#define <API key>(n) ((struct tinfo_s *)(<API key> (sizeof (struct tinfo_s), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tinfo_s *)(<API key> (sizeof (struct tinfo_s), n MEM_STAT_INFO)))
#define ggc_alloc_c_parser() ((struct c_parser *)(<API key> (sizeof (struct c_parser) MEM_STAT_INFO)))
#define <API key>() ((struct c_parser *)(<API key> (sizeof (struct c_parser) MEM_STAT_INFO)))
#define <API key>(n) ((struct c_parser *)(<API key> (sizeof (struct c_parser), n MEM_STAT_INFO)))
#define <API key>(n) ((struct c_parser *)(<API key> (sizeof (struct c_parser), n MEM_STAT_INFO)))
#define ggc_alloc_c_token() ((struct c_token *)(<API key> (sizeof (struct c_token) MEM_STAT_INFO)))
#define <API key>() ((struct c_token *)(<API key> (sizeof (struct c_token) MEM_STAT_INFO)))
#define <API key>(n) ((struct c_token *)(<API key> (sizeof (struct c_token), n MEM_STAT_INFO)))
#define <API key>(n) ((struct c_token *)(<API key> (sizeof (struct c_token), n MEM_STAT_INFO)))
#define ggc_alloc_opt_stack() ((struct opt_stack *)(<API key> (sizeof (struct opt_stack) MEM_STAT_INFO)))
#define <API key>() ((struct opt_stack *)(<API key> (sizeof (struct opt_stack) MEM_STAT_INFO)))
#define <API key>(n) ((struct opt_stack *)(<API key> (sizeof (struct opt_stack), n MEM_STAT_INFO)))
#define <API key>(n) ((struct opt_stack *)(<API key> (sizeof (struct opt_stack), n MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((vec<pending_weak,va_gc> *)(<API key> (sizeof (vec<pending_weak,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<pending_weak,va_gc> *)(<API key> (sizeof (vec<pending_weak,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<pending_weak,va_gc> *)(<API key> (sizeof (vec<pending_weak,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<pending_weak,va_gc> *)(<API key> (sizeof (vec<pending_weak,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct pending_weak_d *)(<API key> (sizeof (struct pending_weak_d) MEM_STAT_INFO)))
#define <API key>() ((struct pending_weak_d *)(<API key> (sizeof (struct pending_weak_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct pending_weak_d *)(<API key> (sizeof (struct pending_weak_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct pending_weak_d *)(<API key> (sizeof (struct pending_weak_d), n MEM_STAT_INFO)))
#define <API key>() ((struct align_stack *)(<API key> (sizeof (struct align_stack) MEM_STAT_INFO)))
#define <API key>() ((struct align_stack *)(<API key> (sizeof (struct align_stack) MEM_STAT_INFO)))
#define <API key>(n) ((struct align_stack *)(<API key> (sizeof (struct align_stack), n MEM_STAT_INFO)))
#define <API key>(n) ((struct align_stack *)(<API key> (sizeof (struct align_stack), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((vec<tree_gc_vec,va_gc> *)(<API key> (sizeof (vec<tree_gc_vec,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<tree_gc_vec,va_gc> *)(<API key> (sizeof (vec<tree_gc_vec,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<tree_gc_vec,va_gc> *)(<API key> (sizeof (vec<tree_gc_vec,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<tree_gc_vec,va_gc> *)(<API key> (sizeof (vec<tree_gc_vec,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct c_language_function *)(<API key> (sizeof (struct c_language_function) MEM_STAT_INFO)))
#define <API key>() ((struct c_language_function *)(<API key> (sizeof (struct c_language_function) MEM_STAT_INFO)))
#define <API key>(n) ((struct c_language_function *)(<API key> (sizeof (struct c_language_function), n MEM_STAT_INFO)))
#define <API key>(n) ((struct c_language_function *)(<API key> (sizeof (struct c_language_function), n MEM_STAT_INFO)))
#define <API key>() ((vec<const_char_p,va_gc> *)(<API key> (sizeof (vec<const_char_p,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<const_char_p,va_gc> *)(<API key> (sizeof (vec<const_char_p,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<const_char_p,va_gc> *)(<API key> (sizeof (vec<const_char_p,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<const_char_p,va_gc> *)(<API key> (sizeof (vec<const_char_p,va_gc>), n MEM_STAT_INFO)))
#define <API key>(SIZE) ((struct sorted_fields_type *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE) ((struct sorted_fields_type *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct sorted_fields_type *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct sorted_fields_type *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>() ((struct c_inline_static *)(<API key> (sizeof (struct c_inline_static) MEM_STAT_INFO)))
#define <API key>() ((struct c_inline_static *)(<API key> (sizeof (struct c_inline_static) MEM_STAT_INFO)))
#define <API key>(n) ((struct c_inline_static *)(<API key> (sizeof (struct c_inline_static), n MEM_STAT_INFO)))
#define <API key>(n) ((struct c_inline_static *)(<API key> (sizeof (struct c_inline_static), n MEM_STAT_INFO)))
#define <API key>() ((vec<c_goto_bindings_p,va_gc> *)(<API key> (sizeof (vec<c_goto_bindings_p,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<c_goto_bindings_p,va_gc> *)(<API key> (sizeof (vec<c_goto_bindings_p,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<c_goto_bindings_p,va_gc> *)(<API key> (sizeof (vec<c_goto_bindings_p,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<c_goto_bindings_p,va_gc> *)(<API key> (sizeof (vec<c_goto_bindings_p,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct c_goto_bindings *)(<API key> (sizeof (struct c_goto_bindings) MEM_STAT_INFO)))
#define <API key>() ((struct c_goto_bindings *)(<API key> (sizeof (struct c_goto_bindings) MEM_STAT_INFO)))
#define <API key>(n) ((struct c_goto_bindings *)(<API key> (sizeof (struct c_goto_bindings), n MEM_STAT_INFO)))
#define <API key>(n) ((struct c_goto_bindings *)(<API key> (sizeof (struct c_goto_bindings), n MEM_STAT_INFO)))
#define ggc_alloc_c_scope() ((struct c_scope *)(<API key> (sizeof (struct c_scope) MEM_STAT_INFO)))
#define <API key>() ((struct c_scope *)(<API key> (sizeof (struct c_scope) MEM_STAT_INFO)))
#define <API key>(n) ((struct c_scope *)(<API key> (sizeof (struct c_scope), n MEM_STAT_INFO)))
#define <API key>(n) ((struct c_scope *)(<API key> (sizeof (struct c_scope), n MEM_STAT_INFO)))
#define <API key>() ((struct lang_identifier *)(<API key> (sizeof (struct lang_identifier) MEM_STAT_INFO)))
#define <API key>() ((struct lang_identifier *)(<API key> (sizeof (struct lang_identifier) MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_identifier *)(<API key> (sizeof (struct lang_identifier), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lang_identifier *)(<API key> (sizeof (struct lang_identifier), n MEM_STAT_INFO)))
#define <API key>() ((struct c_common_identifier *)(<API key> (sizeof (struct c_common_identifier) MEM_STAT_INFO)))
#define <API key>() ((struct c_common_identifier *)(<API key> (sizeof (struct c_common_identifier) MEM_STAT_INFO)))
#define <API key>(n) ((struct c_common_identifier *)(<API key> (sizeof (struct c_common_identifier), n MEM_STAT_INFO)))
#define <API key>(n) ((struct c_common_identifier *)(<API key> (sizeof (struct c_common_identifier), n MEM_STAT_INFO)))
#define ggc_alloc_c_binding() ((struct c_binding *)(<API key> (sizeof (struct c_binding) MEM_STAT_INFO)))
#define <API key>() ((struct c_binding *)(<API key> (sizeof (struct c_binding) MEM_STAT_INFO)))
#define <API key>(n) ((struct c_binding *)(<API key> (sizeof (struct c_binding), n MEM_STAT_INFO)))
#define <API key>(n) ((struct c_binding *)(<API key> (sizeof (struct c_binding), n MEM_STAT_INFO)))
#define <API key>() ((struct c_label_vars *)(<API key> (sizeof (struct c_label_vars) MEM_STAT_INFO)))
#define <API key>() ((struct c_label_vars *)(<API key> (sizeof (struct c_label_vars) MEM_STAT_INFO)))
#define <API key>(n) ((struct c_label_vars *)(<API key> (sizeof (struct c_label_vars), n MEM_STAT_INFO)))
#define <API key>(n) ((struct c_label_vars *)(<API key> (sizeof (struct c_label_vars), n MEM_STAT_INFO)))
#define <API key>() ((struct stmt_tree_s *)(<API key> (sizeof (struct stmt_tree_s) MEM_STAT_INFO)))
#define <API key>() ((struct stmt_tree_s *)(<API key> (sizeof (struct stmt_tree_s) MEM_STAT_INFO)))
#define <API key>(n) ((struct stmt_tree_s *)(<API key> (sizeof (struct stmt_tree_s), n MEM_STAT_INFO)))
#define <API key>(n) ((struct stmt_tree_s *)(<API key> (sizeof (struct stmt_tree_s), n MEM_STAT_INFO)))
#define <API key>() ((struct c_spot_bindings *)(<API key> (sizeof (struct c_spot_bindings) MEM_STAT_INFO)))
#define <API key>() ((struct c_spot_bindings *)(<API key> (sizeof (struct c_spot_bindings) MEM_STAT_INFO)))
#define <API key>(n) ((struct c_spot_bindings *)(<API key> (sizeof (struct c_spot_bindings), n MEM_STAT_INFO)))
#define <API key>(n) ((struct c_spot_bindings *)(<API key> (sizeof (struct c_spot_bindings), n MEM_STAT_INFO)))
#define <API key>() ((struct pad_type_hash *)(<API key> (sizeof (struct pad_type_hash) MEM_STAT_INFO)))
#define <API key>() ((struct pad_type_hash *)(<API key> (sizeof (struct pad_type_hash) MEM_STAT_INFO)))
#define <API key>(n) ((struct pad_type_hash *)(<API key> (sizeof (struct pad_type_hash), n MEM_STAT_INFO)))
#define <API key>(n) ((struct pad_type_hash *)(<API key> (sizeof (struct pad_type_hash), n MEM_STAT_INFO)))
#define <API key>() ((struct gnat_binding_level *)(<API key> (sizeof (struct gnat_binding_level) MEM_STAT_INFO)))
#define <API key>() ((struct gnat_binding_level *)(<API key> (sizeof (struct gnat_binding_level) MEM_STAT_INFO)))
#define <API key>(n) ((struct gnat_binding_level *)(<API key> (sizeof (struct gnat_binding_level), n MEM_STAT_INFO)))
#define <API key>(n) ((struct gnat_binding_level *)(<API key> (sizeof (struct gnat_binding_level), n MEM_STAT_INFO)))
#define <API key>() ((vec<loop_info,va_gc> *)(<API key> (sizeof (vec<loop_info,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<loop_info,va_gc> *)(<API key> (sizeof (vec<loop_info,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<loop_info,va_gc> *)(<API key> (sizeof (vec<loop_info,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<loop_info,va_gc> *)(<API key> (sizeof (vec<loop_info,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct loop_info_d *)(<API key> (sizeof (struct loop_info_d) MEM_STAT_INFO)))
#define <API key>() ((struct loop_info_d *)(<API key> (sizeof (struct loop_info_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct loop_info_d *)(<API key> (sizeof (struct loop_info_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct loop_info_d *)(<API key> (sizeof (struct loop_info_d), n MEM_STAT_INFO)))
#define <API key>() ((vec<range_check_info,va_gc> *)(<API key> (sizeof (vec<range_check_info,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<range_check_info,va_gc> *)(<API key> (sizeof (vec<range_check_info,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<range_check_info,va_gc> *)(<API key> (sizeof (vec<range_check_info,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<range_check_info,va_gc> *)(<API key> (sizeof (vec<range_check_info,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct range_check_info_d *)(<API key> (sizeof (struct range_check_info_d) MEM_STAT_INFO)))
#define <API key>() ((struct range_check_info_d *)(<API key> (sizeof (struct range_check_info_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct range_check_info_d *)(<API key> (sizeof (struct range_check_info_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct range_check_info_d *)(<API key> (sizeof (struct range_check_info_d), n MEM_STAT_INFO)))
#define ggc_alloc_elab_info() ((struct elab_info *)(<API key> (sizeof (struct elab_info) MEM_STAT_INFO)))
#define <API key>() ((struct elab_info *)(<API key> (sizeof (struct elab_info) MEM_STAT_INFO)))
#define <API key>(n) ((struct elab_info *)(<API key> (sizeof (struct elab_info), n MEM_STAT_INFO)))
#define <API key>(n) ((struct elab_info *)(<API key> (sizeof (struct elab_info), n MEM_STAT_INFO)))
#define <API key>() ((struct stmt_group *)(<API key> (sizeof (struct stmt_group) MEM_STAT_INFO)))
#define <API key>() ((struct stmt_group *)(<API key> (sizeof (struct stmt_group) MEM_STAT_INFO)))
#define <API key>(n) ((struct stmt_group *)(<API key> (sizeof (struct stmt_group), n MEM_STAT_INFO)))
#define <API key>(n) ((struct stmt_group *)(<API key> (sizeof (struct stmt_group), n MEM_STAT_INFO)))
#define <API key>() ((vec<parm_attr,va_gc> *)(<API key> (sizeof (vec<parm_attr,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<parm_attr,va_gc> *)(<API key> (sizeof (vec<parm_attr,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<parm_attr,va_gc> *)(<API key> (sizeof (vec<parm_attr,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<parm_attr,va_gc> *)(<API key> (sizeof (vec<parm_attr,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct parm_attr_d *)(<API key> (sizeof (struct parm_attr_d) MEM_STAT_INFO)))
#define <API key>() ((struct parm_attr_d *)(<API key> (sizeof (struct parm_attr_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct parm_attr_d *)(<API key> (sizeof (struct parm_attr_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct parm_attr_d *)(<API key> (sizeof (struct parm_attr_d), n MEM_STAT_INFO)))
#define <API key>() ((vec<inline_summary_t,va_gc> *)(<API key> (sizeof (vec<inline_summary_t,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<inline_summary_t,va_gc> *)(<API key> (sizeof (vec<inline_summary_t,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<inline_summary_t,va_gc> *)(<API key> (sizeof (vec<inline_summary_t,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<inline_summary_t,va_gc> *)(<API key> (sizeof (vec<inline_summary_t,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((vec<size_time_entry,va_gc> *)(<API key> (sizeof (vec<size_time_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<size_time_entry,va_gc> *)(<API key> (sizeof (vec<size_time_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<size_time_entry,va_gc> *)(<API key> (sizeof (vec<size_time_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<size_time_entry,va_gc> *)(<API key> (sizeof (vec<size_time_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct size_time_entry *)(<API key> (sizeof (struct size_time_entry) MEM_STAT_INFO)))
#define <API key>() ((struct size_time_entry *)(<API key> (sizeof (struct size_time_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct size_time_entry *)(<API key> (sizeof (struct size_time_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct size_time_entry *)(<API key> (sizeof (struct size_time_entry), n MEM_STAT_INFO)))
#define ggc_alloc_predicate() ((struct predicate *)(<API key> (sizeof (struct predicate) MEM_STAT_INFO)))
#define <API key>() ((struct predicate *)(<API key> (sizeof (struct predicate) MEM_STAT_INFO)))
#define <API key>(n) ((struct predicate *)(<API key> (sizeof (struct predicate), n MEM_STAT_INFO)))
#define <API key>(n) ((struct predicate *)(<API key> (sizeof (struct predicate), n MEM_STAT_INFO)))
#define <API key>() ((vec<condition,va_gc> *)(<API key> (sizeof (vec<condition,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<condition,va_gc> *)(<API key> (sizeof (vec<condition,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<condition,va_gc> *)(<API key> (sizeof (vec<condition,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<condition,va_gc> *)(<API key> (sizeof (vec<condition,va_gc>), n MEM_STAT_INFO)))
#define ggc_alloc_condition() ((struct condition *)(<API key> (sizeof (struct condition) MEM_STAT_INFO)))
#define <API key>() ((struct condition *)(<API key> (sizeof (struct condition) MEM_STAT_INFO)))
#define <API key>(n) ((struct condition *)(<API key> (sizeof (struct condition), n MEM_STAT_INFO)))
#define <API key>(n) ((struct condition *)(<API key> (sizeof (struct condition), n MEM_STAT_INFO)))
#define <API key>() ((struct lto_tree_ref_table *)(<API key> (sizeof (struct lto_tree_ref_table) MEM_STAT_INFO)))
#define <API key>() ((struct lto_tree_ref_table *)(<API key> (sizeof (struct lto_tree_ref_table) MEM_STAT_INFO)))
#define <API key>(n) ((struct lto_tree_ref_table *)(<API key> (sizeof (struct lto_tree_ref_table), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lto_tree_ref_table *)(<API key> (sizeof (struct lto_tree_ref_table), n MEM_STAT_INFO)))
#define <API key>() ((struct lto_in_decl_state *)(<API key> (sizeof (struct lto_in_decl_state) MEM_STAT_INFO)))
#define <API key>() ((struct lto_in_decl_state *)(<API key> (sizeof (struct lto_in_decl_state) MEM_STAT_INFO)))
#define <API key>(n) ((struct lto_in_decl_state *)(<API key> (sizeof (struct lto_in_decl_state), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lto_in_decl_state *)(<API key> (sizeof (struct lto_in_decl_state), n MEM_STAT_INFO)))
#define <API key>() ((vec<ipa_edge_args_t,va_gc> *)(<API key> (sizeof (vec<ipa_edge_args_t,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<ipa_edge_args_t,va_gc> *)(<API key> (sizeof (vec<ipa_edge_args_t,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<ipa_edge_args_t,va_gc> *)(<API key> (sizeof (vec<ipa_edge_args_t,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<ipa_edge_args_t,va_gc> *)(<API key> (sizeof (vec<ipa_edge_args_t,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((vec<ipa_jump_func_t,va_gc> *)(<API key> (sizeof (vec<ipa_jump_func_t,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<ipa_jump_func_t,va_gc> *)(<API key> (sizeof (vec<ipa_jump_func_t,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<ipa_jump_func_t,va_gc> *)(<API key> (sizeof (vec<ipa_jump_func_t,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<ipa_jump_func_t,va_gc> *)(<API key> (sizeof (vec<ipa_jump_func_t,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((union jump_func_value *)(<API key> (sizeof (union jump_func_value) MEM_STAT_INFO)))
#define <API key>() ((union jump_func_value *)(<API key> (sizeof (union jump_func_value) MEM_STAT_INFO)))
#define <API key>(n) ((union jump_func_value *)(<API key> (sizeof (union jump_func_value), n MEM_STAT_INFO)))
#define <API key>(n) ((union jump_func_value *)(<API key> (sizeof (union jump_func_value), n MEM_STAT_INFO)))
#define <API key>() ((vec<ipa_agg_jf_item_t,va_gc> *)(<API key> (sizeof (vec<ipa_agg_jf_item_t,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<ipa_agg_jf_item_t,va_gc> *)(<API key> (sizeof (vec<ipa_agg_jf_item_t,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<ipa_agg_jf_item_t,va_gc> *)(<API key> (sizeof (vec<ipa_agg_jf_item_t,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<ipa_agg_jf_item_t,va_gc> *)(<API key> (sizeof (vec<ipa_agg_jf_item_t,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct ipa_known_type_data *)(<API key> (sizeof (struct ipa_known_type_data) MEM_STAT_INFO)))
#define <API key>() ((struct ipa_known_type_data *)(<API key> (sizeof (struct ipa_known_type_data) MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_known_type_data *)(<API key> (sizeof (struct ipa_known_type_data), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_known_type_data *)(<API key> (sizeof (struct ipa_known_type_data), n MEM_STAT_INFO)))
#define <API key>(SIZE) ((struct <API key> *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE) ((struct <API key> *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct <API key> *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct <API key> *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>() ((struct scev_info_str *)(<API key> (sizeof (struct scev_info_str) MEM_STAT_INFO)))
#define <API key>() ((struct scev_info_str *)(<API key> (sizeof (struct scev_info_str) MEM_STAT_INFO)))
#define <API key>(n) ((struct scev_info_str *)(<API key> (sizeof (struct scev_info_str), n MEM_STAT_INFO)))
#define <API key>(n) ((struct scev_info_str *)(<API key> (sizeof (struct scev_info_str), n MEM_STAT_INFO)))
#define <API key>() ((vec<mem_addr_template,va_gc> *)(<API key> (sizeof (vec<mem_addr_template,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<mem_addr_template,va_gc> *)(<API key> (sizeof (vec<mem_addr_template,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<mem_addr_template,va_gc> *)(<API key> (sizeof (vec<mem_addr_template,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<mem_addr_template,va_gc> *)(<API key> (sizeof (vec<mem_addr_template,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct mem_addr_template *)(<API key> (sizeof (struct mem_addr_template) MEM_STAT_INFO)))
#define <API key>() ((struct mem_addr_template *)(<API key> (sizeof (struct mem_addr_template) MEM_STAT_INFO)))
#define <API key>(n) ((struct mem_addr_template *)(<API key> (sizeof (struct mem_addr_template), n MEM_STAT_INFO)))
#define <API key>(n) ((struct mem_addr_template *)(<API key> (sizeof (struct mem_addr_template), n MEM_STAT_INFO)))
#define <API key>() ((struct ssa_operands *)(<API key> (sizeof (struct ssa_operands) MEM_STAT_INFO)))
#define <API key>() ((struct ssa_operands *)(<API key> (sizeof (struct ssa_operands) MEM_STAT_INFO)))
#define <API key>(n) ((struct ssa_operands *)(<API key> (sizeof (struct ssa_operands), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ssa_operands *)(<API key> (sizeof (struct ssa_operands), n MEM_STAT_INFO)))
#define <API key>() ((vec<gimple,va_gc> *)(<API key> (sizeof (vec<gimple,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<gimple,va_gc> *)(<API key> (sizeof (vec<gimple,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<gimple,va_gc> *)(<API key> (sizeof (vec<gimple,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<gimple,va_gc> *)(<API key> (sizeof (vec<gimple,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct tm_restart_node *)(<API key> (sizeof (struct tm_restart_node) MEM_STAT_INFO)))
#define <API key>() ((struct tm_restart_node *)(<API key> (sizeof (struct tm_restart_node) MEM_STAT_INFO)))
#define <API key>(n) ((struct tm_restart_node *)(<API key> (sizeof (struct tm_restart_node), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tm_restart_node *)(<API key> (sizeof (struct tm_restart_node), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct gimple_omp_for_iter *)(<API key> (sizeof (struct gimple_omp_for_iter) MEM_STAT_INFO)))
#define <API key>() ((struct gimple_omp_for_iter *)(<API key> (sizeof (struct gimple_omp_for_iter) MEM_STAT_INFO)))
#define <API key>(n) ((struct gimple_omp_for_iter *)(<API key> (sizeof (struct gimple_omp_for_iter), n MEM_STAT_INFO)))
#define <API key>(n) ((struct gimple_omp_for_iter *)(<API key> (sizeof (struct gimple_omp_for_iter), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct pt_solution *)(<API key> (sizeof (struct pt_solution) MEM_STAT_INFO)))
#define <API key>() ((struct pt_solution *)(<API key> (sizeof (struct pt_solution) MEM_STAT_INFO)))
#define <API key>(n) ((struct pt_solution *)(<API key> (sizeof (struct pt_solution), n MEM_STAT_INFO)))
#define <API key>(n) ((struct pt_solution *)(<API key> (sizeof (struct pt_solution), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define ggc_alloc_type_hash() ((struct type_hash *)(<API key> (sizeof (struct type_hash) MEM_STAT_INFO)))
#define <API key>() ((struct type_hash *)(<API key> (sizeof (struct type_hash) MEM_STAT_INFO)))
#define <API key>(n) ((struct type_hash *)(<API key> (sizeof (struct type_hash), n MEM_STAT_INFO)))
#define <API key>(n) ((struct type_hash *)(<API key> (sizeof (struct type_hash), n MEM_STAT_INFO)))
#define <API key>() ((struct string_pool_data *)(<API key> (sizeof (struct string_pool_data) MEM_STAT_INFO)))
#define <API key>() ((struct string_pool_data *)(<API key> (sizeof (struct string_pool_data) MEM_STAT_INFO)))
#define <API key>(n) ((struct string_pool_data *)(<API key> (sizeof (struct string_pool_data), n MEM_STAT_INFO)))
#define <API key>(n) ((struct string_pool_data *)(<API key> (sizeof (struct string_pool_data), n MEM_STAT_INFO)))
#define <API key>() ((vec<dummy_info_ref,va_gc> *)(<API key> (sizeof (vec<dummy_info_ref,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<dummy_info_ref,va_gc> *)(<API key> (sizeof (vec<dummy_info_ref,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<dummy_info_ref,va_gc> *)(<API key> (sizeof (vec<dummy_info_ref,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<dummy_info_ref,va_gc> *)(<API key> (sizeof (vec<dummy_info_ref,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct dummy_info_t *)(<API key> (sizeof (struct dummy_info_t) MEM_STAT_INFO)))
#define <API key>() ((struct dummy_info_t *)(<API key> (sizeof (struct dummy_info_t) MEM_STAT_INFO)))
#define <API key>(n) ((struct dummy_info_t *)(<API key> (sizeof (struct dummy_info_t), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dummy_info_t *)(<API key> (sizeof (struct dummy_info_t), n MEM_STAT_INFO)))
#define <API key>() ((vec<compact_info_ref,va_gc> *)(<API key> (sizeof (vec<compact_info_ref,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<compact_info_ref,va_gc> *)(<API key> (sizeof (vec<compact_info_ref,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<compact_info_ref,va_gc> *)(<API key> (sizeof (vec<compact_info_ref,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<compact_info_ref,va_gc> *)(<API key> (sizeof (vec<compact_info_ref,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct compact_info_t *)(<API key> (sizeof (struct compact_info_t) MEM_STAT_INFO)))
#define <API key>() ((struct compact_info_t *)(<API key> (sizeof (struct compact_info_t) MEM_STAT_INFO)))
#define <API key>(n) ((struct compact_info_t *)(<API key> (sizeof (struct compact_info_t), n MEM_STAT_INFO)))
#define <API key>(n) ((struct compact_info_t *)(<API key> (sizeof (struct compact_info_t), n MEM_STAT_INFO)))
#define <API key>() ((vec<chain_ref,va_gc> *)(<API key> (sizeof (vec<chain_ref,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<chain_ref,va_gc> *)(<API key> (sizeof (vec<chain_ref,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<chain_ref,va_gc> *)(<API key> (sizeof (vec<chain_ref,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<chain_ref,va_gc> *)(<API key> (sizeof (vec<chain_ref,va_gc>), n MEM_STAT_INFO)))
#define ggc_alloc_chain_t() ((struct chain_t *)(<API key> (sizeof (struct chain_t) MEM_STAT_INFO)))
#define <API key>() ((struct chain_t *)(<API key> (sizeof (struct chain_t) MEM_STAT_INFO)))
#define <API key>(n) ((struct chain_t *)(<API key> (sizeof (struct chain_t), n MEM_STAT_INFO)))
#define <API key>(n) ((struct chain_t *)(<API key> (sizeof (struct chain_t), n MEM_STAT_INFO)))
#define <API key>() ((struct initial_value_pair *)(<API key> (sizeof (struct initial_value_pair) MEM_STAT_INFO)))
#define <API key>() ((struct initial_value_pair *)(<API key> (sizeof (struct initial_value_pair) MEM_STAT_INFO)))
#define <API key>(n) ((struct initial_value_pair *)(<API key> (sizeof (struct initial_value_pair), n MEM_STAT_INFO)))
#define <API key>(n) ((struct initial_value_pair *)(<API key> (sizeof (struct initial_value_pair), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((union eh_status_u *)(<API key> (sizeof (union eh_status_u) MEM_STAT_INFO)))
#define <API key>() ((union eh_status_u *)(<API key> (sizeof (union eh_status_u) MEM_STAT_INFO)))
#define <API key>(n) ((union eh_status_u *)(<API key> (sizeof (union eh_status_u), n MEM_STAT_INFO)))
#define <API key>(n) ((union eh_status_u *)(<API key> (sizeof (union eh_status_u), n MEM_STAT_INFO)))
#define <API key>() ((struct throw_stmt_node *)(<API key> (sizeof (struct throw_stmt_node) MEM_STAT_INFO)))
#define <API key>() ((struct throw_stmt_node *)(<API key> (sizeof (struct throw_stmt_node) MEM_STAT_INFO)))
#define <API key>(n) ((struct throw_stmt_node *)(<API key> (sizeof (struct throw_stmt_node), n MEM_STAT_INFO)))
#define <API key>(n) ((struct throw_stmt_node *)(<API key> (sizeof (struct throw_stmt_node), n MEM_STAT_INFO)))
#define <API key>() ((vec<eh_landing_pad,va_gc> *)(<API key> (sizeof (vec<eh_landing_pad,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<eh_landing_pad,va_gc> *)(<API key> (sizeof (vec<eh_landing_pad,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<eh_landing_pad,va_gc> *)(<API key> (sizeof (vec<eh_landing_pad,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<eh_landing_pad,va_gc> *)(<API key> (sizeof (vec<eh_landing_pad,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((vec<eh_region,va_gc> *)(<API key> (sizeof (vec<eh_region,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<eh_region,va_gc> *)(<API key> (sizeof (vec<eh_region,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<eh_region,va_gc> *)(<API key> (sizeof (vec<eh_region,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<eh_region,va_gc> *)(<API key> (sizeof (vec<eh_region,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((union eh_region_u *)(<API key> (sizeof (union eh_region_u) MEM_STAT_INFO)))
#define <API key>() ((union eh_region_u *)(<API key> (sizeof (union eh_region_u) MEM_STAT_INFO)))
#define <API key>(n) ((union eh_region_u *)(<API key> (sizeof (union eh_region_u), n MEM_STAT_INFO)))
#define <API key>(n) ((union eh_region_u *)(<API key> (sizeof (union eh_region_u), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct eh_region_u_allowed *)(<API key> (sizeof (struct eh_region_u_allowed) MEM_STAT_INFO)))
#define <API key>() ((struct eh_region_u_allowed *)(<API key> (sizeof (struct eh_region_u_allowed) MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_region_u_allowed *)(<API key> (sizeof (struct eh_region_u_allowed), n MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_region_u_allowed *)(<API key> (sizeof (struct eh_region_u_allowed), n MEM_STAT_INFO)))
#define <API key>() ((struct eh_region_u_try *)(<API key> (sizeof (struct eh_region_u_try) MEM_STAT_INFO)))
#define <API key>() ((struct eh_region_u_try *)(<API key> (sizeof (struct eh_region_u_try) MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_region_u_try *)(<API key> (sizeof (struct eh_region_u_try), n MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_region_u_try *)(<API key> (sizeof (struct eh_region_u_try), n MEM_STAT_INFO)))
#define <API key>() ((struct eh_catch_d *)(<API key> (sizeof (struct eh_catch_d) MEM_STAT_INFO)))
#define <API key>() ((struct eh_catch_d *)(<API key> (sizeof (struct eh_catch_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_catch_d *)(<API key> (sizeof (struct eh_catch_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_catch_d *)(<API key> (sizeof (struct eh_catch_d), n MEM_STAT_INFO)))
#define <API key>() ((struct eh_landing_pad_d *)(<API key> (sizeof (struct eh_landing_pad_d) MEM_STAT_INFO)))
#define <API key>() ((struct eh_landing_pad_d *)(<API key> (sizeof (struct eh_landing_pad_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_landing_pad_d *)(<API key> (sizeof (struct eh_landing_pad_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_landing_pad_d *)(<API key> (sizeof (struct eh_landing_pad_d), n MEM_STAT_INFO)))
#define <API key>() ((struct eh_region_d *)(<API key> (sizeof (struct eh_region_d) MEM_STAT_INFO)))
#define <API key>() ((struct eh_region_d *)(<API key> (sizeof (struct eh_region_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_region_d *)(<API key> (sizeof (struct eh_region_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_region_d *)(<API key> (sizeof (struct eh_region_d), n MEM_STAT_INFO)))
#define <API key>() ((vec<die_arg_entry,va_gc> *)(<API key> (sizeof (vec<die_arg_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<die_arg_entry,va_gc> *)(<API key> (sizeof (vec<die_arg_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<die_arg_entry,va_gc> *)(<API key> (sizeof (vec<die_arg_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<die_arg_entry,va_gc> *)(<API key> (sizeof (vec<die_arg_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((vec<macinfo_entry,va_gc> *)(<API key> (sizeof (vec<macinfo_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<macinfo_entry,va_gc> *)(<API key> (sizeof (vec<macinfo_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<macinfo_entry,va_gc> *)(<API key> (sizeof (vec<macinfo_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<macinfo_entry,va_gc> *)(<API key> (sizeof (vec<macinfo_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((vec<pubname_entry,va_gc> *)(<API key> (sizeof (vec<pubname_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<pubname_entry,va_gc> *)(<API key> (sizeof (vec<pubname_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<pubname_entry,va_gc> *)(<API key> (sizeof (vec<pubname_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<pubname_entry,va_gc> *)(<API key> (sizeof (vec<pubname_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<<API key>,va_gc> *)(<API key> (sizeof (vec<<API key>,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct call_arg_loc_node *)(<API key> (sizeof (struct call_arg_loc_node) MEM_STAT_INFO)))
#define <API key>() ((struct call_arg_loc_node *)(<API key> (sizeof (struct call_arg_loc_node) MEM_STAT_INFO)))
#define <API key>(n) ((struct call_arg_loc_node *)(<API key> (sizeof (struct call_arg_loc_node), n MEM_STAT_INFO)))
#define <API key>(n) ((struct call_arg_loc_node *)(<API key> (sizeof (struct call_arg_loc_node), n MEM_STAT_INFO)))
#define <API key>() ((struct var_loc_list_def *)(<API key> (sizeof (struct var_loc_list_def) MEM_STAT_INFO)))
#define <API key>() ((struct var_loc_list_def *)(<API key> (sizeof (struct var_loc_list_def) MEM_STAT_INFO)))
#define <API key>(n) ((struct var_loc_list_def *)(<API key> (sizeof (struct var_loc_list_def), n MEM_STAT_INFO)))
#define <API key>(n) ((struct var_loc_list_def *)(<API key> (sizeof (struct var_loc_list_def), n MEM_STAT_INFO)))
#define <API key>() ((struct var_loc_node *)(<API key> (sizeof (struct var_loc_node) MEM_STAT_INFO)))
#define <API key>() ((struct var_loc_node *)(<API key> (sizeof (struct var_loc_node) MEM_STAT_INFO)))
#define <API key>(n) ((struct var_loc_node *)(<API key> (sizeof (struct var_loc_node), n MEM_STAT_INFO)))
#define <API key>(n) ((struct var_loc_node *)(<API key> (sizeof (struct var_loc_node), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct limbo_die_struct *)(<API key> (sizeof (struct limbo_die_struct) MEM_STAT_INFO)))
#define <API key>() ((struct limbo_die_struct *)(<API key> (sizeof (struct limbo_die_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct limbo_die_struct *)(<API key> (sizeof (struct limbo_die_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct limbo_die_struct *)(<API key> (sizeof (struct limbo_die_struct), n MEM_STAT_INFO)))
#define <API key>() ((struct macinfo_struct *)(<API key> (sizeof (struct macinfo_struct) MEM_STAT_INFO)))
#define <API key>() ((struct macinfo_struct *)(<API key> (sizeof (struct macinfo_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct macinfo_struct *)(<API key> (sizeof (struct macinfo_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct macinfo_struct *)(<API key> (sizeof (struct macinfo_struct), n MEM_STAT_INFO)))
#define <API key>() ((vec<dw_attr_node,va_gc> *)(<API key> (sizeof (vec<dw_attr_node,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<dw_attr_node,va_gc> *)(<API key> (sizeof (vec<dw_attr_node,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<dw_attr_node,va_gc> *)(<API key> (sizeof (vec<dw_attr_node,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<dw_attr_node,va_gc> *)(<API key> (sizeof (vec<dw_attr_node,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((union <API key> *)(<API key> (sizeof (union <API key>) MEM_STAT_INFO)))
#define <API key>() ((union <API key> *)(<API key> (sizeof (union <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((union <API key> *)(<API key> (sizeof (union <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((union <API key> *)(<API key> (sizeof (union <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((vec<dw_line_info_entry,va_gc> *)(<API key> (sizeof (vec<dw_line_info_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<dw_line_info_entry,va_gc> *)(<API key> (sizeof (vec<dw_line_info_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<dw_line_info_entry,va_gc> *)(<API key> (sizeof (vec<dw_line_info_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<dw_line_info_entry,va_gc> *)(<API key> (sizeof (vec<dw_line_info_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct comdat_type_struct *)(<API key> (sizeof (struct comdat_type_struct) MEM_STAT_INFO)))
#define <API key>() ((struct comdat_type_struct *)(<API key> (sizeof (struct comdat_type_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct comdat_type_struct *)(<API key> (sizeof (struct comdat_type_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct comdat_type_struct *)(<API key> (sizeof (struct comdat_type_struct), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_ranges_struct *)(<API key> (sizeof (struct dw_ranges_struct) MEM_STAT_INFO)))
#define <API key>() ((struct dw_ranges_struct *)(<API key> (sizeof (struct dw_ranges_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_ranges_struct *)(<API key> (sizeof (struct dw_ranges_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_ranges_struct *)(<API key> (sizeof (struct dw_ranges_struct), n MEM_STAT_INFO)))
#define <API key>() ((struct pubname_struct *)(<API key> (sizeof (struct pubname_struct) MEM_STAT_INFO)))
#define <API key>() ((struct pubname_struct *)(<API key> (sizeof (struct pubname_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct pubname_struct *)(<API key> (sizeof (struct pubname_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct pubname_struct *)(<API key> (sizeof (struct pubname_struct), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_line_info_struct *)(<API key> (sizeof (struct dw_line_info_struct) MEM_STAT_INFO)))
#define <API key>() ((struct dw_line_info_struct *)(<API key> (sizeof (struct dw_line_info_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_line_info_struct *)(<API key> (sizeof (struct dw_line_info_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_line_info_struct *)(<API key> (sizeof (struct dw_line_info_struct), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_attr_struct *)(<API key> (sizeof (struct dw_attr_struct) MEM_STAT_INFO)))
#define <API key>() ((struct dw_attr_struct *)(<API key> (sizeof (struct dw_attr_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_attr_struct *)(<API key> (sizeof (struct dw_attr_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_attr_struct *)(<API key> (sizeof (struct dw_attr_struct), n MEM_STAT_INFO)))
#define <API key>() ((union <API key> *)(<API key> (sizeof (union <API key>) MEM_STAT_INFO)))
#define <API key>() ((union <API key> *)(<API key> (sizeof (union <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((union <API key> *)(<API key> (sizeof (union <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((union <API key> *)(<API key> (sizeof (union <API key>), n MEM_STAT_INFO)))
#define <API key>() ((vec<deferred_locations,va_gc> *)(<API key> (sizeof (vec<deferred_locations,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<deferred_locations,va_gc> *)(<API key> (sizeof (vec<deferred_locations,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<deferred_locations,va_gc> *)(<API key> (sizeof (vec<deferred_locations,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<deferred_locations,va_gc> *)(<API key> (sizeof (vec<deferred_locations,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((vec<dw_fde_ref,va_gc> *)(<API key> (sizeof (vec<dw_fde_ref,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<dw_fde_ref,va_gc> *)(<API key> (sizeof (vec<dw_fde_ref,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<dw_fde_ref,va_gc> *)(<API key> (sizeof (vec<dw_fde_ref,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<dw_fde_ref,va_gc> *)(<API key> (sizeof (vec<dw_fde_ref,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_cfi_row_struct *)(<API key> (sizeof (struct dw_cfi_row_struct) MEM_STAT_INFO)))
#define <API key>() ((struct dw_cfi_row_struct *)(<API key> (sizeof (struct dw_cfi_row_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_cfi_row_struct *)(<API key> (sizeof (struct dw_cfi_row_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_cfi_row_struct *)(<API key> (sizeof (struct dw_cfi_row_struct), n MEM_STAT_INFO)))
#define <API key>() ((union dw_val_struct_union *)(<API key> (sizeof (union dw_val_struct_union) MEM_STAT_INFO)))
#define <API key>() ((union dw_val_struct_union *)(<API key> (sizeof (union dw_val_struct_union) MEM_STAT_INFO)))
#define <API key>(n) ((union dw_val_struct_union *)(<API key> (sizeof (union dw_val_struct_union), n MEM_STAT_INFO)))
#define <API key>(n) ((union dw_val_struct_union *)(<API key> (sizeof (union dw_val_struct_union), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct dwarf_file_data *)(<API key> (sizeof (struct dwarf_file_data) MEM_STAT_INFO)))
#define <API key>() ((struct dwarf_file_data *)(<API key> (sizeof (struct dwarf_file_data) MEM_STAT_INFO)))
#define <API key>(n) ((struct dwarf_file_data *)(<API key> (sizeof (struct dwarf_file_data), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dwarf_file_data *)(<API key> (sizeof (struct dwarf_file_data), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_val_die_union *)(<API key> (sizeof (struct dw_val_die_union) MEM_STAT_INFO)))
#define <API key>() ((struct dw_val_die_union *)(<API key> (sizeof (struct dw_val_die_union) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_val_die_union *)(<API key> (sizeof (struct dw_val_die_union), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_val_die_union *)(<API key> (sizeof (struct dw_val_die_union), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_vec_struct *)(<API key> (sizeof (struct dw_vec_struct) MEM_STAT_INFO)))
#define <API key>() ((struct dw_vec_struct *)(<API key> (sizeof (struct dw_vec_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_vec_struct *)(<API key> (sizeof (struct dw_vec_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_vec_struct *)(<API key> (sizeof (struct dw_vec_struct), n MEM_STAT_INFO)))
#define ggc_alloc_cfa_loc() ((struct cfa_loc *)(<API key> (sizeof (struct cfa_loc) MEM_STAT_INFO)))
#define <API key>() ((struct cfa_loc *)(<API key> (sizeof (struct cfa_loc) MEM_STAT_INFO)))
#define <API key>(n) ((struct cfa_loc *)(<API key> (sizeof (struct cfa_loc), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cfa_loc *)(<API key> (sizeof (struct cfa_loc), n MEM_STAT_INFO)))
#define <API key>() ((vec<dw_cfi_ref,va_gc> *)(<API key> (sizeof (vec<dw_cfi_ref,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<dw_cfi_ref,va_gc> *)(<API key> (sizeof (vec<dw_cfi_ref,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<dw_cfi_ref,va_gc> *)(<API key> (sizeof (vec<dw_cfi_ref,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<dw_cfi_ref,va_gc> *)(<API key> (sizeof (vec<dw_cfi_ref,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((union dw_cfi_oprnd_struct *)(<API key> (sizeof (union dw_cfi_oprnd_struct) MEM_STAT_INFO)))
#define <API key>() ((union dw_cfi_oprnd_struct *)(<API key> (sizeof (union dw_cfi_oprnd_struct) MEM_STAT_INFO)))
#define <API key>(n) ((union dw_cfi_oprnd_struct *)(<API key> (sizeof (union dw_cfi_oprnd_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((union dw_cfi_oprnd_struct *)(<API key> (sizeof (union dw_cfi_oprnd_struct), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_loc_list_struct *)(<API key> (sizeof (struct dw_loc_list_struct) MEM_STAT_INFO)))
#define <API key>() ((struct dw_loc_list_struct *)(<API key> (sizeof (struct dw_loc_list_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_loc_list_struct *)(<API key> (sizeof (struct dw_loc_list_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_loc_list_struct *)(<API key> (sizeof (struct dw_loc_list_struct), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_loc_descr_struct *)(<API key> (sizeof (struct dw_loc_descr_struct) MEM_STAT_INFO)))
#define <API key>() ((struct dw_loc_descr_struct *)(<API key> (sizeof (struct dw_loc_descr_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_loc_descr_struct *)(<API key> (sizeof (struct dw_loc_descr_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_loc_descr_struct *)(<API key> (sizeof (struct dw_loc_descr_struct), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_cfi_struct *)(<API key> (sizeof (struct dw_cfi_struct) MEM_STAT_INFO)))
#define <API key>() ((struct dw_cfi_struct *)(<API key> (sizeof (struct dw_cfi_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_cfi_struct *)(<API key> (sizeof (struct dw_cfi_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_cfi_struct *)(<API key> (sizeof (struct dw_cfi_struct), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_val_struct *)(<API key> (sizeof (struct dw_val_struct) MEM_STAT_INFO)))
#define <API key>() ((struct dw_val_struct *)(<API key> (sizeof (struct dw_val_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_val_struct *)(<API key> (sizeof (struct dw_val_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_val_struct *)(<API key> (sizeof (struct dw_val_struct), n MEM_STAT_INFO)))
#define ggc_alloc_typeinfo() ((struct typeinfo *)(<API key> (sizeof (struct typeinfo) MEM_STAT_INFO)))
#define <API key>() ((struct typeinfo *)(<API key> (sizeof (struct typeinfo) MEM_STAT_INFO)))
#define <API key>(n) ((struct typeinfo *)(<API key> (sizeof (struct typeinfo), n MEM_STAT_INFO)))
#define <API key>(n) ((struct typeinfo *)(<API key> (sizeof (struct typeinfo), n MEM_STAT_INFO)))
#define <API key>() ((struct inline_summary *)(<API key> (sizeof (struct inline_summary) MEM_STAT_INFO)))
#define <API key>() ((struct inline_summary *)(<API key> (sizeof (struct inline_summary) MEM_STAT_INFO)))
#define <API key>(n) ((struct inline_summary *)(<API key> (sizeof (struct inline_summary), n MEM_STAT_INFO)))
#define <API key>(n) ((struct inline_summary *)(<API key> (sizeof (struct inline_summary), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct ipa_edge_args *)(<API key> (sizeof (struct ipa_edge_args) MEM_STAT_INFO)))
#define <API key>() ((struct ipa_edge_args *)(<API key> (sizeof (struct ipa_edge_args) MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_edge_args *)(<API key> (sizeof (struct ipa_edge_args), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_edge_args *)(<API key> (sizeof (struct ipa_edge_args), n MEM_STAT_INFO)))
#define <API key>() ((struct ipa_agg_jf_item *)(<API key> (sizeof (struct ipa_agg_jf_item) MEM_STAT_INFO)))
#define <API key>() ((struct ipa_agg_jf_item *)(<API key> (sizeof (struct ipa_agg_jf_item) MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_agg_jf_item *)(<API key> (sizeof (struct ipa_agg_jf_item), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_agg_jf_item *)(<API key> (sizeof (struct ipa_agg_jf_item), n MEM_STAT_INFO)))
#define <API key>() ((struct ipa_jump_func *)(<API key> (sizeof (struct ipa_jump_func) MEM_STAT_INFO)))
#define <API key>() ((struct ipa_jump_func *)(<API key> (sizeof (struct ipa_jump_func) MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_jump_func *)(<API key> (sizeof (struct ipa_jump_func), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_jump_func *)(<API key> (sizeof (struct ipa_jump_func), n MEM_STAT_INFO)))
#define <API key>() ((vec<alias_set_entry,va_gc> *)(<API key> (sizeof (vec<alias_set_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<alias_set_entry,va_gc> *)(<API key> (sizeof (vec<alias_set_entry,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<alias_set_entry,va_gc> *)(<API key> (sizeof (vec<alias_set_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<alias_set_entry,va_gc> *)(<API key> (sizeof (vec<alias_set_entry,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct alias_set_entry_d *)(<API key> (sizeof (struct alias_set_entry_d) MEM_STAT_INFO)))
#define <API key>() ((struct alias_set_entry_d *)(<API key> (sizeof (struct alias_set_entry_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct alias_set_entry_d *)(<API key> (sizeof (struct alias_set_entry_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct alias_set_entry_d *)(<API key> (sizeof (struct alias_set_entry_d), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define ggc_alloc_asm_node() ((struct asm_node *)(<API key> (sizeof (struct asm_node) MEM_STAT_INFO)))
#define <API key>() ((struct asm_node *)(<API key> (sizeof (struct asm_node) MEM_STAT_INFO)))
#define <API key>(n) ((struct asm_node *)(<API key> (sizeof (struct asm_node), n MEM_STAT_INFO)))
#define <API key>(n) ((struct asm_node *)(<API key> (sizeof (struct asm_node), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_edge *)(<API key> (sizeof (struct cgraph_edge) MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_edge *)(<API key> (sizeof (struct cgraph_edge) MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_edge *)(<API key> (sizeof (struct cgraph_edge), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_edge *)(<API key> (sizeof (struct cgraph_edge), n MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_clone_info *)(<API key> (sizeof (struct cgraph_clone_info) MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_clone_info *)(<API key> (sizeof (struct cgraph_clone_info) MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_clone_info *)(<API key> (sizeof (struct cgraph_clone_info), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_clone_info *)(<API key> (sizeof (struct cgraph_clone_info), n MEM_STAT_INFO)))
#define <API key>() ((vec<ipa_replace_map_p,va_gc> *)(<API key> (sizeof (vec<ipa_replace_map_p,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<ipa_replace_map_p,va_gc> *)(<API key> (sizeof (vec<ipa_replace_map_p,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<ipa_replace_map_p,va_gc> *)(<API key> (sizeof (vec<ipa_replace_map_p,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<ipa_replace_map_p,va_gc> *)(<API key> (sizeof (vec<ipa_replace_map_p,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct ipa_replace_map *)(<API key> (sizeof (struct ipa_replace_map) MEM_STAT_INFO)))
#define <API key>() ((struct ipa_replace_map *)(<API key> (sizeof (struct ipa_replace_map) MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_replace_map *)(<API key> (sizeof (struct ipa_replace_map), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_replace_map *)(<API key> (sizeof (struct ipa_replace_map), n MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_rtl_info *)(<API key> (sizeof (struct cgraph_rtl_info) MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_rtl_info *)(<API key> (sizeof (struct cgraph_rtl_info) MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_rtl_info *)(<API key> (sizeof (struct cgraph_rtl_info), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_rtl_info *)(<API key> (sizeof (struct cgraph_rtl_info), n MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_global_info *)(<API key> (sizeof (struct cgraph_global_info) MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_global_info *)(<API key> (sizeof (struct cgraph_global_info) MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_global_info *)(<API key> (sizeof (struct cgraph_global_info), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_global_info *)(<API key> (sizeof (struct cgraph_global_info), n MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_local_info *)(<API key> (sizeof (struct cgraph_local_info) MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_local_info *)(<API key> (sizeof (struct cgraph_local_info) MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_local_info *)(<API key> (sizeof (struct cgraph_local_info), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_local_info *)(<API key> (sizeof (struct cgraph_local_info), n MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_thunk_info *)(<API key> (sizeof (struct cgraph_thunk_info) MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_thunk_info *)(<API key> (sizeof (struct cgraph_thunk_info) MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_thunk_info *)(<API key> (sizeof (struct cgraph_thunk_info), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_thunk_info *)(<API key> (sizeof (struct cgraph_thunk_info), n MEM_STAT_INFO)))
#define <API key>() ((struct symtab_node_base *)(<API key> (sizeof (struct symtab_node_base) MEM_STAT_INFO)))
#define <API key>() ((struct symtab_node_base *)(<API key> (sizeof (struct symtab_node_base) MEM_STAT_INFO)))
#define <API key>(n) ((struct symtab_node_base *)(<API key> (sizeof (struct symtab_node_base), n MEM_STAT_INFO)))
#define <API key>(n) ((struct symtab_node_base *)(<API key> (sizeof (struct symtab_node_base), n MEM_STAT_INFO)))
#define <API key>() ((struct lto_file_decl_data *)(<API key> (sizeof (struct lto_file_decl_data) MEM_STAT_INFO)))
#define <API key>() ((struct lto_file_decl_data *)(<API key> (sizeof (struct lto_file_decl_data) MEM_STAT_INFO)))
#define <API key>(n) ((struct lto_file_decl_data *)(<API key> (sizeof (struct lto_file_decl_data), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lto_file_decl_data *)(<API key> (sizeof (struct lto_file_decl_data), n MEM_STAT_INFO)))
#define <API key>() ((struct ipa_ref_list *)(<API key> (sizeof (struct ipa_ref_list) MEM_STAT_INFO)))
#define <API key>() ((struct ipa_ref_list *)(<API key> (sizeof (struct ipa_ref_list) MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_ref_list *)(<API key> (sizeof (struct ipa_ref_list), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_ref_list *)(<API key> (sizeof (struct ipa_ref_list), n MEM_STAT_INFO)))
#define <API key>() ((vec<ipa_ref_t,va_gc> *)(<API key> (sizeof (vec<ipa_ref_t,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<ipa_ref_t,va_gc> *)(<API key> (sizeof (vec<ipa_ref_t,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<ipa_ref_t,va_gc> *)(<API key> (sizeof (vec<ipa_ref_t,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<ipa_ref_t,va_gc> *)(<API key> (sizeof (vec<ipa_ref_t,va_gc>), n MEM_STAT_INFO)))
#define ggc_alloc_ipa_ref() ((struct ipa_ref *)(<API key> (sizeof (struct ipa_ref) MEM_STAT_INFO)))
#define <API key>() ((struct ipa_ref *)(<API key> (sizeof (struct ipa_ref) MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_ref *)(<API key> (sizeof (struct ipa_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ipa_ref *)(<API key> (sizeof (struct ipa_ref), n MEM_STAT_INFO)))
#define <API key>() ((union symtab_node_def *)(<API key> (sizeof (union symtab_node_def) MEM_STAT_INFO)))
#define <API key>() ((union symtab_node_def *)(<API key> (sizeof (union symtab_node_def) MEM_STAT_INFO)))
#define <API key>(n) ((union symtab_node_def *)(<API key> (sizeof (union symtab_node_def), n MEM_STAT_INFO)))
#define <API key>(n) ((union symtab_node_def *)(<API key> (sizeof (union symtab_node_def), n MEM_STAT_INFO)))
#define <API key>() ((struct varpool_node *)(<API key> (sizeof (struct varpool_node) MEM_STAT_INFO)))
#define <API key>() ((struct varpool_node *)(<API key> (sizeof (struct varpool_node) MEM_STAT_INFO)))
#define <API key>(n) ((struct varpool_node *)(<API key> (sizeof (struct varpool_node), n MEM_STAT_INFO)))
#define <API key>(n) ((struct varpool_node *)(<API key> (sizeof (struct varpool_node), n MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_node *)(<API key> (sizeof (struct cgraph_node) MEM_STAT_INFO)))
#define <API key>() ((struct cgraph_node *)(<API key> (sizeof (struct cgraph_node) MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_node *)(<API key> (sizeof (struct cgraph_node), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cgraph_node *)(<API key> (sizeof (struct cgraph_node), n MEM_STAT_INFO)))
#define <API key>() ((vec<basic_block,va_gc> *)(<API key> (sizeof (vec<basic_block,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<basic_block,va_gc> *)(<API key> (sizeof (vec<basic_block,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<basic_block,va_gc> *)(<API key> (sizeof (vec<basic_block,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<basic_block,va_gc> *)(<API key> (sizeof (vec<basic_block,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((union <API key> *)(<API key> (sizeof (union <API key>) MEM_STAT_INFO)))
#define <API key>() ((union <API key> *)(<API key> (sizeof (union <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((union <API key> *)(<API key> (sizeof (union <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((union <API key> *)(<API key> (sizeof (union <API key>), n MEM_STAT_INFO)))
#define <API key>() ((vec<edge,va_gc> *)(<API key> (sizeof (vec<edge,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<edge,va_gc> *)(<API key> (sizeof (vec<edge,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<edge,va_gc> *)(<API key> (sizeof (vec<edge,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<edge,va_gc> *)(<API key> (sizeof (vec<edge,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct gimple_bb_info *)(<API key> (sizeof (struct gimple_bb_info) MEM_STAT_INFO)))
#define <API key>() ((struct gimple_bb_info *)(<API key> (sizeof (struct gimple_bb_info) MEM_STAT_INFO)))
#define <API key>(n) ((struct gimple_bb_info *)(<API key> (sizeof (struct gimple_bb_info), n MEM_STAT_INFO)))
#define <API key>(n) ((struct gimple_bb_info *)(<API key> (sizeof (struct gimple_bb_info), n MEM_STAT_INFO)))
#define <API key>() ((struct rtl_bb_info *)(<API key> (sizeof (struct rtl_bb_info) MEM_STAT_INFO)))
#define <API key>() ((struct rtl_bb_info *)(<API key> (sizeof (struct rtl_bb_info) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtl_bb_info *)(<API key> (sizeof (struct rtl_bb_info), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtl_bb_info *)(<API key> (sizeof (struct rtl_bb_info), n MEM_STAT_INFO)))
#define <API key>() ((vec<loop_p,va_gc> *)(<API key> (sizeof (vec<loop_p,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<loop_p,va_gc> *)(<API key> (sizeof (vec<loop_p,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<loop_p,va_gc> *)(<API key> (sizeof (vec<loop_p,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<loop_p,va_gc> *)(<API key> (sizeof (vec<loop_p,va_gc>), n MEM_STAT_INFO)))
#define ggc_alloc_loop() ((struct loop *)(<API key> (sizeof (struct loop) MEM_STAT_INFO)))
#define <API key>() ((struct loop *)(<API key> (sizeof (struct loop) MEM_STAT_INFO)))
#define ggc_alloc_vec_loop(n) ((struct loop *)(<API key> (sizeof (struct loop), n MEM_STAT_INFO)))
#define <API key>(n) ((struct loop *)(<API key> (sizeof (struct loop), n MEM_STAT_INFO)))
#define ggc_alloc_loop_exit() ((struct loop_exit *)(<API key> (sizeof (struct loop_exit) MEM_STAT_INFO)))
#define <API key>() ((struct loop_exit *)(<API key> (sizeof (struct loop_exit) MEM_STAT_INFO)))
#define <API key>(n) ((struct loop_exit *)(<API key> (sizeof (struct loop_exit), n MEM_STAT_INFO)))
#define <API key>(n) ((struct loop_exit *)(<API key> (sizeof (struct loop_exit), n MEM_STAT_INFO)))
#define <API key>() ((struct nb_iter_bound *)(<API key> (sizeof (struct nb_iter_bound) MEM_STAT_INFO)))
#define <API key>() ((struct nb_iter_bound *)(<API key> (sizeof (struct nb_iter_bound) MEM_STAT_INFO)))
#define <API key>(n) ((struct nb_iter_bound *)(<API key> (sizeof (struct nb_iter_bound), n MEM_STAT_INFO)))
#define <API key>(n) ((struct nb_iter_bound *)(<API key> (sizeof (struct nb_iter_bound), n MEM_STAT_INFO)))
#define <API key>() ((struct lpt_decision *)(<API key> (sizeof (struct lpt_decision) MEM_STAT_INFO)))
#define <API key>() ((struct lpt_decision *)(<API key> (sizeof (struct lpt_decision) MEM_STAT_INFO)))
#define <API key>(n) ((struct lpt_decision *)(<API key> (sizeof (struct lpt_decision), n MEM_STAT_INFO)))
#define <API key>(n) ((struct lpt_decision *)(<API key> (sizeof (struct lpt_decision), n MEM_STAT_INFO)))
#define <API key>() ((struct noswitch_section *)(<API key> (sizeof (struct noswitch_section) MEM_STAT_INFO)))
#define <API key>() ((struct noswitch_section *)(<API key> (sizeof (struct noswitch_section) MEM_STAT_INFO)))
#define <API key>(n) ((struct noswitch_section *)(<API key> (sizeof (struct noswitch_section), n MEM_STAT_INFO)))
#define <API key>(n) ((struct noswitch_section *)(<API key> (sizeof (struct noswitch_section), n MEM_STAT_INFO)))
#define <API key>() ((struct unnamed_section *)(<API key> (sizeof (struct unnamed_section) MEM_STAT_INFO)))
#define <API key>() ((struct unnamed_section *)(<API key> (sizeof (struct unnamed_section) MEM_STAT_INFO)))
#define <API key>(n) ((struct unnamed_section *)(<API key> (sizeof (struct unnamed_section), n MEM_STAT_INFO)))
#define <API key>(n) ((struct unnamed_section *)(<API key> (sizeof (struct unnamed_section), n MEM_STAT_INFO)))
#define <API key>() ((struct named_section *)(<API key> (sizeof (struct named_section) MEM_STAT_INFO)))
#define <API key>() ((struct named_section *)(<API key> (sizeof (struct named_section) MEM_STAT_INFO)))
#define <API key>(n) ((struct named_section *)(<API key> (sizeof (struct named_section), n MEM_STAT_INFO)))
#define <API key>(n) ((struct named_section *)(<API key> (sizeof (struct named_section), n MEM_STAT_INFO)))
#define <API key>() ((struct section_common *)(<API key> (sizeof (struct section_common) MEM_STAT_INFO)))
#define <API key>() ((struct section_common *)(<API key> (sizeof (struct section_common) MEM_STAT_INFO)))
#define <API key>(n) ((struct section_common *)(<API key> (sizeof (struct section_common), n MEM_STAT_INFO)))
#define <API key>(n) ((struct section_common *)(<API key> (sizeof (struct section_common), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct language_function *)(<API key> (sizeof (struct language_function) MEM_STAT_INFO)))
#define <API key>() ((struct language_function *)(<API key> (sizeof (struct language_function) MEM_STAT_INFO)))
#define <API key>(n) ((struct language_function *)(<API key> (sizeof (struct language_function), n MEM_STAT_INFO)))
#define <API key>(n) ((struct language_function *)(<API key> (sizeof (struct language_function), n MEM_STAT_INFO)))
#define ggc_alloc_loops() ((struct loops *)(<API key> (sizeof (struct loops) MEM_STAT_INFO)))
#define <API key>() ((struct loops *)(<API key> (sizeof (struct loops) MEM_STAT_INFO)))
#define ggc_alloc_vec_loops(n) ((struct loops *)(<API key> (sizeof (struct loops), n MEM_STAT_INFO)))
#define <API key>(n) ((struct loops *)(<API key> (sizeof (struct loops), n MEM_STAT_INFO)))
#define <API key>() ((struct control_flow_graph *)(<API key> (sizeof (struct control_flow_graph) MEM_STAT_INFO)))
#define <API key>() ((struct control_flow_graph *)(<API key> (sizeof (struct control_flow_graph) MEM_STAT_INFO)))
#define <API key>(n) ((struct control_flow_graph *)(<API key> (sizeof (struct control_flow_graph), n MEM_STAT_INFO)))
#define <API key>(n) ((struct control_flow_graph *)(<API key> (sizeof (struct control_flow_graph), n MEM_STAT_INFO)))
#define ggc_alloc_eh_status() ((struct eh_status *)(<API key> (sizeof (struct eh_status) MEM_STAT_INFO)))
#define <API key>() ((struct eh_status *)(<API key> (sizeof (struct eh_status) MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_status *)(<API key> (sizeof (struct eh_status), n MEM_STAT_INFO)))
#define <API key>(n) ((struct eh_status *)(<API key> (sizeof (struct eh_status), n MEM_STAT_INFO)))
#define <API key>() ((struct stack_usage *)(<API key> (sizeof (struct stack_usage) MEM_STAT_INFO)))
#define <API key>() ((struct stack_usage *)(<API key> (sizeof (struct stack_usage) MEM_STAT_INFO)))
#define <API key>(n) ((struct stack_usage *)(<API key> (sizeof (struct stack_usage), n MEM_STAT_INFO)))
#define <API key>(n) ((struct stack_usage *)(<API key> (sizeof (struct stack_usage), n MEM_STAT_INFO)))
#define ggc_alloc_rtl_data() ((struct rtl_data *)(<API key> (sizeof (struct rtl_data) MEM_STAT_INFO)))
#define <API key>() ((struct rtl_data *)(<API key> (sizeof (struct rtl_data) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtl_data *)(<API key> (sizeof (struct rtl_data), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtl_data *)(<API key> (sizeof (struct rtl_data), n MEM_STAT_INFO)))
#define <API key>() ((vec<temp_slot_p,va_gc> *)(<API key> (sizeof (vec<temp_slot_p,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<temp_slot_p,va_gc> *)(<API key> (sizeof (vec<temp_slot_p,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<temp_slot_p,va_gc> *)(<API key> (sizeof (vec<temp_slot_p,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<temp_slot_p,va_gc> *)(<API key> (sizeof (vec<temp_slot_p,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct frame_space *)(<API key> (sizeof (struct frame_space) MEM_STAT_INFO)))
#define <API key>() ((struct frame_space *)(<API key> (sizeof (struct frame_space) MEM_STAT_INFO)))
#define <API key>(n) ((struct frame_space *)(<API key> (sizeof (struct frame_space), n MEM_STAT_INFO)))
#define <API key>(n) ((struct frame_space *)(<API key> (sizeof (struct frame_space), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct incoming_args *)(<API key> (sizeof (struct incoming_args) MEM_STAT_INFO)))
#define <API key>() ((struct incoming_args *)(<API key> (sizeof (struct incoming_args) MEM_STAT_INFO)))
#define <API key>(n) ((struct incoming_args *)(<API key> (sizeof (struct incoming_args), n MEM_STAT_INFO)))
#define <API key>(n) ((struct incoming_args *)(<API key> (sizeof (struct incoming_args), n MEM_STAT_INFO)))
#define <API key>() ((struct varasm_status *)(<API key> (sizeof (struct varasm_status) MEM_STAT_INFO)))
#define <API key>() ((struct varasm_status *)(<API key> (sizeof (struct varasm_status) MEM_STAT_INFO)))
#define <API key>(n) ((struct varasm_status *)(<API key> (sizeof (struct varasm_status), n MEM_STAT_INFO)))
#define <API key>(n) ((struct varasm_status *)(<API key> (sizeof (struct varasm_status), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_constant_pool *)(<API key> (sizeof (struct rtx_constant_pool) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_constant_pool *)(<API key> (sizeof (struct rtx_constant_pool) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_constant_pool *)(<API key> (sizeof (struct rtx_constant_pool), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_constant_pool *)(<API key> (sizeof (struct rtx_constant_pool), n MEM_STAT_INFO)))
#define <API key>() ((struct dw_fde_struct *)(<API key> (sizeof (struct dw_fde_struct) MEM_STAT_INFO)))
#define <API key>() ((struct dw_fde_struct *)(<API key> (sizeof (struct dw_fde_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_fde_struct *)(<API key> (sizeof (struct dw_fde_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct dw_fde_struct *)(<API key> (sizeof (struct dw_fde_struct), n MEM_STAT_INFO)))
#define ggc_alloc_temp_slot() ((struct temp_slot *)(<API key> (sizeof (struct temp_slot) MEM_STAT_INFO)))
#define <API key>() ((struct temp_slot *)(<API key> (sizeof (struct temp_slot) MEM_STAT_INFO)))
#define <API key>(n) ((struct temp_slot *)(<API key> (sizeof (struct temp_slot), n MEM_STAT_INFO)))
#define <API key>(n) ((struct temp_slot *)(<API key> (sizeof (struct temp_slot), n MEM_STAT_INFO)))
#define ggc_alloc_gimple_df() ((struct gimple_df *)(<API key> (sizeof (struct gimple_df) MEM_STAT_INFO)))
#define <API key>() ((struct gimple_df *)(<API key> (sizeof (struct gimple_df) MEM_STAT_INFO)))
#define <API key>(n) ((struct gimple_df *)(<API key> (sizeof (struct gimple_df), n MEM_STAT_INFO)))
#define <API key>(n) ((struct gimple_df *)(<API key> (sizeof (struct gimple_df), n MEM_STAT_INFO)))
#define ggc_alloc_rtl_eh() ((struct rtl_eh *)(<API key> (sizeof (struct rtl_eh) MEM_STAT_INFO)))
#define <API key>() ((struct rtl_eh *)(<API key> (sizeof (struct rtl_eh) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtl_eh *)(<API key> (sizeof (struct rtl_eh), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtl_eh *)(<API key> (sizeof (struct rtl_eh), n MEM_STAT_INFO)))
#define <API key>() ((vec<call_site_record,va_gc> *)(<API key> (sizeof (vec<call_site_record,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<call_site_record,va_gc> *)(<API key> (sizeof (vec<call_site_record,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<call_site_record,va_gc> *)(<API key> (sizeof (vec<call_site_record,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<call_site_record,va_gc> *)(<API key> (sizeof (vec<call_site_record,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((vec<uchar,va_gc> *)(<API key> (sizeof (vec<uchar,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<uchar,va_gc> *)(<API key> (sizeof (vec<uchar,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<uchar,va_gc> *)(<API key> (sizeof (vec<uchar,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<uchar,va_gc> *)(<API key> (sizeof (vec<uchar,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct call_site_record_d *)(<API key> (sizeof (struct call_site_record_d) MEM_STAT_INFO)))
#define <API key>() ((struct call_site_record_d *)(<API key> (sizeof (struct call_site_record_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct call_site_record_d *)(<API key> (sizeof (struct call_site_record_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct call_site_record_d *)(<API key> (sizeof (struct call_site_record_d), n MEM_STAT_INFO)))
#define <API key>() ((struct expr_status *)(<API key> (sizeof (struct expr_status) MEM_STAT_INFO)))
#define <API key>() ((struct expr_status *)(<API key> (sizeof (struct expr_status) MEM_STAT_INFO)))
#define <API key>(n) ((struct expr_status *)(<API key> (sizeof (struct expr_status), n MEM_STAT_INFO)))
#define <API key>(n) ((struct expr_status *)(<API key> (sizeof (struct expr_status), n MEM_STAT_INFO)))
#define <API key>() ((struct emit_status *)(<API key> (sizeof (struct emit_status) MEM_STAT_INFO)))
#define <API key>() ((struct emit_status *)(<API key> (sizeof (struct emit_status) MEM_STAT_INFO)))
#define <API key>(n) ((struct emit_status *)(<API key> (sizeof (struct emit_status), n MEM_STAT_INFO)))
#define <API key>(n) ((struct emit_status *)(<API key> (sizeof (struct emit_status), n MEM_STAT_INFO)))
#define <API key>() ((struct sequence_stack *)(<API key> (sizeof (struct sequence_stack) MEM_STAT_INFO)))
#define <API key>() ((struct sequence_stack *)(<API key> (sizeof (struct sequence_stack) MEM_STAT_INFO)))
#define <API key>(n) ((struct sequence_stack *)(<API key> (sizeof (struct sequence_stack), n MEM_STAT_INFO)))
#define <API key>(n) ((struct sequence_stack *)(<API key> (sizeof (struct sequence_stack), n MEM_STAT_INFO)))
#define <API key>() ((struct target_libfuncs *)(<API key> (sizeof (struct target_libfuncs) MEM_STAT_INFO)))
#define <API key>() ((struct target_libfuncs *)(<API key> (sizeof (struct target_libfuncs) MEM_STAT_INFO)))
#define <API key>(n) ((struct target_libfuncs *)(<API key> (sizeof (struct target_libfuncs), n MEM_STAT_INFO)))
#define <API key>(n) ((struct target_libfuncs *)(<API key> (sizeof (struct target_libfuncs), n MEM_STAT_INFO)))
#define <API key>() ((struct libfunc_entry *)(<API key> (sizeof (struct libfunc_entry) MEM_STAT_INFO)))
#define <API key>() ((struct libfunc_entry *)(<API key> (sizeof (struct libfunc_entry) MEM_STAT_INFO)))
#define <API key>(n) ((struct libfunc_entry *)(<API key> (sizeof (struct libfunc_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((struct libfunc_entry *)(<API key> (sizeof (struct libfunc_entry), n MEM_STAT_INFO)))
#define <API key>() ((struct builtin_info_type_d *)(<API key> (sizeof (struct builtin_info_type_d) MEM_STAT_INFO)))
#define <API key>() ((struct builtin_info_type_d *)(<API key> (sizeof (struct builtin_info_type_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct builtin_info_type_d *)(<API key> (sizeof (struct builtin_info_type_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct builtin_info_type_d *)(<API key> (sizeof (struct builtin_info_type_d), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_vec_map *)(<API key> (sizeof (struct tree_vec_map) MEM_STAT_INFO)))
#define <API key>() ((struct tree_vec_map *)(<API key> (sizeof (struct tree_vec_map) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_vec_map *)(<API key> (sizeof (struct tree_vec_map), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_vec_map *)(<API key> (sizeof (struct tree_vec_map), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_priority_map *)(<API key> (sizeof (struct tree_priority_map) MEM_STAT_INFO)))
#define <API key>() ((struct tree_priority_map *)(<API key> (sizeof (struct tree_priority_map) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_priority_map *)(<API key> (sizeof (struct tree_priority_map), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_priority_map *)(<API key> (sizeof (struct tree_priority_map), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_int_map *)(<API key> (sizeof (struct tree_int_map) MEM_STAT_INFO)))
#define <API key>() ((struct tree_int_map *)(<API key> (sizeof (struct tree_int_map) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_int_map *)(<API key> (sizeof (struct tree_int_map), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_int_map *)(<API key> (sizeof (struct tree_int_map), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_decl_map *)(<API key> (sizeof (struct tree_decl_map) MEM_STAT_INFO)))
#define <API key>() ((struct tree_decl_map *)(<API key> (sizeof (struct tree_decl_map) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_decl_map *)(<API key> (sizeof (struct tree_decl_map), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_decl_map *)(<API key> (sizeof (struct tree_decl_map), n MEM_STAT_INFO)))
#define ggc_alloc_tree_map() ((struct tree_map *)(<API key> (sizeof (struct tree_map) MEM_STAT_INFO)))
#define <API key>() ((struct tree_map *)(<API key> (sizeof (struct tree_map) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_map *)(<API key> (sizeof (struct tree_map), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_map *)(<API key> (sizeof (struct tree_map), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_map_base *)(<API key> (sizeof (struct tree_map_base) MEM_STAT_INFO)))
#define <API key>() ((struct tree_map_base *)(<API key> (sizeof (struct tree_map_base) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_map_base *)(<API key> (sizeof (struct tree_map_base), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_map_base *)(<API key> (sizeof (struct tree_map_base), n MEM_STAT_INFO)))
#define <API key>() ((union lang_tree_node *)(<API key> (sizeof (union lang_tree_node) MEM_STAT_INFO)))
#define <API key>() ((union lang_tree_node *)(<API key> (sizeof (union lang_tree_node) MEM_STAT_INFO)))
#define <API key>(n) ((union lang_tree_node *)(<API key> (sizeof (union lang_tree_node), n MEM_STAT_INFO)))
#define <API key>(n) ((union lang_tree_node *)(<API key> (sizeof (union lang_tree_node), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_target_option *)(<API key> (sizeof (struct tree_target_option) MEM_STAT_INFO)))
#define <API key>() ((struct tree_target_option *)(<API key> (sizeof (struct tree_target_option) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_target_option *)(<API key> (sizeof (struct tree_target_option), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_target_option *)(<API key> (sizeof (struct tree_target_option), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_statement_list *)(<API key> (sizeof (struct tree_statement_list) MEM_STAT_INFO)))
#define <API key>() ((struct tree_statement_list *)(<API key> (sizeof (struct tree_statement_list) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_statement_list *)(<API key> (sizeof (struct tree_statement_list), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_statement_list *)(<API key> (sizeof (struct tree_statement_list), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_type_decl *)(<API key> (sizeof (struct tree_type_decl) MEM_STAT_INFO)))
#define <API key>() ((struct tree_type_decl *)(<API key> (sizeof (struct tree_type_decl) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_type_decl *)(<API key> (sizeof (struct tree_type_decl), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_type_decl *)(<API key> (sizeof (struct tree_type_decl), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_function_decl *)(<API key> (sizeof (struct tree_function_decl) MEM_STAT_INFO)))
#define <API key>() ((struct tree_function_decl *)(<API key> (sizeof (struct tree_function_decl) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_function_decl *)(<API key> (sizeof (struct tree_function_decl), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_function_decl *)(<API key> (sizeof (struct tree_function_decl), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_var_decl *)(<API key> (sizeof (struct tree_var_decl) MEM_STAT_INFO)))
#define <API key>() ((struct tree_var_decl *)(<API key> (sizeof (struct tree_var_decl) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_var_decl *)(<API key> (sizeof (struct tree_var_decl), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_var_decl *)(<API key> (sizeof (struct tree_var_decl), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_decl_with_vis *)(<API key> (sizeof (struct tree_decl_with_vis) MEM_STAT_INFO)))
#define <API key>() ((struct tree_decl_with_vis *)(<API key> (sizeof (struct tree_decl_with_vis) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_decl_with_vis *)(<API key> (sizeof (struct tree_decl_with_vis), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_decl_with_vis *)(<API key> (sizeof (struct tree_decl_with_vis), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_parm_decl *)(<API key> (sizeof (struct tree_parm_decl) MEM_STAT_INFO)))
#define <API key>() ((struct tree_parm_decl *)(<API key> (sizeof (struct tree_parm_decl) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_parm_decl *)(<API key> (sizeof (struct tree_parm_decl), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_parm_decl *)(<API key> (sizeof (struct tree_parm_decl), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_const_decl *)(<API key> (sizeof (struct tree_const_decl) MEM_STAT_INFO)))
#define <API key>() ((struct tree_const_decl *)(<API key> (sizeof (struct tree_const_decl) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_const_decl *)(<API key> (sizeof (struct tree_const_decl), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_const_decl *)(<API key> (sizeof (struct tree_const_decl), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_result_decl *)(<API key> (sizeof (struct tree_result_decl) MEM_STAT_INFO)))
#define <API key>() ((struct tree_result_decl *)(<API key> (sizeof (struct tree_result_decl) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_result_decl *)(<API key> (sizeof (struct tree_result_decl), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_result_decl *)(<API key> (sizeof (struct tree_result_decl), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_label_decl *)(<API key> (sizeof (struct tree_label_decl) MEM_STAT_INFO)))
#define <API key>() ((struct tree_label_decl *)(<API key> (sizeof (struct tree_label_decl) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_label_decl *)(<API key> (sizeof (struct tree_label_decl), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_label_decl *)(<API key> (sizeof (struct tree_label_decl), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_field_decl *)(<API key> (sizeof (struct tree_field_decl) MEM_STAT_INFO)))
#define <API key>() ((struct tree_field_decl *)(<API key> (sizeof (struct tree_field_decl) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_field_decl *)(<API key> (sizeof (struct tree_field_decl), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_field_decl *)(<API key> (sizeof (struct tree_field_decl), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_decl_with_rtl *)(<API key> (sizeof (struct tree_decl_with_rtl) MEM_STAT_INFO)))
#define <API key>() ((struct tree_decl_with_rtl *)(<API key> (sizeof (struct tree_decl_with_rtl) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_decl_with_rtl *)(<API key> (sizeof (struct tree_decl_with_rtl), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_decl_with_rtl *)(<API key> (sizeof (struct tree_decl_with_rtl), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_decl_common *)(<API key> (sizeof (struct tree_decl_common) MEM_STAT_INFO)))
#define <API key>() ((struct tree_decl_common *)(<API key> (sizeof (struct tree_decl_common) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_decl_common *)(<API key> (sizeof (struct tree_decl_common), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_decl_common *)(<API key> (sizeof (struct tree_decl_common), n MEM_STAT_INFO)))
#define ggc_alloc_lang_decl(SIZE) ((struct lang_decl *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE) ((struct lang_decl *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct lang_decl *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct lang_decl *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>() ((struct tree_decl_minimal *)(<API key> (sizeof (struct tree_decl_minimal) MEM_STAT_INFO)))
#define <API key>() ((struct tree_decl_minimal *)(<API key> (sizeof (struct tree_decl_minimal) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_decl_minimal *)(<API key> (sizeof (struct tree_decl_minimal), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_decl_minimal *)(<API key> (sizeof (struct tree_decl_minimal), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_binfo *)(<API key> (sizeof (struct tree_binfo) MEM_STAT_INFO)))
#define <API key>() ((struct tree_binfo *)(<API key> (sizeof (struct tree_binfo) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_binfo *)(<API key> (sizeof (struct tree_binfo), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_binfo *)(<API key> (sizeof (struct tree_binfo), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define ggc_alloc_lang_type(SIZE) ((struct lang_type *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE) ((struct lang_type *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct lang_type *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct lang_type *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>() ((struct tree_type_common *)(<API key> (sizeof (struct tree_type_common) MEM_STAT_INFO)))
#define <API key>() ((struct tree_type_common *)(<API key> (sizeof (struct tree_type_common) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_type_common *)(<API key> (sizeof (struct tree_type_common), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_type_common *)(<API key> (sizeof (struct tree_type_common), n MEM_STAT_INFO)))
#define <API key>() ((union tree_type_symtab *)(<API key> (sizeof (union tree_type_symtab) MEM_STAT_INFO)))
#define <API key>() ((union tree_type_symtab *)(<API key> (sizeof (union tree_type_symtab) MEM_STAT_INFO)))
#define <API key>(n) ((union tree_type_symtab *)(<API key> (sizeof (union tree_type_symtab), n MEM_STAT_INFO)))
#define <API key>(n) ((union tree_type_symtab *)(<API key> (sizeof (union tree_type_symtab), n MEM_STAT_INFO)))
#define <API key>() ((struct die_struct *)(<API key> (sizeof (struct die_struct) MEM_STAT_INFO)))
#define <API key>() ((struct die_struct *)(<API key> (sizeof (struct die_struct) MEM_STAT_INFO)))
#define <API key>(n) ((struct die_struct *)(<API key> (sizeof (struct die_struct), n MEM_STAT_INFO)))
#define <API key>(n) ((struct die_struct *)(<API key> (sizeof (struct die_struct), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_block *)(<API key> (sizeof (struct tree_block) MEM_STAT_INFO)))
#define <API key>() ((struct tree_block *)(<API key> (sizeof (struct tree_block) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_block *)(<API key> (sizeof (struct tree_block), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_block *)(<API key> (sizeof (struct tree_block), n MEM_STAT_INFO)))
#define <API key>() ((vec<tree,va_gc> *)(<API key> (sizeof (vec<tree,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<tree,va_gc> *)(<API key> (sizeof (vec<tree,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<tree,va_gc> *)(<API key> (sizeof (vec<tree,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<tree,va_gc> *)(<API key> (sizeof (vec<tree,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_omp_clause *)(<API key> (sizeof (struct tree_omp_clause) MEM_STAT_INFO)))
#define <API key>() ((struct tree_omp_clause *)(<API key> (sizeof (struct tree_omp_clause) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_omp_clause *)(<API key> (sizeof (struct tree_omp_clause), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_omp_clause *)(<API key> (sizeof (struct tree_omp_clause), n MEM_STAT_INFO)))
#define ggc_alloc_phi_arg_d() ((struct phi_arg_d *)(<API key> (sizeof (struct phi_arg_d) MEM_STAT_INFO)))
#define <API key>() ((struct phi_arg_d *)(<API key> (sizeof (struct phi_arg_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct phi_arg_d *)(<API key> (sizeof (struct phi_arg_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct phi_arg_d *)(<API key> (sizeof (struct phi_arg_d), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_ssa_name *)(<API key> (sizeof (struct tree_ssa_name) MEM_STAT_INFO)))
#define <API key>() ((struct tree_ssa_name *)(<API key> (sizeof (struct tree_ssa_name) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_ssa_name *)(<API key> (sizeof (struct tree_ssa_name), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_ssa_name *)(<API key> (sizeof (struct tree_ssa_name), n MEM_STAT_INFO)))
#define <API key>() ((struct ssa_use_operand_d *)(<API key> (sizeof (struct ssa_use_operand_d) MEM_STAT_INFO)))
#define <API key>() ((struct ssa_use_operand_d *)(<API key> (sizeof (struct ssa_use_operand_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct ssa_use_operand_d *)(<API key> (sizeof (struct ssa_use_operand_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ssa_use_operand_d *)(<API key> (sizeof (struct ssa_use_operand_d), n MEM_STAT_INFO)))
#define <API key>() ((struct ptr_info_def *)(<API key> (sizeof (struct ptr_info_def) MEM_STAT_INFO)))
#define <API key>() ((struct ptr_info_def *)(<API key> (sizeof (struct ptr_info_def) MEM_STAT_INFO)))
#define <API key>(n) ((struct ptr_info_def *)(<API key> (sizeof (struct ptr_info_def), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ptr_info_def *)(<API key> (sizeof (struct ptr_info_def), n MEM_STAT_INFO)))
#define ggc_alloc_tree_exp() ((struct tree_exp *)(<API key> (sizeof (struct tree_exp) MEM_STAT_INFO)))
#define <API key>() ((struct tree_exp *)(<API key> (sizeof (struct tree_exp) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_exp *)(<API key> (sizeof (struct tree_exp), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_exp *)(<API key> (sizeof (struct tree_exp), n MEM_STAT_INFO)))
#define <API key>() ((union tree_exp_subunion *)(<API key> (sizeof (union tree_exp_subunion) MEM_STAT_INFO)))
#define <API key>() ((union tree_exp_subunion *)(<API key> (sizeof (union tree_exp_subunion) MEM_STAT_INFO)))
#define <API key>(n) ((union tree_exp_subunion *)(<API key> (sizeof (union tree_exp_subunion), n MEM_STAT_INFO)))
#define <API key>(n) ((union tree_exp_subunion *)(<API key> (sizeof (union tree_exp_subunion), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_constructor *)(<API key> (sizeof (struct tree_constructor) MEM_STAT_INFO)))
#define <API key>() ((struct tree_constructor *)(<API key> (sizeof (struct tree_constructor) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_constructor *)(<API key> (sizeof (struct tree_constructor), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_constructor *)(<API key> (sizeof (struct tree_constructor), n MEM_STAT_INFO)))
#define <API key>() ((vec<constructor_elt,va_gc> *)(<API key> (sizeof (vec<constructor_elt,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<constructor_elt,va_gc> *)(<API key> (sizeof (vec<constructor_elt,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<constructor_elt,va_gc> *)(<API key> (sizeof (vec<constructor_elt,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<constructor_elt,va_gc> *)(<API key> (sizeof (vec<constructor_elt,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct constructor_elt_d *)(<API key> (sizeof (struct constructor_elt_d) MEM_STAT_INFO)))
#define <API key>() ((struct constructor_elt_d *)(<API key> (sizeof (struct constructor_elt_d) MEM_STAT_INFO)))
#define <API key>(n) ((struct constructor_elt_d *)(<API key> (sizeof (struct constructor_elt_d), n MEM_STAT_INFO)))
#define <API key>(n) ((struct constructor_elt_d *)(<API key> (sizeof (struct constructor_elt_d), n MEM_STAT_INFO)))
#define ggc_alloc_tree_vec() ((struct tree_vec *)(<API key> (sizeof (struct tree_vec) MEM_STAT_INFO)))
#define <API key>() ((struct tree_vec *)(<API key> (sizeof (struct tree_vec) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_vec *)(<API key> (sizeof (struct tree_vec), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_vec *)(<API key> (sizeof (struct tree_vec), n MEM_STAT_INFO)))
#define ggc_alloc_tree_list() ((struct tree_list *)(<API key> (sizeof (struct tree_list) MEM_STAT_INFO)))
#define <API key>() ((struct tree_list *)(<API key> (sizeof (struct tree_list) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_list *)(<API key> (sizeof (struct tree_list), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_list *)(<API key> (sizeof (struct tree_list), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_identifier *)(<API key> (sizeof (struct tree_identifier) MEM_STAT_INFO)))
#define <API key>() ((struct tree_identifier *)(<API key> (sizeof (struct tree_identifier) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_identifier *)(<API key> (sizeof (struct tree_identifier), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_identifier *)(<API key> (sizeof (struct tree_identifier), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_vector *)(<API key> (sizeof (struct tree_vector) MEM_STAT_INFO)))
#define <API key>() ((struct tree_vector *)(<API key> (sizeof (struct tree_vector) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_vector *)(<API key> (sizeof (struct tree_vector), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_vector *)(<API key> (sizeof (struct tree_vector), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_complex *)(<API key> (sizeof (struct tree_complex) MEM_STAT_INFO)))
#define <API key>() ((struct tree_complex *)(<API key> (sizeof (struct tree_complex) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_complex *)(<API key> (sizeof (struct tree_complex), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_complex *)(<API key> (sizeof (struct tree_complex), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_string *)(<API key> (sizeof (struct tree_string) MEM_STAT_INFO)))
#define <API key>() ((struct tree_string *)(<API key> (sizeof (struct tree_string) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_string *)(<API key> (sizeof (struct tree_string), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_string *)(<API key> (sizeof (struct tree_string), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_fixed_cst *)(<API key> (sizeof (struct tree_fixed_cst) MEM_STAT_INFO)))
#define <API key>() ((struct tree_fixed_cst *)(<API key> (sizeof (struct tree_fixed_cst) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_fixed_cst *)(<API key> (sizeof (struct tree_fixed_cst), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_fixed_cst *)(<API key> (sizeof (struct tree_fixed_cst), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_real_cst *)(<API key> (sizeof (struct tree_real_cst) MEM_STAT_INFO)))
#define <API key>() ((struct tree_real_cst *)(<API key> (sizeof (struct tree_real_cst) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_real_cst *)(<API key> (sizeof (struct tree_real_cst), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_real_cst *)(<API key> (sizeof (struct tree_real_cst), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_int_cst *)(<API key> (sizeof (struct tree_int_cst) MEM_STAT_INFO)))
#define <API key>() ((struct tree_int_cst *)(<API key> (sizeof (struct tree_int_cst) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_int_cst *)(<API key> (sizeof (struct tree_int_cst), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_int_cst *)(<API key> (sizeof (struct tree_int_cst), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_common *)(<API key> (sizeof (struct tree_common) MEM_STAT_INFO)))
#define <API key>() ((struct tree_common *)(<API key> (sizeof (struct tree_common) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_common *)(<API key> (sizeof (struct tree_common), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_common *)(<API key> (sizeof (struct tree_common), n MEM_STAT_INFO)))
#define <API key>() ((struct tree_typed *)(<API key> (sizeof (struct tree_typed) MEM_STAT_INFO)))
#define <API key>() ((struct tree_typed *)(<API key> (sizeof (struct tree_typed) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_typed *)(<API key> (sizeof (struct tree_typed), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_typed *)(<API key> (sizeof (struct tree_typed), n MEM_STAT_INFO)))
#define ggc_alloc_tree_base() ((struct tree_base *)(<API key> (sizeof (struct tree_base) MEM_STAT_INFO)))
#define <API key>() ((struct tree_base *)(<API key> (sizeof (struct tree_base) MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_base *)(<API key> (sizeof (struct tree_base), n MEM_STAT_INFO)))
#define <API key>(n) ((struct tree_base *)(<API key> (sizeof (struct tree_base), n MEM_STAT_INFO)))
#define <API key>() ((vec<alias_pair,va_gc> *)(<API key> (sizeof (vec<alias_pair,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<alias_pair,va_gc> *)(<API key> (sizeof (vec<alias_pair,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<alias_pair,va_gc> *)(<API key> (sizeof (vec<alias_pair,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<alias_pair,va_gc> *)(<API key> (sizeof (vec<alias_pair,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct alias_pair *)(<API key> (sizeof (struct alias_pair) MEM_STAT_INFO)))
#define <API key>() ((struct alias_pair *)(<API key> (sizeof (struct alias_pair) MEM_STAT_INFO)))
#define <API key>(n) ((struct alias_pair *)(<API key> (sizeof (struct alias_pair), n MEM_STAT_INFO)))
#define <API key>(n) ((struct alias_pair *)(<API key> (sizeof (struct alias_pair), n MEM_STAT_INFO)))
#define <API key>() ((struct target_rtl *)(<API key> (sizeof (struct target_rtl) MEM_STAT_INFO)))
#define <API key>() ((struct target_rtl *)(<API key> (sizeof (struct target_rtl) MEM_STAT_INFO)))
#define <API key>(n) ((struct target_rtl *)(<API key> (sizeof (struct target_rtl), n MEM_STAT_INFO)))
#define <API key>(n) ((struct target_rtl *)(<API key> (sizeof (struct target_rtl), n MEM_STAT_INFO)))
#define ggc_alloc_function() ((struct function *)(<API key> (sizeof (struct function) MEM_STAT_INFO)))
#define <API key>() ((struct function *)(<API key> (sizeof (struct function) MEM_STAT_INFO)))
#define <API key>(n) ((struct function *)(<API key> (sizeof (struct function), n MEM_STAT_INFO)))
#define <API key>(n) ((struct function *)(<API key> (sizeof (struct function), n MEM_STAT_INFO)))
#define <API key>() ((union rtx_def_subunion *)(<API key> (sizeof (union rtx_def_subunion) MEM_STAT_INFO)))
#define <API key>() ((union rtx_def_subunion *)(<API key> (sizeof (union rtx_def_subunion) MEM_STAT_INFO)))
#define <API key>(n) ((union rtx_def_subunion *)(<API key> (sizeof (union rtx_def_subunion), n MEM_STAT_INFO)))
#define <API key>(n) ((union rtx_def_subunion *)(<API key> (sizeof (union rtx_def_subunion), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_entry_value *)(<API key> (sizeof (struct rtx_def_entry_value) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_entry_value *)(<API key> (sizeof (struct rtx_def_entry_value) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_entry_value *)(<API key> (sizeof (struct rtx_def_entry_value), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_entry_value *)(<API key> (sizeof (struct rtx_def_entry_value), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_fma *)(<API key> (sizeof (struct rtx_def_fma) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_fma *)(<API key> (sizeof (struct rtx_def_fma) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_fma *)(<API key> (sizeof (struct rtx_def_fma), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_fma *)(<API key> (sizeof (struct rtx_def_fma), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_truncate *)(<API key> (sizeof (struct rtx_def_us_truncate) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_truncate *)(<API key> (sizeof (struct rtx_def_us_truncate) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_truncate *)(<API key> (sizeof (struct rtx_def_us_truncate), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_truncate *)(<API key> (sizeof (struct rtx_def_us_truncate), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_truncate *)(<API key> (sizeof (struct rtx_def_ss_truncate) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_truncate *)(<API key> (sizeof (struct rtx_def_ss_truncate) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_truncate *)(<API key> (sizeof (struct rtx_def_ss_truncate), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_truncate *)(<API key> (sizeof (struct rtx_def_ss_truncate), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_minus *)(<API key> (sizeof (struct rtx_def_us_minus) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_minus *)(<API key> (sizeof (struct rtx_def_us_minus) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_minus *)(<API key> (sizeof (struct rtx_def_us_minus), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_minus *)(<API key> (sizeof (struct rtx_def_us_minus), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_ashift *)(<API key> (sizeof (struct rtx_def_us_ashift) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_ashift *)(<API key> (sizeof (struct rtx_def_us_ashift) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_ashift *)(<API key> (sizeof (struct rtx_def_us_ashift), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_ashift *)(<API key> (sizeof (struct rtx_def_us_ashift), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_ashift *)(<API key> (sizeof (struct rtx_def_ss_ashift) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_ashift *)(<API key> (sizeof (struct rtx_def_ss_ashift) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_ashift *)(<API key> (sizeof (struct rtx_def_ss_ashift), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_ashift *)(<API key> (sizeof (struct rtx_def_ss_ashift), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_abs *)(<API key> (sizeof (struct rtx_def_ss_abs) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_abs *)(<API key> (sizeof (struct rtx_def_ss_abs) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_abs *)(<API key> (sizeof (struct rtx_def_ss_abs), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_abs *)(<API key> (sizeof (struct rtx_def_ss_abs), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_neg *)(<API key> (sizeof (struct rtx_def_us_neg) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_neg *)(<API key> (sizeof (struct rtx_def_us_neg) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_neg *)(<API key> (sizeof (struct rtx_def_us_neg), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_neg *)(<API key> (sizeof (struct rtx_def_us_neg), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_neg *)(<API key> (sizeof (struct rtx_def_ss_neg) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_neg *)(<API key> (sizeof (struct rtx_def_ss_neg) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_neg *)(<API key> (sizeof (struct rtx_def_ss_neg), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_neg *)(<API key> (sizeof (struct rtx_def_ss_neg), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_minus *)(<API key> (sizeof (struct rtx_def_ss_minus) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_minus *)(<API key> (sizeof (struct rtx_def_ss_minus) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_minus *)(<API key> (sizeof (struct rtx_def_ss_minus), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_minus *)(<API key> (sizeof (struct rtx_def_ss_minus), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_plus *)(<API key> (sizeof (struct rtx_def_us_plus) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_plus *)(<API key> (sizeof (struct rtx_def_us_plus) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_plus *)(<API key> (sizeof (struct rtx_def_us_plus), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_plus *)(<API key> (sizeof (struct rtx_def_us_plus), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_plus *)(<API key> (sizeof (struct rtx_def_ss_plus) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_plus *)(<API key> (sizeof (struct rtx_def_ss_plus) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_plus *)(<API key> (sizeof (struct rtx_def_ss_plus), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_plus *)(<API key> (sizeof (struct rtx_def_ss_plus), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_vec_concat *)(<API key> (sizeof (struct rtx_def_vec_concat) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_vec_concat *)(<API key> (sizeof (struct rtx_def_vec_concat) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_vec_concat *)(<API key> (sizeof (struct rtx_def_vec_concat), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_vec_concat *)(<API key> (sizeof (struct rtx_def_vec_concat), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_vec_select *)(<API key> (sizeof (struct rtx_def_vec_select) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_vec_select *)(<API key> (sizeof (struct rtx_def_vec_select) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_vec_select *)(<API key> (sizeof (struct rtx_def_vec_select), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_vec_select *)(<API key> (sizeof (struct rtx_def_vec_select), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_vec_merge *)(<API key> (sizeof (struct rtx_def_vec_merge) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_vec_merge *)(<API key> (sizeof (struct rtx_def_vec_merge) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_vec_merge *)(<API key> (sizeof (struct rtx_def_vec_merge), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_vec_merge *)(<API key> (sizeof (struct rtx_def_vec_merge), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_lo_sum *)(<API key> (sizeof (struct rtx_def_lo_sum) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_lo_sum *)(<API key> (sizeof (struct rtx_def_lo_sum) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_lo_sum *)(<API key> (sizeof (struct rtx_def_lo_sum), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_lo_sum *)(<API key> (sizeof (struct rtx_def_lo_sum), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_high *)(<API key> (sizeof (struct rtx_def_high) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_high *)(<API key> (sizeof (struct rtx_def_high) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_high *)(<API key> (sizeof (struct rtx_def_high), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_high *)(<API key> (sizeof (struct rtx_def_high), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_parity *)(<API key> (sizeof (struct rtx_def_parity) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_parity *)(<API key> (sizeof (struct rtx_def_parity) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_parity *)(<API key> (sizeof (struct rtx_def_parity), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_parity *)(<API key> (sizeof (struct rtx_def_parity), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_popcount *)(<API key> (sizeof (struct rtx_def_popcount) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_popcount *)(<API key> (sizeof (struct rtx_def_popcount) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_popcount *)(<API key> (sizeof (struct rtx_def_popcount), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_popcount *)(<API key> (sizeof (struct rtx_def_popcount), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ctz *)(<API key> (sizeof (struct rtx_def_ctz) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ctz *)(<API key> (sizeof (struct rtx_def_ctz) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ctz *)(<API key> (sizeof (struct rtx_def_ctz), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ctz *)(<API key> (sizeof (struct rtx_def_ctz), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_clz *)(<API key> (sizeof (struct rtx_def_clz) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_clz *)(<API key> (sizeof (struct rtx_def_clz) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_clz *)(<API key> (sizeof (struct rtx_def_clz), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_clz *)(<API key> (sizeof (struct rtx_def_clz), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_clrsb *)(<API key> (sizeof (struct rtx_def_clrsb) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_clrsb *)(<API key> (sizeof (struct rtx_def_clrsb) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_clrsb *)(<API key> (sizeof (struct rtx_def_clrsb), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_clrsb *)(<API key> (sizeof (struct rtx_def_clrsb), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ffs *)(<API key> (sizeof (struct rtx_def_ffs) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ffs *)(<API key> (sizeof (struct rtx_def_ffs) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ffs *)(<API key> (sizeof (struct rtx_def_ffs), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ffs *)(<API key> (sizeof (struct rtx_def_ffs), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_bswap *)(<API key> (sizeof (struct rtx_def_bswap) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_bswap *)(<API key> (sizeof (struct rtx_def_bswap) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_bswap *)(<API key> (sizeof (struct rtx_def_bswap), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_bswap *)(<API key> (sizeof (struct rtx_def_bswap), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_sqrt *)(<API key> (sizeof (struct rtx_def_sqrt) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_sqrt *)(<API key> (sizeof (struct rtx_def_sqrt) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_sqrt *)(<API key> (sizeof (struct rtx_def_sqrt), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_sqrt *)(<API key> (sizeof (struct rtx_def_sqrt), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_abs *)(<API key> (sizeof (struct rtx_def_abs) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_abs *)(<API key> (sizeof (struct rtx_def_abs) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_abs *)(<API key> (sizeof (struct rtx_def_abs), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_abs *)(<API key> (sizeof (struct rtx_def_abs), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_sat_fract *)(<API key> (sizeof (struct rtx_def_sat_fract) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_sat_fract *)(<API key> (sizeof (struct rtx_def_sat_fract) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_sat_fract *)(<API key> (sizeof (struct rtx_def_sat_fract), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_sat_fract *)(<API key> (sizeof (struct rtx_def_sat_fract), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_fix *)(<API key> (sizeof (struct rtx_def_fix) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_fix *)(<API key> (sizeof (struct rtx_def_fix) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_fix *)(<API key> (sizeof (struct rtx_def_fix), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_fix *)(<API key> (sizeof (struct rtx_def_fix), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_float *)(<API key> (sizeof (struct rtx_def_float) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_float *)(<API key> (sizeof (struct rtx_def_float) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_float *)(<API key> (sizeof (struct rtx_def_float), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_float *)(<API key> (sizeof (struct rtx_def_float), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_truncate *)(<API key> (sizeof (struct rtx_def_truncate) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_truncate *)(<API key> (sizeof (struct rtx_def_truncate) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_truncate *)(<API key> (sizeof (struct rtx_def_truncate), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_truncate *)(<API key> (sizeof (struct rtx_def_truncate), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_zero_extend *)(<API key> (sizeof (struct rtx_def_zero_extend) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_zero_extend *)(<API key> (sizeof (struct rtx_def_zero_extend) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_zero_extend *)(<API key> (sizeof (struct rtx_def_zero_extend), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_zero_extend *)(<API key> (sizeof (struct rtx_def_zero_extend), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_sign_extend *)(<API key> (sizeof (struct rtx_def_sign_extend) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_sign_extend *)(<API key> (sizeof (struct rtx_def_sign_extend) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_sign_extend *)(<API key> (sizeof (struct rtx_def_sign_extend), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_sign_extend *)(<API key> (sizeof (struct rtx_def_sign_extend), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ltgt *)(<API key> (sizeof (struct rtx_def_ltgt) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ltgt *)(<API key> (sizeof (struct rtx_def_ltgt) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ltgt *)(<API key> (sizeof (struct rtx_def_ltgt), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ltgt *)(<API key> (sizeof (struct rtx_def_ltgt), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_unlt *)(<API key> (sizeof (struct rtx_def_unlt) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_unlt *)(<API key> (sizeof (struct rtx_def_unlt) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_unlt *)(<API key> (sizeof (struct rtx_def_unlt), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_unlt *)(<API key> (sizeof (struct rtx_def_unlt), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_unle *)(<API key> (sizeof (struct rtx_def_unle) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_unle *)(<API key> (sizeof (struct rtx_def_unle) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_unle *)(<API key> (sizeof (struct rtx_def_unle), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_unle *)(<API key> (sizeof (struct rtx_def_unle), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ungt *)(<API key> (sizeof (struct rtx_def_ungt) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ungt *)(<API key> (sizeof (struct rtx_def_ungt) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ungt *)(<API key> (sizeof (struct rtx_def_ungt), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ungt *)(<API key> (sizeof (struct rtx_def_ungt), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_unge *)(<API key> (sizeof (struct rtx_def_unge) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_unge *)(<API key> (sizeof (struct rtx_def_unge) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_unge *)(<API key> (sizeof (struct rtx_def_unge), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_unge *)(<API key> (sizeof (struct rtx_def_unge), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_uneq *)(<API key> (sizeof (struct rtx_def_uneq) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_uneq *)(<API key> (sizeof (struct rtx_def_uneq) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_uneq *)(<API key> (sizeof (struct rtx_def_uneq), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_uneq *)(<API key> (sizeof (struct rtx_def_uneq), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ordered *)(<API key> (sizeof (struct rtx_def_ordered) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ordered *)(<API key> (sizeof (struct rtx_def_ordered) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ordered *)(<API key> (sizeof (struct rtx_def_ordered), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ordered *)(<API key> (sizeof (struct rtx_def_ordered), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_unordered *)(<API key> (sizeof (struct rtx_def_unordered) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_unordered *)(<API key> (sizeof (struct rtx_def_unordered) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_unordered *)(<API key> (sizeof (struct rtx_def_unordered), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_unordered *)(<API key> (sizeof (struct rtx_def_unordered), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ltu *)(<API key> (sizeof (struct rtx_def_ltu) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ltu *)(<API key> (sizeof (struct rtx_def_ltu) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ltu *)(<API key> (sizeof (struct rtx_def_ltu), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ltu *)(<API key> (sizeof (struct rtx_def_ltu), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_leu *)(<API key> (sizeof (struct rtx_def_leu) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_leu *)(<API key> (sizeof (struct rtx_def_leu) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_leu *)(<API key> (sizeof (struct rtx_def_leu), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_leu *)(<API key> (sizeof (struct rtx_def_leu), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_gtu *)(<API key> (sizeof (struct rtx_def_gtu) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_gtu *)(<API key> (sizeof (struct rtx_def_gtu) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_gtu *)(<API key> (sizeof (struct rtx_def_gtu), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_gtu *)(<API key> (sizeof (struct rtx_def_gtu), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_geu *)(<API key> (sizeof (struct rtx_def_geu) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_geu *)(<API key> (sizeof (struct rtx_def_geu) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_geu *)(<API key> (sizeof (struct rtx_def_geu), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_geu *)(<API key> (sizeof (struct rtx_def_geu), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_lt *)(<API key> (sizeof (struct rtx_def_lt) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_lt *)(<API key> (sizeof (struct rtx_def_lt) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_lt *)(<API key> (sizeof (struct rtx_def_lt), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_lt *)(<API key> (sizeof (struct rtx_def_lt), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_le *)(<API key> (sizeof (struct rtx_def_le) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_le *)(<API key> (sizeof (struct rtx_def_le) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_le *)(<API key> (sizeof (struct rtx_def_le), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_le *)(<API key> (sizeof (struct rtx_def_le), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_gt *)(<API key> (sizeof (struct rtx_def_gt) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_gt *)(<API key> (sizeof (struct rtx_def_gt) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_gt *)(<API key> (sizeof (struct rtx_def_gt), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_gt *)(<API key> (sizeof (struct rtx_def_gt), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ge *)(<API key> (sizeof (struct rtx_def_ge) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ge *)(<API key> (sizeof (struct rtx_def_ge) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ge *)(<API key> (sizeof (struct rtx_def_ge), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ge *)(<API key> (sizeof (struct rtx_def_ge), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_eq *)(<API key> (sizeof (struct rtx_def_eq) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_eq *)(<API key> (sizeof (struct rtx_def_eq) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_eq *)(<API key> (sizeof (struct rtx_def_eq), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_eq *)(<API key> (sizeof (struct rtx_def_eq), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ne *)(<API key> (sizeof (struct rtx_def_ne) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ne *)(<API key> (sizeof (struct rtx_def_ne) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ne *)(<API key> (sizeof (struct rtx_def_ne), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ne *)(<API key> (sizeof (struct rtx_def_ne), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_post_modify *)(<API key> (sizeof (struct rtx_def_post_modify) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_post_modify *)(<API key> (sizeof (struct rtx_def_post_modify) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_post_modify *)(<API key> (sizeof (struct rtx_def_post_modify), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_post_modify *)(<API key> (sizeof (struct rtx_def_post_modify), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_pre_modify *)(<API key> (sizeof (struct rtx_def_pre_modify) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_pre_modify *)(<API key> (sizeof (struct rtx_def_pre_modify) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_pre_modify *)(<API key> (sizeof (struct rtx_def_pre_modify), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_pre_modify *)(<API key> (sizeof (struct rtx_def_pre_modify), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_post_inc *)(<API key> (sizeof (struct rtx_def_post_inc) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_post_inc *)(<API key> (sizeof (struct rtx_def_post_inc) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_post_inc *)(<API key> (sizeof (struct rtx_def_post_inc), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_post_inc *)(<API key> (sizeof (struct rtx_def_post_inc), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_post_dec *)(<API key> (sizeof (struct rtx_def_post_dec) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_post_dec *)(<API key> (sizeof (struct rtx_def_post_dec) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_post_dec *)(<API key> (sizeof (struct rtx_def_post_dec), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_post_dec *)(<API key> (sizeof (struct rtx_def_post_dec), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_pre_inc *)(<API key> (sizeof (struct rtx_def_pre_inc) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_pre_inc *)(<API key> (sizeof (struct rtx_def_pre_inc) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_pre_inc *)(<API key> (sizeof (struct rtx_def_pre_inc), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_pre_inc *)(<API key> (sizeof (struct rtx_def_pre_inc), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_pre_dec *)(<API key> (sizeof (struct rtx_def_pre_dec) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_pre_dec *)(<API key> (sizeof (struct rtx_def_pre_dec) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_pre_dec *)(<API key> (sizeof (struct rtx_def_pre_dec), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_pre_dec *)(<API key> (sizeof (struct rtx_def_pre_dec), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_umax *)(<API key> (sizeof (struct rtx_def_umax) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_umax *)(<API key> (sizeof (struct rtx_def_umax) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_umax *)(<API key> (sizeof (struct rtx_def_umax), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_umax *)(<API key> (sizeof (struct rtx_def_umax), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_umin *)(<API key> (sizeof (struct rtx_def_umin) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_umin *)(<API key> (sizeof (struct rtx_def_umin) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_umin *)(<API key> (sizeof (struct rtx_def_umin), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_umin *)(<API key> (sizeof (struct rtx_def_umin), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_smax *)(<API key> (sizeof (struct rtx_def_smax) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_smax *)(<API key> (sizeof (struct rtx_def_smax) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_smax *)(<API key> (sizeof (struct rtx_def_smax), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_smax *)(<API key> (sizeof (struct rtx_def_smax), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_smin *)(<API key> (sizeof (struct rtx_def_smin) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_smin *)(<API key> (sizeof (struct rtx_def_smin) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_smin *)(<API key> (sizeof (struct rtx_def_smin), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_smin *)(<API key> (sizeof (struct rtx_def_smin), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_rotatert *)(<API key> (sizeof (struct rtx_def_rotatert) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_rotatert *)(<API key> (sizeof (struct rtx_def_rotatert) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_rotatert *)(<API key> (sizeof (struct rtx_def_rotatert), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_rotatert *)(<API key> (sizeof (struct rtx_def_rotatert), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_lshiftrt *)(<API key> (sizeof (struct rtx_def_lshiftrt) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_lshiftrt *)(<API key> (sizeof (struct rtx_def_lshiftrt) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_lshiftrt *)(<API key> (sizeof (struct rtx_def_lshiftrt), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_lshiftrt *)(<API key> (sizeof (struct rtx_def_lshiftrt), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ashiftrt *)(<API key> (sizeof (struct rtx_def_ashiftrt) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ashiftrt *)(<API key> (sizeof (struct rtx_def_ashiftrt) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ashiftrt *)(<API key> (sizeof (struct rtx_def_ashiftrt), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ashiftrt *)(<API key> (sizeof (struct rtx_def_ashiftrt), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_rotate *)(<API key> (sizeof (struct rtx_def_rotate) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_rotate *)(<API key> (sizeof (struct rtx_def_rotate) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_rotate *)(<API key> (sizeof (struct rtx_def_rotate), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_rotate *)(<API key> (sizeof (struct rtx_def_rotate), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ashift *)(<API key> (sizeof (struct rtx_def_ashift) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ashift *)(<API key> (sizeof (struct rtx_def_ashift) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ashift *)(<API key> (sizeof (struct rtx_def_ashift), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ashift *)(<API key> (sizeof (struct rtx_def_ashift), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_not *)(<API key> (sizeof (struct rtx_def_not) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_not *)(<API key> (sizeof (struct rtx_def_not) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_not *)(<API key> (sizeof (struct rtx_def_not), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_not *)(<API key> (sizeof (struct rtx_def_not), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_xor *)(<API key> (sizeof (struct rtx_def_xor) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_xor *)(<API key> (sizeof (struct rtx_def_xor) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_xor *)(<API key> (sizeof (struct rtx_def_xor), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_xor *)(<API key> (sizeof (struct rtx_def_xor), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ior *)(<API key> (sizeof (struct rtx_def_ior) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ior *)(<API key> (sizeof (struct rtx_def_ior) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ior *)(<API key> (sizeof (struct rtx_def_ior), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ior *)(<API key> (sizeof (struct rtx_def_ior), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_and *)(<API key> (sizeof (struct rtx_def_and) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_and *)(<API key> (sizeof (struct rtx_def_and) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_and *)(<API key> (sizeof (struct rtx_def_and), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_and *)(<API key> (sizeof (struct rtx_def_and), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_umod *)(<API key> (sizeof (struct rtx_def_umod) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_umod *)(<API key> (sizeof (struct rtx_def_umod) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_umod *)(<API key> (sizeof (struct rtx_def_umod), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_umod *)(<API key> (sizeof (struct rtx_def_umod), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_udiv *)(<API key> (sizeof (struct rtx_def_udiv) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_udiv *)(<API key> (sizeof (struct rtx_def_udiv) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_udiv *)(<API key> (sizeof (struct rtx_def_udiv), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_udiv *)(<API key> (sizeof (struct rtx_def_udiv), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_mod *)(<API key> (sizeof (struct rtx_def_mod) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_mod *)(<API key> (sizeof (struct rtx_def_mod) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_mod *)(<API key> (sizeof (struct rtx_def_mod), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_mod *)(<API key> (sizeof (struct rtx_def_mod), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_div *)(<API key> (sizeof (struct rtx_def_us_div) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_div *)(<API key> (sizeof (struct rtx_def_us_div) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_div *)(<API key> (sizeof (struct rtx_def_us_div), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_div *)(<API key> (sizeof (struct rtx_def_us_div), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_div *)(<API key> (sizeof (struct rtx_def_ss_div) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_div *)(<API key> (sizeof (struct rtx_def_ss_div) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_div *)(<API key> (sizeof (struct rtx_def_ss_div), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_div *)(<API key> (sizeof (struct rtx_def_ss_div), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_div *)(<API key> (sizeof (struct rtx_def_div) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_div *)(<API key> (sizeof (struct rtx_def_div) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_div *)(<API key> (sizeof (struct rtx_def_div), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_div *)(<API key> (sizeof (struct rtx_def_div), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_mult *)(<API key> (sizeof (struct rtx_def_us_mult) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_us_mult *)(<API key> (sizeof (struct rtx_def_us_mult) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_mult *)(<API key> (sizeof (struct rtx_def_us_mult), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_us_mult *)(<API key> (sizeof (struct rtx_def_us_mult), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_mult *)(<API key> (sizeof (struct rtx_def_ss_mult) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_ss_mult *)(<API key> (sizeof (struct rtx_def_ss_mult) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_mult *)(<API key> (sizeof (struct rtx_def_ss_mult), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_ss_mult *)(<API key> (sizeof (struct rtx_def_ss_mult), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_mult *)(<API key> (sizeof (struct rtx_def_mult) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_mult *)(<API key> (sizeof (struct rtx_def_mult) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_mult *)(<API key> (sizeof (struct rtx_def_mult), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_mult *)(<API key> (sizeof (struct rtx_def_mult), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_neg *)(<API key> (sizeof (struct rtx_def_neg) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_neg *)(<API key> (sizeof (struct rtx_def_neg) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_neg *)(<API key> (sizeof (struct rtx_def_neg), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_neg *)(<API key> (sizeof (struct rtx_def_neg), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_minus *)(<API key> (sizeof (struct rtx_def_minus) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_minus *)(<API key> (sizeof (struct rtx_def_minus) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_minus *)(<API key> (sizeof (struct rtx_def_minus), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_minus *)(<API key> (sizeof (struct rtx_def_minus), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_plus *)(<API key> (sizeof (struct rtx_def_plus) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_plus *)(<API key> (sizeof (struct rtx_def_plus) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_plus *)(<API key> (sizeof (struct rtx_def_plus), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_plus *)(<API key> (sizeof (struct rtx_def_plus), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_compare *)(<API key> (sizeof (struct rtx_def_compare) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_compare *)(<API key> (sizeof (struct rtx_def_compare) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_compare *)(<API key> (sizeof (struct rtx_def_compare), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_compare *)(<API key> (sizeof (struct rtx_def_compare), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_cc0 *)(<API key> (sizeof (struct rtx_def_cc0) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_cc0 *)(<API key> (sizeof (struct rtx_def_cc0) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_cc0 *)(<API key> (sizeof (struct rtx_def_cc0), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_cc0 *)(<API key> (sizeof (struct rtx_def_cc0), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_symbol_ref *)(<API key> (sizeof (struct rtx_def_symbol_ref) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_symbol_ref *)(<API key> (sizeof (struct rtx_def_symbol_ref) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_symbol_ref *)(<API key> (sizeof (struct rtx_def_symbol_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_symbol_ref *)(<API key> (sizeof (struct rtx_def_symbol_ref), n MEM_STAT_INFO)))
#define <API key>() ((union fake_union_1 *)(<API key> (sizeof (union fake_union_1) MEM_STAT_INFO)))
#define <API key>() ((union fake_union_1 *)(<API key> (sizeof (union fake_union_1) MEM_STAT_INFO)))
#define <API key>(n) ((union fake_union_1 *)(<API key> (sizeof (union fake_union_1), n MEM_STAT_INFO)))
#define <API key>(n) ((union fake_union_1 *)(<API key> (sizeof (union fake_union_1), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_label_ref *)(<API key> (sizeof (struct rtx_def_label_ref) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_label_ref *)(<API key> (sizeof (struct rtx_def_label_ref) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_label_ref *)(<API key> (sizeof (struct rtx_def_label_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_label_ref *)(<API key> (sizeof (struct rtx_def_label_ref), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_mem *)(<API key> (sizeof (struct rtx_def_mem) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_mem *)(<API key> (sizeof (struct rtx_def_mem) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_mem *)(<API key> (sizeof (struct rtx_def_mem), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_mem *)(<API key> (sizeof (struct rtx_def_mem), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_concatn *)(<API key> (sizeof (struct rtx_def_concatn) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_concatn *)(<API key> (sizeof (struct rtx_def_concatn) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_concatn *)(<API key> (sizeof (struct rtx_def_concatn), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_concatn *)(<API key> (sizeof (struct rtx_def_concatn), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_concat *)(<API key> (sizeof (struct rtx_def_concat) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_concat *)(<API key> (sizeof (struct rtx_def_concat) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_concat *)(<API key> (sizeof (struct rtx_def_concat), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_concat *)(<API key> (sizeof (struct rtx_def_concat), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_subreg *)(<API key> (sizeof (struct rtx_def_subreg) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_subreg *)(<API key> (sizeof (struct rtx_def_subreg) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_subreg *)(<API key> (sizeof (struct rtx_def_subreg), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_subreg *)(<API key> (sizeof (struct rtx_def_subreg), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_scratch *)(<API key> (sizeof (struct rtx_def_scratch) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_scratch *)(<API key> (sizeof (struct rtx_def_scratch) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_scratch *)(<API key> (sizeof (struct rtx_def_scratch), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_scratch *)(<API key> (sizeof (struct rtx_def_scratch), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_reg *)(<API key> (sizeof (struct rtx_def_reg) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_reg *)(<API key> (sizeof (struct rtx_def_reg) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_reg *)(<API key> (sizeof (struct rtx_def_reg), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_reg *)(<API key> (sizeof (struct rtx_def_reg), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_pc *)(<API key> (sizeof (struct rtx_def_pc) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_pc *)(<API key> (sizeof (struct rtx_def_pc) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_pc *)(<API key> (sizeof (struct rtx_def_pc), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_pc *)(<API key> (sizeof (struct rtx_def_pc), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_const *)(<API key> (sizeof (struct rtx_def_const) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_const *)(<API key> (sizeof (struct rtx_def_const) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_const *)(<API key> (sizeof (struct rtx_def_const), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_const *)(<API key> (sizeof (struct rtx_def_const), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_const_fixed *)(<API key> (sizeof (struct rtx_def_const_fixed) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_const_fixed *)(<API key> (sizeof (struct rtx_def_const_fixed) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_const_fixed *)(<API key> (sizeof (struct rtx_def_const_fixed), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_const_fixed *)(<API key> (sizeof (struct rtx_def_const_fixed), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_const_int *)(<API key> (sizeof (struct rtx_def_const_int) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_const_int *)(<API key> (sizeof (struct rtx_def_const_int) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_const_int *)(<API key> (sizeof (struct rtx_def_const_int), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_const_int *)(<API key> (sizeof (struct rtx_def_const_int), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_trap_if *)(<API key> (sizeof (struct rtx_def_trap_if) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_trap_if *)(<API key> (sizeof (struct rtx_def_trap_if) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_trap_if *)(<API key> (sizeof (struct rtx_def_trap_if), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_trap_if *)(<API key> (sizeof (struct rtx_def_trap_if), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_eh_return *)(<API key> (sizeof (struct rtx_def_eh_return) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_eh_return *)(<API key> (sizeof (struct rtx_def_eh_return) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_eh_return *)(<API key> (sizeof (struct rtx_def_eh_return), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_eh_return *)(<API key> (sizeof (struct rtx_def_eh_return), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_return *)(<API key> (sizeof (struct rtx_def_return) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_return *)(<API key> (sizeof (struct rtx_def_return) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_return *)(<API key> (sizeof (struct rtx_def_return), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_return *)(<API key> (sizeof (struct rtx_def_return), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_call *)(<API key> (sizeof (struct rtx_def_call) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_call *)(<API key> (sizeof (struct rtx_def_call) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_call *)(<API key> (sizeof (struct rtx_def_call), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_call *)(<API key> (sizeof (struct rtx_def_call), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_clobber *)(<API key> (sizeof (struct rtx_def_clobber) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_clobber *)(<API key> (sizeof (struct rtx_def_clobber) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_clobber *)(<API key> (sizeof (struct rtx_def_clobber), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_clobber *)(<API key> (sizeof (struct rtx_def_clobber), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_use *)(<API key> (sizeof (struct rtx_def_use) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_use *)(<API key> (sizeof (struct rtx_def_use) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_use *)(<API key> (sizeof (struct rtx_def_use), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_use *)(<API key> (sizeof (struct rtx_def_use), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_set *)(<API key> (sizeof (struct rtx_def_set) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_set *)(<API key> (sizeof (struct rtx_def_set) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_set *)(<API key> (sizeof (struct rtx_def_set), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_set *)(<API key> (sizeof (struct rtx_def_set), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_prefetch *)(<API key> (sizeof (struct rtx_def_prefetch) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_prefetch *)(<API key> (sizeof (struct rtx_def_prefetch) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_prefetch *)(<API key> (sizeof (struct rtx_def_prefetch), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_prefetch *)(<API key> (sizeof (struct rtx_def_prefetch), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_addr_vec *)(<API key> (sizeof (struct rtx_def_addr_vec) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_addr_vec *)(<API key> (sizeof (struct rtx_def_addr_vec) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_addr_vec *)(<API key> (sizeof (struct rtx_def_addr_vec), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_addr_vec *)(<API key> (sizeof (struct rtx_def_addr_vec), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_unspec *)(<API key> (sizeof (struct rtx_def_unspec) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_unspec *)(<API key> (sizeof (struct rtx_def_unspec) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_unspec *)(<API key> (sizeof (struct rtx_def_unspec), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_unspec *)(<API key> (sizeof (struct rtx_def_unspec), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_asm_input *)(<API key> (sizeof (struct rtx_def_asm_input) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_asm_input *)(<API key> (sizeof (struct rtx_def_asm_input) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_asm_input *)(<API key> (sizeof (struct rtx_def_asm_input), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_asm_input *)(<API key> (sizeof (struct rtx_def_asm_input), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_parallel *)(<API key> (sizeof (struct rtx_def_parallel) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_parallel *)(<API key> (sizeof (struct rtx_def_parallel) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_parallel *)(<API key> (sizeof (struct rtx_def_parallel), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_parallel *)(<API key> (sizeof (struct rtx_def_parallel), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_cond_exec *)(<API key> (sizeof (struct rtx_def_cond_exec) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_cond_exec *)(<API key> (sizeof (struct rtx_def_cond_exec) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_cond_exec *)(<API key> (sizeof (struct rtx_def_cond_exec), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_cond_exec *)(<API key> (sizeof (struct rtx_def_cond_exec), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_note *)(<API key> (sizeof (struct rtx_def_note) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_note *)(<API key> (sizeof (struct rtx_def_note) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_note *)(<API key> (sizeof (struct rtx_def_note), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_note *)(<API key> (sizeof (struct rtx_def_note), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_code_label *)(<API key> (sizeof (struct rtx_def_code_label) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_code_label *)(<API key> (sizeof (struct rtx_def_code_label) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_code_label *)(<API key> (sizeof (struct rtx_def_code_label), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_code_label *)(<API key> (sizeof (struct rtx_def_code_label), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_barrier *)(<API key> (sizeof (struct rtx_def_barrier) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_barrier *)(<API key> (sizeof (struct rtx_def_barrier) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_barrier *)(<API key> (sizeof (struct rtx_def_barrier), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_barrier *)(<API key> (sizeof (struct rtx_def_barrier), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_call_insn *)(<API key> (sizeof (struct rtx_def_call_insn) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_call_insn *)(<API key> (sizeof (struct rtx_def_call_insn) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_call_insn *)(<API key> (sizeof (struct rtx_def_call_insn), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_call_insn *)(<API key> (sizeof (struct rtx_def_call_insn), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_jump_insn *)(<API key> (sizeof (struct rtx_def_jump_insn) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_jump_insn *)(<API key> (sizeof (struct rtx_def_jump_insn) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_jump_insn *)(<API key> (sizeof (struct rtx_def_jump_insn), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_jump_insn *)(<API key> (sizeof (struct rtx_def_jump_insn), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_insn *)(<API key> (sizeof (struct rtx_def_insn) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_insn *)(<API key> (sizeof (struct rtx_def_insn) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_insn *)(<API key> (sizeof (struct rtx_def_insn), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_insn *)(<API key> (sizeof (struct rtx_def_insn), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_debug_insn *)(<API key> (sizeof (struct rtx_def_debug_insn) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_debug_insn *)(<API key> (sizeof (struct rtx_def_debug_insn) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_debug_insn *)(<API key> (sizeof (struct rtx_def_debug_insn), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_debug_insn *)(<API key> (sizeof (struct rtx_def_debug_insn), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_address *)(<API key> (sizeof (struct rtx_def_address) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_address *)(<API key> (sizeof (struct rtx_def_address) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_address *)(<API key> (sizeof (struct rtx_def_address), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_address *)(<API key> (sizeof (struct rtx_def_address), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_sequence *)(<API key> (sizeof (struct rtx_def_sequence) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_sequence *)(<API key> (sizeof (struct rtx_def_sequence) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_sequence *)(<API key> (sizeof (struct rtx_def_sequence), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_sequence *)(<API key> (sizeof (struct rtx_def_sequence), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_insn_list *)(<API key> (sizeof (struct rtx_def_insn_list) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_insn_list *)(<API key> (sizeof (struct rtx_def_insn_list) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_insn_list *)(<API key> (sizeof (struct rtx_def_insn_list), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_insn_list *)(<API key> (sizeof (struct rtx_def_insn_list), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_expr_list *)(<API key> (sizeof (struct rtx_def_expr_list) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_expr_list *)(<API key> (sizeof (struct rtx_def_expr_list) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_expr_list *)(<API key> (sizeof (struct rtx_def_expr_list), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_expr_list *)(<API key> (sizeof (struct rtx_def_expr_list), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_debug_expr *)(<API key> (sizeof (struct rtx_def_debug_expr) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_debug_expr *)(<API key> (sizeof (struct rtx_def_debug_expr) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_debug_expr *)(<API key> (sizeof (struct rtx_def_debug_expr), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_debug_expr *)(<API key> (sizeof (struct rtx_def_debug_expr), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_value *)(<API key> (sizeof (struct rtx_def_value) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_value *)(<API key> (sizeof (struct rtx_def_value) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_value *)(<API key> (sizeof (struct rtx_def_value), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_value *)(<API key> (sizeof (struct rtx_def_value), n MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_UnKnown *)(<API key> (sizeof (struct rtx_def_UnKnown) MEM_STAT_INFO)))
#define <API key>() ((struct rtx_def_UnKnown *)(<API key> (sizeof (struct rtx_def_UnKnown) MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_UnKnown *)(<API key> (sizeof (struct rtx_def_UnKnown), n MEM_STAT_INFO)))
#define <API key>(n) ((struct rtx_def_UnKnown *)(<API key> (sizeof (struct rtx_def_UnKnown), n MEM_STAT_INFO)))
#define <API key>() ((union <API key> *)(<API key> (sizeof (union <API key>) MEM_STAT_INFO)))
#define <API key>() ((union <API key> *)(<API key> (sizeof (union <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((union <API key> *)(<API key> (sizeof (union <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((union <API key> *)(<API key> (sizeof (union <API key>), n MEM_STAT_INFO)))
#define <API key>() ((union <API key> *)(<API key> (sizeof (union <API key>) MEM_STAT_INFO)))
#define <API key>() ((union <API key> *)(<API key> (sizeof (union <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((union <API key> *)(<API key> (sizeof (union <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((union <API key> *)(<API key> (sizeof (union <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>() ((struct fixed_value *)(<API key> (sizeof (struct fixed_value) MEM_STAT_INFO)))
#define <API key>() ((struct fixed_value *)(<API key> (sizeof (struct fixed_value) MEM_STAT_INFO)))
#define <API key>(n) ((struct fixed_value *)(<API key> (sizeof (struct fixed_value), n MEM_STAT_INFO)))
#define <API key>(n) ((struct fixed_value *)(<API key> (sizeof (struct fixed_value), n MEM_STAT_INFO)))
#define <API key>() ((struct real_value *)(<API key> (sizeof (struct real_value) MEM_STAT_INFO)))
#define <API key>() ((struct real_value *)(<API key> (sizeof (struct real_value) MEM_STAT_INFO)))
#define <API key>(n) ((struct real_value *)(<API key> (sizeof (struct real_value), n MEM_STAT_INFO)))
#define <API key>(n) ((struct real_value *)(<API key> (sizeof (struct real_value), n MEM_STAT_INFO)))
#define <API key>() ((vec<rtx,va_gc> *)(<API key> (sizeof (vec<rtx,va_gc>) MEM_STAT_INFO)))
#define <API key>() ((vec<rtx,va_gc> *)(<API key> (sizeof (vec<rtx,va_gc>) MEM_STAT_INFO)))
#define <API key>(n) ((vec<rtx,va_gc> *)(<API key> (sizeof (vec<rtx,va_gc>), n MEM_STAT_INFO)))
#define <API key>(n) ((vec<rtx,va_gc> *)(<API key> (sizeof (vec<rtx,va_gc>), n MEM_STAT_INFO)))
#define <API key>() ((struct block_symbol *)(<API key> (sizeof (struct block_symbol) MEM_STAT_INFO)))
#define <API key>() ((struct block_symbol *)(<API key> (sizeof (struct block_symbol) MEM_STAT_INFO)))
#define <API key>(n) ((struct block_symbol *)(<API key> (sizeof (struct block_symbol), n MEM_STAT_INFO)))
#define <API key>(n) ((struct block_symbol *)(<API key> (sizeof (struct block_symbol), n MEM_STAT_INFO)))
#define <API key>() ((struct object_block *)(<API key> (sizeof (struct object_block) MEM_STAT_INFO)))
#define <API key>() ((struct object_block *)(<API key> (sizeof (struct object_block) MEM_STAT_INFO)))
#define <API key>(n) ((struct object_block *)(<API key> (sizeof (struct object_block), n MEM_STAT_INFO)))
#define <API key>(n) ((struct object_block *)(<API key> (sizeof (struct object_block), n MEM_STAT_INFO)))
#define ggc_alloc_reg_attrs() ((struct reg_attrs *)(<API key> (sizeof (struct reg_attrs) MEM_STAT_INFO)))
#define <API key>() ((struct reg_attrs *)(<API key> (sizeof (struct reg_attrs) MEM_STAT_INFO)))
#define <API key>(n) ((struct reg_attrs *)(<API key> (sizeof (struct reg_attrs), n MEM_STAT_INFO)))
#define <API key>(n) ((struct reg_attrs *)(<API key> (sizeof (struct reg_attrs), n MEM_STAT_INFO)))
#define ggc_alloc_mem_attrs() ((struct mem_attrs *)(<API key> (sizeof (struct mem_attrs) MEM_STAT_INFO)))
#define <API key>() ((struct mem_attrs *)(<API key> (sizeof (struct mem_attrs) MEM_STAT_INFO)))
#define <API key>(n) ((struct mem_attrs *)(<API key> (sizeof (struct mem_attrs), n MEM_STAT_INFO)))
#define <API key>(n) ((struct mem_attrs *)(<API key> (sizeof (struct mem_attrs), n MEM_STAT_INFO)))
#define <API key>() ((struct coverage_data *)(<API key> (sizeof (struct coverage_data) MEM_STAT_INFO)))
#define <API key>() ((struct coverage_data *)(<API key> (sizeof (struct coverage_data) MEM_STAT_INFO)))
#define <API key>(n) ((struct coverage_data *)(<API key> (sizeof (struct coverage_data), n MEM_STAT_INFO)))
#define <API key>(n) ((struct coverage_data *)(<API key> (sizeof (struct coverage_data), n MEM_STAT_INFO)))
#define <API key>() ((struct bitmap_obstack *)(<API key> (sizeof (struct bitmap_obstack) MEM_STAT_INFO)))
#define <API key>() ((struct bitmap_obstack *)(<API key> (sizeof (struct bitmap_obstack) MEM_STAT_INFO)))
#define <API key>(n) ((struct bitmap_obstack *)(<API key> (sizeof (struct bitmap_obstack), n MEM_STAT_INFO)))
#define <API key>(n) ((struct bitmap_obstack *)(<API key> (sizeof (struct bitmap_obstack), n MEM_STAT_INFO)))
#define <API key>() ((struct bitmap_element_def *)(<API key> (sizeof (struct bitmap_element_def) MEM_STAT_INFO)))
#define <API key>() ((struct bitmap_element_def *)(<API key> (sizeof (struct bitmap_element_def) MEM_STAT_INFO)))
#define <API key>(n) ((struct bitmap_element_def *)(<API key> (sizeof (struct bitmap_element_def), n MEM_STAT_INFO)))
#define <API key>(n) ((struct bitmap_element_def *)(<API key> (sizeof (struct bitmap_element_def), n MEM_STAT_INFO)))
#define <API key>() ((struct splay_tree_s *)(<API key> (sizeof (struct splay_tree_s) MEM_STAT_INFO)))
#define <API key>() ((struct splay_tree_s *)(<API key> (sizeof (struct splay_tree_s) MEM_STAT_INFO)))
#define <API key>(n) ((struct splay_tree_s *)(<API key> (sizeof (struct splay_tree_s), n MEM_STAT_INFO)))
#define <API key>(n) ((struct splay_tree_s *)(<API key> (sizeof (struct splay_tree_s), n MEM_STAT_INFO)))
#define <API key>() ((struct splay_tree_node_s *)(<API key> (sizeof (struct splay_tree_node_s) MEM_STAT_INFO)))
#define <API key>() ((struct splay_tree_node_s *)(<API key> (sizeof (struct splay_tree_node_s) MEM_STAT_INFO)))
#define <API key>(n) ((struct splay_tree_node_s *)(<API key> (sizeof (struct splay_tree_node_s), n MEM_STAT_INFO)))
#define <API key>(n) ((struct splay_tree_node_s *)(<API key> (sizeof (struct splay_tree_node_s), n MEM_STAT_INFO)))
#define <API key>() ((struct machine_function *)(<API key> (sizeof (struct machine_function) MEM_STAT_INFO)))
#define <API key>() ((struct machine_function *)(<API key> (sizeof (struct machine_function) MEM_STAT_INFO)))
#define <API key>(n) ((struct machine_function *)(<API key> (sizeof (struct machine_function), n MEM_STAT_INFO)))
#define <API key>(n) ((struct machine_function *)(<API key> (sizeof (struct machine_function), n MEM_STAT_INFO)))
#define <API key>() ((struct arm_stack_offsets *)(<API key> (sizeof (struct arm_stack_offsets) MEM_STAT_INFO)))
#define <API key>() ((struct arm_stack_offsets *)(<API key> (sizeof (struct arm_stack_offsets) MEM_STAT_INFO)))
#define <API key>(n) ((struct arm_stack_offsets *)(<API key> (sizeof (struct arm_stack_offsets), n MEM_STAT_INFO)))
#define <API key>(n) ((struct arm_stack_offsets *)(<API key> (sizeof (struct arm_stack_offsets), n MEM_STAT_INFO)))
#define <API key>() ((struct basic_block_def *)(<API key> (sizeof (struct basic_block_def) MEM_STAT_INFO)))
#define <API key>() ((struct basic_block_def *)(<API key> (sizeof (struct basic_block_def) MEM_STAT_INFO)))
#define <API key>(n) ((struct basic_block_def *)(<API key> (sizeof (struct basic_block_def), n MEM_STAT_INFO)))
#define <API key>(n) ((struct basic_block_def *)(<API key> (sizeof (struct basic_block_def), n MEM_STAT_INFO)))
#define ggc_alloc_edge_def() ((struct edge_def *)(<API key> (sizeof (struct edge_def) MEM_STAT_INFO)))
#define <API key>() ((struct edge_def *)(<API key> (sizeof (struct edge_def) MEM_STAT_INFO)))
#define <API key>(n) ((struct edge_def *)(<API key> (sizeof (struct edge_def), n MEM_STAT_INFO)))
#define <API key>(n) ((struct edge_def *)(<API key> (sizeof (struct edge_def), n MEM_STAT_INFO)))
#define <API key>() ((struct cl_optimization *)(<API key> (sizeof (struct cl_optimization) MEM_STAT_INFO)))
#define <API key>() ((struct cl_optimization *)(<API key> (sizeof (struct cl_optimization) MEM_STAT_INFO)))
#define <API key>(n) ((struct cl_optimization *)(<API key> (sizeof (struct cl_optimization), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cl_optimization *)(<API key> (sizeof (struct cl_optimization), n MEM_STAT_INFO)))
#define <API key>() ((struct cl_target_option *)(<API key> (sizeof (struct cl_target_option) MEM_STAT_INFO)))
#define <API key>() ((struct cl_target_option *)(<API key> (sizeof (struct cl_target_option) MEM_STAT_INFO)))
#define <API key>(n) ((struct cl_target_option *)(<API key> (sizeof (struct cl_target_option), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cl_target_option *)(<API key> (sizeof (struct cl_target_option), n MEM_STAT_INFO)))
#define ggc_alloc_section() ((union section *)(<API key> (sizeof (union section) MEM_STAT_INFO)))
#define <API key>() ((union section *)(<API key> (sizeof (union section) MEM_STAT_INFO)))
#define <API key>(n) ((union section *)(<API key> (sizeof (union section), n MEM_STAT_INFO)))
#define <API key>(n) ((union section *)(<API key> (sizeof (union section), n MEM_STAT_INFO)))
#define <API key>(SIZE) ((union gimple_statement_d *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE) ((union gimple_statement_d *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((union gimple_statement_d *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((union gimple_statement_d *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define ggc_alloc_rtvec_def(SIZE) ((struct rtvec_def *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE) ((struct rtvec_def *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct rtvec_def *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct rtvec_def *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define ggc_alloc_rtx_def(SIZE) ((struct rtx_def *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE) ((struct rtx_def *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct rtx_def *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((struct rtx_def *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>() ((struct bitmap_head_def *)(<API key> (sizeof (struct bitmap_head_def) MEM_STAT_INFO)))
#define <API key>() ((struct bitmap_head_def *)(<API key> (sizeof (struct bitmap_head_def) MEM_STAT_INFO)))
#define <API key>(n) ((struct bitmap_head_def *)(<API key> (sizeof (struct bitmap_head_def), n MEM_STAT_INFO)))
#define <API key>(n) ((struct bitmap_head_def *)(<API key> (sizeof (struct bitmap_head_def), n MEM_STAT_INFO)))
#define <API key>() ((union cpp_macro_u *)(<API key> (sizeof (union cpp_macro_u) MEM_STAT_INFO)))
#define <API key>() ((union cpp_macro_u *)(<API key> (sizeof (union cpp_macro_u) MEM_STAT_INFO)))
#define <API key>(n) ((union cpp_macro_u *)(<API key> (sizeof (union cpp_macro_u), n MEM_STAT_INFO)))
#define <API key>(n) ((union cpp_macro_u *)(<API key> (sizeof (union cpp_macro_u), n MEM_STAT_INFO)))
#define <API key>() ((struct ht_identifier *)(<API key> (sizeof (struct ht_identifier) MEM_STAT_INFO)))
#define <API key>() ((struct ht_identifier *)(<API key> (sizeof (struct ht_identifier) MEM_STAT_INFO)))
#define <API key>(n) ((struct ht_identifier *)(<API key> (sizeof (struct ht_identifier), n MEM_STAT_INFO)))
#define <API key>(n) ((struct ht_identifier *)(<API key> (sizeof (struct ht_identifier), n MEM_STAT_INFO)))
#define <API key>() ((union _cpp_hashnode_value *)(<API key> (sizeof (union _cpp_hashnode_value) MEM_STAT_INFO)))
#define <API key>() ((union _cpp_hashnode_value *)(<API key> (sizeof (union _cpp_hashnode_value) MEM_STAT_INFO)))
#define <API key>(n) ((union _cpp_hashnode_value *)(<API key> (sizeof (union _cpp_hashnode_value), n MEM_STAT_INFO)))
#define <API key>(n) ((union _cpp_hashnode_value *)(<API key> (sizeof (union _cpp_hashnode_value), n MEM_STAT_INFO)))
#define <API key>() ((union cpp_token_u *)(<API key> (sizeof (union cpp_token_u) MEM_STAT_INFO)))
#define <API key>() ((union cpp_token_u *)(<API key> (sizeof (union cpp_token_u) MEM_STAT_INFO)))
#define <API key>(n) ((union cpp_token_u *)(<API key> (sizeof (union cpp_token_u), n MEM_STAT_INFO)))
#define <API key>(n) ((union cpp_token_u *)(<API key> (sizeof (union cpp_token_u), n MEM_STAT_INFO)))
#define <API key>() ((struct cpp_identifier *)(<API key> (sizeof (struct cpp_identifier) MEM_STAT_INFO)))
#define <API key>() ((struct cpp_identifier *)(<API key> (sizeof (struct cpp_identifier) MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_identifier *)(<API key> (sizeof (struct cpp_identifier), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_identifier *)(<API key> (sizeof (struct cpp_identifier), n MEM_STAT_INFO)))
#define <API key>() ((struct cpp_macro_arg *)(<API key> (sizeof (struct cpp_macro_arg) MEM_STAT_INFO)))
#define <API key>() ((struct cpp_macro_arg *)(<API key> (sizeof (struct cpp_macro_arg) MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_macro_arg *)(<API key> (sizeof (struct cpp_macro_arg), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_macro_arg *)(<API key> (sizeof (struct cpp_macro_arg), n MEM_STAT_INFO)))
#define ggc_alloc_answer() ((struct answer *)(<API key> (sizeof (struct answer) MEM_STAT_INFO)))
#define <API key>() ((struct answer *)(<API key> (sizeof (struct answer) MEM_STAT_INFO)))
#define <API key>(n) ((struct answer *)(<API key> (sizeof (struct answer), n MEM_STAT_INFO)))
#define <API key>(n) ((struct answer *)(<API key> (sizeof (struct answer), n MEM_STAT_INFO)))
#define ggc_alloc_cpp_macro() ((struct cpp_macro *)(<API key> (sizeof (struct cpp_macro) MEM_STAT_INFO)))
#define <API key>() ((struct cpp_macro *)(<API key> (sizeof (struct cpp_macro) MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_macro *)(<API key> (sizeof (struct cpp_macro), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_macro *)(<API key> (sizeof (struct cpp_macro), n MEM_STAT_INFO)))
#define <API key>() ((struct cpp_string *)(<API key> (sizeof (struct cpp_string) MEM_STAT_INFO)))
#define <API key>() ((struct cpp_string *)(<API key> (sizeof (struct cpp_string) MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_string *)(<API key> (sizeof (struct cpp_string), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_string *)(<API key> (sizeof (struct cpp_string), n MEM_STAT_INFO)))
#define ggc_alloc_cpp_token() ((struct cpp_token *)(<API key> (sizeof (struct cpp_token) MEM_STAT_INFO)))
#define <API key>() ((struct cpp_token *)(<API key> (sizeof (struct cpp_token) MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_token *)(<API key> (sizeof (struct cpp_token), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_token *)(<API key> (sizeof (struct cpp_token), n MEM_STAT_INFO)))
#define ggc_alloc_line_maps() ((struct line_maps *)(<API key> (sizeof (struct line_maps) MEM_STAT_INFO)))
#define <API key>() ((struct line_maps *)(<API key> (sizeof (struct line_maps) MEM_STAT_INFO)))
#define <API key>(n) ((struct line_maps *)(<API key> (sizeof (struct line_maps), n MEM_STAT_INFO)))
#define <API key>(n) ((struct line_maps *)(<API key> (sizeof (struct line_maps), n MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>() ((struct <API key> *)(<API key> (sizeof (struct <API key>) MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((struct <API key> *)(<API key> (sizeof (struct <API key>), n MEM_STAT_INFO)))
#define ggc_alloc_htab() ((struct htab *)(<API key> (sizeof (struct htab) MEM_STAT_INFO)))
#define <API key>() ((struct htab *)(<API key> (sizeof (struct htab) MEM_STAT_INFO)))
#define ggc_alloc_vec_htab(n) ((struct htab *)(<API key> (sizeof (struct htab), n MEM_STAT_INFO)))
#define <API key>(n) ((struct htab *)(<API key> (sizeof (struct htab), n MEM_STAT_INFO)))
#define <API key>() ((struct location_adhoc_data *)(<API key> (sizeof (struct location_adhoc_data) MEM_STAT_INFO)))
#define <API key>() ((struct location_adhoc_data *)(<API key> (sizeof (struct location_adhoc_data) MEM_STAT_INFO)))
#define <API key>(n) ((struct location_adhoc_data *)(<API key> (sizeof (struct location_adhoc_data), n MEM_STAT_INFO)))
#define <API key>(n) ((struct location_adhoc_data *)(<API key> (sizeof (struct location_adhoc_data), n MEM_STAT_INFO)))
#define ggc_alloc_maps_info() ((struct maps_info *)(<API key> (sizeof (struct maps_info) MEM_STAT_INFO)))
#define <API key>() ((struct maps_info *)(<API key> (sizeof (struct maps_info) MEM_STAT_INFO)))
#define <API key>(n) ((struct maps_info *)(<API key> (sizeof (struct maps_info), n MEM_STAT_INFO)))
#define <API key>(n) ((struct maps_info *)(<API key> (sizeof (struct maps_info), n MEM_STAT_INFO)))
#define ggc_alloc_line_map() ((struct line_map *)(<API key> (sizeof (struct line_map) MEM_STAT_INFO)))
#define <API key>() ((struct line_map *)(<API key> (sizeof (struct line_map) MEM_STAT_INFO)))
#define <API key>(n) ((struct line_map *)(<API key> (sizeof (struct line_map), n MEM_STAT_INFO)))
#define <API key>(n) ((struct line_map *)(<API key> (sizeof (struct line_map), n MEM_STAT_INFO)))
#define ggc_alloc_map_u() ((union map_u *)(<API key> (sizeof (union map_u) MEM_STAT_INFO)))
#define <API key>() ((union map_u *)(<API key> (sizeof (union map_u) MEM_STAT_INFO)))
#define ggc_alloc_vec_map_u(n) ((union map_u *)(<API key> (sizeof (union map_u), n MEM_STAT_INFO)))
#define <API key>(n) ((union map_u *)(<API key> (sizeof (union map_u), n MEM_STAT_INFO)))
#define <API key>() ((struct line_map_macro *)(<API key> (sizeof (struct line_map_macro) MEM_STAT_INFO)))
#define <API key>() ((struct line_map_macro *)(<API key> (sizeof (struct line_map_macro) MEM_STAT_INFO)))
#define <API key>(n) ((struct line_map_macro *)(<API key> (sizeof (struct line_map_macro), n MEM_STAT_INFO)))
#define <API key>(n) ((struct line_map_macro *)(<API key> (sizeof (struct line_map_macro), n MEM_STAT_INFO)))
#define ggc_alloc_tree_node(SIZE) ((union tree_node *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE) ((union tree_node *)(<API key> (SIZE MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((union tree_node *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>(SIZE, n) ((union tree_node *)(<API key> (SIZE, n MEM_STAT_INFO)))
#define <API key>() ((struct cpp_hashnode *)(<API key> (sizeof (struct cpp_hashnode) MEM_STAT_INFO)))
#define <API key>() ((struct cpp_hashnode *)(<API key> (sizeof (struct cpp_hashnode) MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_hashnode *)(<API key> (sizeof (struct cpp_hashnode), n MEM_STAT_INFO)))
#define <API key>(n) ((struct cpp_hashnode *)(<API key> (sizeof (struct cpp_hashnode), n MEM_STAT_INFO)))
#define <API key>() ((struct line_map_ordinary *)(<API key> (sizeof (struct line_map_ordinary) MEM_STAT_INFO)))
#define <API key>() ((struct line_map_ordinary *)(<API key> (sizeof (struct line_map_ordinary) MEM_STAT_INFO)))
#define <API key>(n) ((struct line_map_ordinary *)(<API key> (sizeof (struct line_map_ordinary), n MEM_STAT_INFO)))
#define <API key>(n) ((struct line_map_ordinary *)(<API key> (sizeof (struct line_map_ordinary), n MEM_STAT_INFO)))
/* Allocators for known typedefs. */
#define ggc_alloc_attr() ((attr *)(<API key> (sizeof (attr) MEM_STAT_INFO)))
#define <API key>() ((attr *)(<API key> (sizeof (attr) MEM_STAT_INFO)))
#define ggc_alloc_vec_attr(n) ((attr *)(<API key> (sizeof (attr), n MEM_STAT_INFO)))
#define <API key>(n) ((attr *)(<API key> (sizeof (attr), n MEM_STAT_INFO)))
#define ggc_alloc_hash() ((hash *)(<API key> (sizeof (hash) MEM_STAT_INFO)))
#define <API key>() ((hash *)(<API key> (sizeof (hash) MEM_STAT_INFO)))
#define ggc_alloc_vec_hash(n) ((hash *)(<API key> (sizeof (hash), n MEM_STAT_INFO)))
#define <API key>(n) ((hash *)(<API key> (sizeof (hash), n MEM_STAT_INFO)))
#define <API key>() ((objc_map_t *)(<API key> (sizeof (objc_map_t) MEM_STAT_INFO)))
#define <API key>() ((objc_map_t *)(<API key> (sizeof (objc_map_t) MEM_STAT_INFO)))
#define <API key>(n) ((objc_map_t *)(<API key> (sizeof (objc_map_t), n MEM_STAT_INFO)))
#define <API key>(n) ((objc_map_t *)(<API key> (sizeof (objc_map_t), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((method_entry *)(<API key> (sizeof (method_entry) MEM_STAT_INFO)))
#define <API key>() ((method_entry *)(<API key> (sizeof (method_entry) MEM_STAT_INFO)))
#define <API key>(n) ((method_entry *)(<API key> (sizeof (method_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((method_entry *)(<API key> (sizeof (method_entry), n MEM_STAT_INFO)))
#define <API key>() ((constant_pool *)(<API key> (sizeof (constant_pool) MEM_STAT_INFO)))
#define <API key>() ((constant_pool *)(<API key> (sizeof (constant_pool) MEM_STAT_INFO)))
#define <API key>(n) ((constant_pool *)(<API key> (sizeof (constant_pool), n MEM_STAT_INFO)))
#define <API key>(n) ((constant_pool *)(<API key> (sizeof (constant_pool), n MEM_STAT_INFO)))
#define ggc_alloc_go_char_p() ((go_char_p *)(<API key> (sizeof (go_char_p) MEM_STAT_INFO)))
#define <API key>() ((go_char_p *)(<API key> (sizeof (go_char_p) MEM_STAT_INFO)))
#define <API key>(n) ((go_char_p *)(<API key> (sizeof (go_char_p), n MEM_STAT_INFO)))
#define <API key>(n) ((go_char_p *)(<API key> (sizeof (go_char_p), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((cp_token_cache_ptr *)(<API key> (sizeof (cp_token_cache_ptr) MEM_STAT_INFO)))
#define <API key>() ((cp_token_cache_ptr *)(<API key> (sizeof (cp_token_cache_ptr) MEM_STAT_INFO)))
#define <API key>(n) ((cp_token_cache_ptr *)(<API key> (sizeof (cp_token_cache_ptr), n MEM_STAT_INFO)))
#define <API key>(n) ((cp_token_cache_ptr *)(<API key> (sizeof (cp_token_cache_ptr), n MEM_STAT_INFO)))
#define <API key>() ((cp_token_position *)(<API key> (sizeof (cp_token_position) MEM_STAT_INFO)))
#define <API key>() ((cp_token_position *)(<API key> (sizeof (cp_token_position) MEM_STAT_INFO)))
#define <API key>(n) ((cp_token_position *)(<API key> (sizeof (cp_token_position), n MEM_STAT_INFO)))
#define <API key>(n) ((cp_token_position *)(<API key> (sizeof (cp_token_position), n MEM_STAT_INFO)))
#define <API key>() ((incomplete_var *)(<API key> (sizeof (incomplete_var) MEM_STAT_INFO)))
#define <API key>() ((incomplete_var *)(<API key> (sizeof (incomplete_var) MEM_STAT_INFO)))
#define <API key>(n) ((incomplete_var *)(<API key> (sizeof (incomplete_var), n MEM_STAT_INFO)))
#define <API key>(n) ((incomplete_var *)(<API key> (sizeof (incomplete_var), n MEM_STAT_INFO)))
#define <API key>() ((tree_pair_p *)(<API key> (sizeof (tree_pair_p) MEM_STAT_INFO)))
#define <API key>() ((tree_pair_p *)(<API key> (sizeof (tree_pair_p) MEM_STAT_INFO)))
#define <API key>(n) ((tree_pair_p *)(<API key> (sizeof (tree_pair_p), n MEM_STAT_INFO)))
#define <API key>(n) ((tree_pair_p *)(<API key> (sizeof (tree_pair_p), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((ptrmem_cst_t *)(<API key> (sizeof (ptrmem_cst_t) MEM_STAT_INFO)))
#define <API key>() ((ptrmem_cst_t *)(<API key> (sizeof (ptrmem_cst_t) MEM_STAT_INFO)))
#define <API key>(n) ((ptrmem_cst_t *)(<API key> (sizeof (ptrmem_cst_t), n MEM_STAT_INFO)))
#define <API key>(n) ((ptrmem_cst_t *)(<API key> (sizeof (ptrmem_cst_t), n MEM_STAT_INFO)))
#define <API key>() ((template_parm_index *)(<API key> (sizeof (template_parm_index) MEM_STAT_INFO)))
#define <API key>() ((template_parm_index *)(<API key> (sizeof (template_parm_index) MEM_STAT_INFO)))
#define <API key>(n) ((template_parm_index *)(<API key> (sizeof (template_parm_index), n MEM_STAT_INFO)))
#define <API key>(n) ((template_parm_index *)(<API key> (sizeof (template_parm_index), n MEM_STAT_INFO)))
#define <API key>() ((binding_entry *)(<API key> (sizeof (binding_entry) MEM_STAT_INFO)))
#define <API key>() ((binding_entry *)(<API key> (sizeof (binding_entry) MEM_STAT_INFO)))
#define <API key>(n) ((binding_entry *)(<API key> (sizeof (binding_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((binding_entry *)(<API key> (sizeof (binding_entry), n MEM_STAT_INFO)))
#define <API key>() ((binding_table *)(<API key> (sizeof (binding_table) MEM_STAT_INFO)))
#define <API key>() ((binding_table *)(<API key> (sizeof (binding_table) MEM_STAT_INFO)))
#define <API key>(n) ((binding_table *)(<API key> (sizeof (binding_table), n MEM_STAT_INFO)))
#define <API key>(n) ((binding_table *)(<API key> (sizeof (binding_table), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((pending_weak *)(<API key> (sizeof (pending_weak) MEM_STAT_INFO)))
#define <API key>() ((pending_weak *)(<API key> (sizeof (pending_weak) MEM_STAT_INFO)))
#define <API key>(n) ((pending_weak *)(<API key> (sizeof (pending_weak), n MEM_STAT_INFO)))
#define <API key>(n) ((pending_weak *)(<API key> (sizeof (pending_weak), n MEM_STAT_INFO)))
#define ggc_alloc_stmt_tree() ((stmt_tree *)(<API key> (sizeof (stmt_tree) MEM_STAT_INFO)))
#define <API key>() ((stmt_tree *)(<API key> (sizeof (stmt_tree) MEM_STAT_INFO)))
#define <API key>(n) ((stmt_tree *)(<API key> (sizeof (stmt_tree), n MEM_STAT_INFO)))
#define <API key>(n) ((stmt_tree *)(<API key> (sizeof (stmt_tree), n MEM_STAT_INFO)))
#define <API key>() ((tree_gc_vec *)(<API key> (sizeof (tree_gc_vec) MEM_STAT_INFO)))
#define <API key>() ((tree_gc_vec *)(<API key> (sizeof (tree_gc_vec) MEM_STAT_INFO)))
#define <API key>(n) ((tree_gc_vec *)(<API key> (sizeof (tree_gc_vec), n MEM_STAT_INFO)))
#define <API key>(n) ((tree_gc_vec *)(<API key> (sizeof (tree_gc_vec), n MEM_STAT_INFO)))
#define <API key>() ((const_char_p *)(<API key> (sizeof (const_char_p) MEM_STAT_INFO)))
#define <API key>() ((const_char_p *)(<API key> (sizeof (const_char_p) MEM_STAT_INFO)))
#define <API key>(n) ((const_char_p *)(<API key> (sizeof (const_char_p), n MEM_STAT_INFO)))
#define <API key>(n) ((const_char_p *)(<API key> (sizeof (const_char_p), n MEM_STAT_INFO)))
#define <API key>() ((c_binding_ptr *)(<API key> (sizeof (c_binding_ptr) MEM_STAT_INFO)))
#define <API key>() ((c_binding_ptr *)(<API key> (sizeof (c_binding_ptr) MEM_STAT_INFO)))
#define <API key>(n) ((c_binding_ptr *)(<API key> (sizeof (c_binding_ptr), n MEM_STAT_INFO)))
#define <API key>(n) ((c_binding_ptr *)(<API key> (sizeof (c_binding_ptr), n MEM_STAT_INFO)))
#define <API key>() ((c_goto_bindings_p *)(<API key> (sizeof (c_goto_bindings_p) MEM_STAT_INFO)))
#define <API key>() ((c_goto_bindings_p *)(<API key> (sizeof (c_goto_bindings_p) MEM_STAT_INFO)))
#define <API key>(n) ((c_goto_bindings_p *)(<API key> (sizeof (c_goto_bindings_p), n MEM_STAT_INFO)))
#define <API key>(n) ((c_goto_bindings_p *)(<API key> (sizeof (c_goto_bindings_p), n MEM_STAT_INFO)))
#define ggc_alloc_loop_info() ((loop_info *)(<API key> (sizeof (loop_info) MEM_STAT_INFO)))
#define <API key>() ((loop_info *)(<API key> (sizeof (loop_info) MEM_STAT_INFO)))
#define <API key>(n) ((loop_info *)(<API key> (sizeof (loop_info), n MEM_STAT_INFO)))
#define <API key>(n) ((loop_info *)(<API key> (sizeof (loop_info), n MEM_STAT_INFO)))
#define <API key>() ((range_check_info *)(<API key> (sizeof (range_check_info) MEM_STAT_INFO)))
#define <API key>() ((range_check_info *)(<API key> (sizeof (range_check_info) MEM_STAT_INFO)))
#define <API key>(n) ((range_check_info *)(<API key> (sizeof (range_check_info), n MEM_STAT_INFO)))
#define <API key>(n) ((range_check_info *)(<API key> (sizeof (range_check_info), n MEM_STAT_INFO)))
#define ggc_alloc_parm_attr() ((parm_attr *)(<API key> (sizeof (parm_attr) MEM_STAT_INFO)))
#define <API key>() ((parm_attr *)(<API key> (sizeof (parm_attr) MEM_STAT_INFO)))
#define <API key>(n) ((parm_attr *)(<API key> (sizeof (parm_attr), n MEM_STAT_INFO)))
#define <API key>(n) ((parm_attr *)(<API key> (sizeof (parm_attr), n MEM_STAT_INFO)))
#define <API key>() ((inline_summary_t *)(<API key> (sizeof (inline_summary_t) MEM_STAT_INFO)))
#define <API key>() ((inline_summary_t *)(<API key> (sizeof (inline_summary_t) MEM_STAT_INFO)))
#define <API key>(n) ((inline_summary_t *)(<API key> (sizeof (inline_summary_t), n MEM_STAT_INFO)))
#define <API key>(n) ((inline_summary_t *)(<API key> (sizeof (inline_summary_t), n MEM_STAT_INFO)))
#define <API key>() ((conditions *)(<API key> (sizeof (conditions) MEM_STAT_INFO)))
#define <API key>() ((conditions *)(<API key> (sizeof (conditions) MEM_STAT_INFO)))
#define <API key>(n) ((conditions *)(<API key> (sizeof (conditions), n MEM_STAT_INFO)))
#define <API key>(n) ((conditions *)(<API key> (sizeof (conditions), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((ipa_edge_args_t *)(<API key> (sizeof (ipa_edge_args_t) MEM_STAT_INFO)))
#define <API key>() ((ipa_edge_args_t *)(<API key> (sizeof (ipa_edge_args_t) MEM_STAT_INFO)))
#define <API key>(n) ((ipa_edge_args_t *)(<API key> (sizeof (ipa_edge_args_t), n MEM_STAT_INFO)))
#define <API key>(n) ((ipa_edge_args_t *)(<API key> (sizeof (ipa_edge_args_t), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((ipa_jump_func_t *)(<API key> (sizeof (ipa_jump_func_t) MEM_STAT_INFO)))
#define <API key>() ((ipa_jump_func_t *)(<API key> (sizeof (ipa_jump_func_t) MEM_STAT_INFO)))
#define <API key>(n) ((ipa_jump_func_t *)(<API key> (sizeof (ipa_jump_func_t), n MEM_STAT_INFO)))
#define <API key>(n) ((ipa_jump_func_t *)(<API key> (sizeof (ipa_jump_func_t), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((ipa_agg_jf_item_t *)(<API key> (sizeof (ipa_agg_jf_item_t) MEM_STAT_INFO)))
#define <API key>() ((ipa_agg_jf_item_t *)(<API key> (sizeof (ipa_agg_jf_item_t) MEM_STAT_INFO)))
#define <API key>(n) ((ipa_agg_jf_item_t *)(<API key> (sizeof (ipa_agg_jf_item_t), n MEM_STAT_INFO)))
#define <API key>(n) ((ipa_agg_jf_item_t *)(<API key> (sizeof (ipa_agg_jf_item_t), n MEM_STAT_INFO)))
#define ggc_alloc_char_ptr() ((char_ptr *)(<API key> (sizeof (char_ptr) MEM_STAT_INFO)))
#define <API key>() ((char_ptr *)(<API key> (sizeof (char_ptr) MEM_STAT_INFO)))
#define <API key>(n) ((char_ptr *)(<API key> (sizeof (char_ptr), n MEM_STAT_INFO)))
#define <API key>(n) ((char_ptr *)(<API key> (sizeof (char_ptr), n MEM_STAT_INFO)))
#define <API key>() ((use_operand_p *)(<API key> (sizeof (use_operand_p) MEM_STAT_INFO)))
#define <API key>() ((use_operand_p *)(<API key> (sizeof (use_operand_p) MEM_STAT_INFO)))
#define <API key>(n) ((use_operand_p *)(<API key> (sizeof (use_operand_p), n MEM_STAT_INFO)))
#define <API key>(n) ((use_operand_p *)(<API key> (sizeof (use_operand_p), n MEM_STAT_INFO)))
#define <API key>() ((def_operand_p *)(<API key> (sizeof (def_operand_p) MEM_STAT_INFO)))
#define <API key>() ((def_operand_p *)(<API key> (sizeof (def_operand_p) MEM_STAT_INFO)))
#define <API key>(n) ((def_operand_p *)(<API key> (sizeof (def_operand_p), n MEM_STAT_INFO)))
#define <API key>(n) ((def_operand_p *)(<API key> (sizeof (def_operand_p), n MEM_STAT_INFO)))
#define ggc_alloc_char_p() ((char_p *)(<API key> (sizeof (char_p) MEM_STAT_INFO)))
#define <API key>() ((char_p *)(<API key> (sizeof (char_p) MEM_STAT_INFO)))
#define <API key>(n) ((char_p *)(<API key> (sizeof (char_p), n MEM_STAT_INFO)))
#define <API key>(n) ((char_p *)(<API key> (sizeof (char_p), n MEM_STAT_INFO)))
#define <API key>() ((gimple_seq_node *)(<API key> (sizeof (gimple_seq_node) MEM_STAT_INFO)))
#define <API key>() ((gimple_seq_node *)(<API key> (sizeof (gimple_seq_node) MEM_STAT_INFO)))
#define <API key>(n) ((gimple_seq_node *)(<API key> (sizeof (gimple_seq_node), n MEM_STAT_INFO)))
#define <API key>(n) ((gimple_seq_node *)(<API key> (sizeof (gimple_seq_node), n MEM_STAT_INFO)))
#define <API key>() ((dummy_info_ref *)(<API key> (sizeof (dummy_info_ref) MEM_STAT_INFO)))
#define <API key>() ((dummy_info_ref *)(<API key> (sizeof (dummy_info_ref) MEM_STAT_INFO)))
#define <API key>(n) ((dummy_info_ref *)(<API key> (sizeof (dummy_info_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((dummy_info_ref *)(<API key> (sizeof (dummy_info_ref), n MEM_STAT_INFO)))
#define <API key>() ((compact_info_ref *)(<API key> (sizeof (compact_info_ref) MEM_STAT_INFO)))
#define <API key>() ((compact_info_ref *)(<API key> (sizeof (compact_info_ref) MEM_STAT_INFO)))
#define <API key>(n) ((compact_info_ref *)(<API key> (sizeof (compact_info_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((compact_info_ref *)(<API key> (sizeof (compact_info_ref), n MEM_STAT_INFO)))
#define ggc_alloc_chain_ref() ((chain_ref *)(<API key> (sizeof (chain_ref) MEM_STAT_INFO)))
#define <API key>() ((chain_ref *)(<API key> (sizeof (chain_ref) MEM_STAT_INFO)))
#define <API key>(n) ((chain_ref *)(<API key> (sizeof (chain_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((chain_ref *)(<API key> (sizeof (chain_ref), n MEM_STAT_INFO)))
#define <API key>() ((function_p *)(<API key> (sizeof (function_p) MEM_STAT_INFO)))
#define <API key>() ((function_p *)(<API key> (sizeof (function_p) MEM_STAT_INFO)))
#define <API key>(n) ((function_p *)(<API key> (sizeof (function_p), n MEM_STAT_INFO)))
#define <API key>(n) ((function_p *)(<API key> (sizeof (function_p), n MEM_STAT_INFO)))
#define ggc_alloc_eh_region() ((eh_region *)(<API key> (sizeof (eh_region) MEM_STAT_INFO)))
#define <API key>() ((eh_region *)(<API key> (sizeof (eh_region) MEM_STAT_INFO)))
#define <API key>(n) ((eh_region *)(<API key> (sizeof (eh_region), n MEM_STAT_INFO)))
#define <API key>(n) ((eh_region *)(<API key> (sizeof (eh_region), n MEM_STAT_INFO)))
#define ggc_alloc_eh_catch() ((eh_catch *)(<API key> (sizeof (eh_catch) MEM_STAT_INFO)))
#define <API key>() ((eh_catch *)(<API key> (sizeof (eh_catch) MEM_STAT_INFO)))
#define <API key>(n) ((eh_catch *)(<API key> (sizeof (eh_catch), n MEM_STAT_INFO)))
#define <API key>(n) ((eh_catch *)(<API key> (sizeof (eh_catch), n MEM_STAT_INFO)))
#define <API key>() ((eh_landing_pad *)(<API key> (sizeof (eh_landing_pad) MEM_STAT_INFO)))
#define <API key>() ((eh_landing_pad *)(<API key> (sizeof (eh_landing_pad) MEM_STAT_INFO)))
#define <API key>(n) ((eh_landing_pad *)(<API key> (sizeof (eh_landing_pad), n MEM_STAT_INFO)))
#define <API key>(n) ((eh_landing_pad *)(<API key> (sizeof (eh_landing_pad), n MEM_STAT_INFO)))
#define ggc_alloc_dchar_p() ((dchar_p *)(<API key> (sizeof (dchar_p) MEM_STAT_INFO)))
#define <API key>() ((dchar_p *)(<API key> (sizeof (dchar_p) MEM_STAT_INFO)))
#define <API key>(n) ((dchar_p *)(<API key> (sizeof (dchar_p), n MEM_STAT_INFO)))
#define <API key>(n) ((dchar_p *)(<API key> (sizeof (dchar_p), n MEM_STAT_INFO)))
#define <API key>() ((cached_dw_loc_list *)(<API key> (sizeof (cached_dw_loc_list) MEM_STAT_INFO)))
#define <API key>() ((cached_dw_loc_list *)(<API key> (sizeof (cached_dw_loc_list) MEM_STAT_INFO)))
#define <API key>(n) ((cached_dw_loc_list *)(<API key> (sizeof (cached_dw_loc_list), n MEM_STAT_INFO)))
#define <API key>(n) ((cached_dw_loc_list *)(<API key> (sizeof (cached_dw_loc_list), n MEM_STAT_INFO)))
#define <API key>() ((var_loc_list *)(<API key> (sizeof (var_loc_list) MEM_STAT_INFO)))
#define <API key>() ((var_loc_list *)(<API key> (sizeof (var_loc_list) MEM_STAT_INFO)))
#define <API key>(n) ((var_loc_list *)(<API key> (sizeof (var_loc_list), n MEM_STAT_INFO)))
#define <API key>(n) ((var_loc_list *)(<API key> (sizeof (var_loc_list), n MEM_STAT_INFO)))
#define <API key>() ((die_arg_entry *)(<API key> (sizeof (die_arg_entry) MEM_STAT_INFO)))
#define <API key>() ((die_arg_entry *)(<API key> (sizeof (die_arg_entry) MEM_STAT_INFO)))
#define <API key>(n) ((die_arg_entry *)(<API key> (sizeof (die_arg_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((die_arg_entry *)(<API key> (sizeof (die_arg_entry), n MEM_STAT_INFO)))
#define <API key>() ((limbo_die_node *)(<API key> (sizeof (limbo_die_node) MEM_STAT_INFO)))
#define <API key>() ((limbo_die_node *)(<API key> (sizeof (limbo_die_node) MEM_STAT_INFO)))
#define <API key>(n) ((limbo_die_node *)(<API key> (sizeof (limbo_die_node), n MEM_STAT_INFO)))
#define <API key>(n) ((limbo_die_node *)(<API key> (sizeof (limbo_die_node), n MEM_STAT_INFO)))
#define <API key>() ((comdat_type_node *)(<API key> (sizeof (comdat_type_node) MEM_STAT_INFO)))
#define <API key>() ((comdat_type_node *)(<API key> (sizeof (comdat_type_node) MEM_STAT_INFO)))
#define <API key>(n) ((comdat_type_node *)(<API key> (sizeof (comdat_type_node), n MEM_STAT_INFO)))
#define <API key>(n) ((comdat_type_node *)(<API key> (sizeof (comdat_type_node), n MEM_STAT_INFO)))
#define <API key>() ((macinfo_entry *)(<API key> (sizeof (macinfo_entry) MEM_STAT_INFO)))
#define <API key>() ((macinfo_entry *)(<API key> (sizeof (macinfo_entry) MEM_STAT_INFO)))
#define <API key>(n) ((macinfo_entry *)(<API key> (sizeof (macinfo_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((macinfo_entry *)(<API key> (sizeof (macinfo_entry), n MEM_STAT_INFO)))
#define <API key>() ((pubname_entry *)(<API key> (sizeof (pubname_entry) MEM_STAT_INFO)))
#define <API key>() ((pubname_entry *)(<API key> (sizeof (pubname_entry) MEM_STAT_INFO)))
#define <API key>(n) ((pubname_entry *)(<API key> (sizeof (pubname_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((pubname_entry *)(<API key> (sizeof (pubname_entry), n MEM_STAT_INFO)))
#define ggc_alloc_die_node() ((die_node *)(<API key> (sizeof (die_node) MEM_STAT_INFO)))
#define <API key>() ((die_node *)(<API key> (sizeof (die_node) MEM_STAT_INFO)))
#define <API key>(n) ((die_node *)(<API key> (sizeof (die_node), n MEM_STAT_INFO)))
#define <API key>(n) ((die_node *)(<API key> (sizeof (die_node), n MEM_STAT_INFO)))
#define <API key>() ((dw_attr_node *)(<API key> (sizeof (dw_attr_node) MEM_STAT_INFO)))
#define <API key>() ((dw_attr_node *)(<API key> (sizeof (dw_attr_node) MEM_STAT_INFO)))
#define <API key>(n) ((dw_attr_node *)(<API key> (sizeof (dw_attr_node), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_attr_node *)(<API key> (sizeof (dw_attr_node), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((dw_line_info_table *)(<API key> (sizeof (dw_line_info_table) MEM_STAT_INFO)))
#define <API key>() ((dw_line_info_table *)(<API key> (sizeof (dw_line_info_table) MEM_STAT_INFO)))
#define <API key>(n) ((dw_line_info_table *)(<API key> (sizeof (dw_line_info_table), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_line_info_table *)(<API key> (sizeof (dw_line_info_table), n MEM_STAT_INFO)))
#define <API key>() ((dw_line_info_entry *)(<API key> (sizeof (dw_line_info_entry) MEM_STAT_INFO)))
#define <API key>() ((dw_line_info_entry *)(<API key> (sizeof (dw_line_info_entry) MEM_STAT_INFO)))
#define <API key>(n) ((dw_line_info_entry *)(<API key> (sizeof (dw_line_info_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_line_info_entry *)(<API key> (sizeof (dw_line_info_entry), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>() ((<API key> *)(<API key> (sizeof (<API key>) MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>(n) ((<API key> *)(<API key> (sizeof (<API key>), n MEM_STAT_INFO)))
#define <API key>() ((dw_ranges_ref *)(<API key> (sizeof (dw_ranges_ref) MEM_STAT_INFO)))
#define <API key>() ((dw_ranges_ref *)(<API key> (sizeof (dw_ranges_ref) MEM_STAT_INFO)))
#define <API key>(n) ((dw_ranges_ref *)(<API key> (sizeof (dw_ranges_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_ranges_ref *)(<API key> (sizeof (dw_ranges_ref), n MEM_STAT_INFO)))
#define <API key>() ((pubname_ref *)(<API key> (sizeof (pubname_ref) MEM_STAT_INFO)))
#define <API key>() ((pubname_ref *)(<API key> (sizeof (pubname_ref) MEM_STAT_INFO)))
#define <API key>(n) ((pubname_ref *)(<API key> (sizeof (pubname_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((pubname_ref *)(<API key> (sizeof (pubname_ref), n MEM_STAT_INFO)))
#define <API key>() ((dw_line_info_ref *)(<API key> (sizeof (dw_line_info_ref) MEM_STAT_INFO)))
#define <API key>() ((dw_line_info_ref *)(<API key> (sizeof (dw_line_info_ref) MEM_STAT_INFO)))
#define <API key>(n) ((dw_line_info_ref *)(<API key> (sizeof (dw_line_info_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_line_info_ref *)(<API key> (sizeof (dw_line_info_ref), n MEM_STAT_INFO)))
#define <API key>() ((dw_attr_ref *)(<API key> (sizeof (dw_attr_ref) MEM_STAT_INFO)))
#define <API key>() ((dw_attr_ref *)(<API key> (sizeof (dw_attr_ref) MEM_STAT_INFO)))
#define <API key>(n) ((dw_attr_ref *)(<API key> (sizeof (dw_attr_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_attr_ref *)(<API key> (sizeof (dw_attr_ref), n MEM_STAT_INFO)))
#define <API key>() ((dw_loc_list_node *)(<API key> (sizeof (dw_loc_list_node) MEM_STAT_INFO)))
#define <API key>() ((dw_loc_list_node *)(<API key> (sizeof (dw_loc_list_node) MEM_STAT_INFO)))
#define <API key>(n) ((dw_loc_list_node *)(<API key> (sizeof (dw_loc_list_node), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_loc_list_node *)(<API key> (sizeof (dw_loc_list_node), n MEM_STAT_INFO)))
#define <API key>() ((addr_table_entry *)(<API key> (sizeof (addr_table_entry) MEM_STAT_INFO)))
#define <API key>() ((addr_table_entry *)(<API key> (sizeof (addr_table_entry) MEM_STAT_INFO)))
#define <API key>(n) ((addr_table_entry *)(<API key> (sizeof (addr_table_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((addr_table_entry *)(<API key> (sizeof (addr_table_entry), n MEM_STAT_INFO)))
#define <API key>() ((deferred_locations *)(<API key> (sizeof (deferred_locations) MEM_STAT_INFO)))
#define <API key>() ((deferred_locations *)(<API key> (sizeof (deferred_locations) MEM_STAT_INFO)))
#define <API key>(n) ((deferred_locations *)(<API key> (sizeof (deferred_locations), n MEM_STAT_INFO)))
#define <API key>(n) ((deferred_locations *)(<API key> (sizeof (deferred_locations), n MEM_STAT_INFO)))
#define <API key>() ((reg_saved_in_data *)(<API key> (sizeof (reg_saved_in_data) MEM_STAT_INFO)))
#define <API key>() ((reg_saved_in_data *)(<API key> (sizeof (reg_saved_in_data) MEM_STAT_INFO)))
#define <API key>(n) ((reg_saved_in_data *)(<API key> (sizeof (reg_saved_in_data), n MEM_STAT_INFO)))
#define <API key>(n) ((reg_saved_in_data *)(<API key> (sizeof (reg_saved_in_data), n MEM_STAT_INFO)))
#define <API key>() ((dw_cfi_row *)(<API key> (sizeof (dw_cfi_row) MEM_STAT_INFO)))
#define <API key>() ((dw_cfi_row *)(<API key> (sizeof (dw_cfi_row) MEM_STAT_INFO)))
#define <API key>(n) ((dw_cfi_row *)(<API key> (sizeof (dw_cfi_row), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_cfi_row *)(<API key> (sizeof (dw_cfi_row), n MEM_STAT_INFO)))
#define <API key>() ((dw_loc_descr_node *)(<API key> (sizeof (dw_loc_descr_node) MEM_STAT_INFO)))
#define <API key>() ((dw_loc_descr_node *)(<API key> (sizeof (dw_loc_descr_node) MEM_STAT_INFO)))
#define <API key>(n) ((dw_loc_descr_node *)(<API key> (sizeof (dw_loc_descr_node), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_loc_descr_node *)(<API key> (sizeof (dw_loc_descr_node), n MEM_STAT_INFO)))
#define <API key>() ((dw_val_node *)(<API key> (sizeof (dw_val_node) MEM_STAT_INFO)))
#define <API key>() ((dw_val_node *)(<API key> (sizeof (dw_val_node) MEM_STAT_INFO)))
#define <API key>(n) ((dw_val_node *)(<API key> (sizeof (dw_val_node), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_val_node *)(<API key> (sizeof (dw_val_node), n MEM_STAT_INFO)))
#define <API key>() ((dw_vec_const *)(<API key> (sizeof (dw_vec_const) MEM_STAT_INFO)))
#define <API key>() ((dw_vec_const *)(<API key> (sizeof (dw_vec_const) MEM_STAT_INFO)))
#define <API key>(n) ((dw_vec_const *)(<API key> (sizeof (dw_vec_const), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_vec_const *)(<API key> (sizeof (dw_vec_const), n MEM_STAT_INFO)))
#define <API key>() ((dw_cfa_location *)(<API key> (sizeof (dw_cfa_location) MEM_STAT_INFO)))
#define <API key>() ((dw_cfa_location *)(<API key> (sizeof (dw_cfa_location) MEM_STAT_INFO)))
#define <API key>(n) ((dw_cfa_location *)(<API key> (sizeof (dw_cfa_location), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_cfa_location *)(<API key> (sizeof (dw_cfa_location), n MEM_STAT_INFO)))
#define <API key>() ((dw_fde_node *)(<API key> (sizeof (dw_fde_node) MEM_STAT_INFO)))
#define <API key>() ((dw_fde_node *)(<API key> (sizeof (dw_fde_node) MEM_STAT_INFO)))
#define <API key>(n) ((dw_fde_node *)(<API key> (sizeof (dw_fde_node), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_fde_node *)(<API key> (sizeof (dw_fde_node), n MEM_STAT_INFO)))
#define <API key>() ((dw_fde_ref *)(<API key> (sizeof (dw_fde_ref) MEM_STAT_INFO)))
#define <API key>() ((dw_fde_ref *)(<API key> (sizeof (dw_fde_ref) MEM_STAT_INFO)))
#define <API key>(n) ((dw_fde_ref *)(<API key> (sizeof (dw_fde_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_fde_ref *)(<API key> (sizeof (dw_fde_ref), n MEM_STAT_INFO)))
#define ggc_alloc_cfi_vec() ((cfi_vec *)(<API key> (sizeof (cfi_vec) MEM_STAT_INFO)))
#define <API key>() ((cfi_vec *)(<API key> (sizeof (cfi_vec) MEM_STAT_INFO)))
#define <API key>(n) ((cfi_vec *)(<API key> (sizeof (cfi_vec), n MEM_STAT_INFO)))
#define <API key>(n) ((cfi_vec *)(<API key> (sizeof (cfi_vec), n MEM_STAT_INFO)))
#define <API key>() ((dw_cfi_node *)(<API key> (sizeof (dw_cfi_node) MEM_STAT_INFO)))
#define <API key>() ((dw_cfi_node *)(<API key> (sizeof (dw_cfi_node) MEM_STAT_INFO)))
#define <API key>(n) ((dw_cfi_node *)(<API key> (sizeof (dw_cfi_node), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_cfi_node *)(<API key> (sizeof (dw_cfi_node), n MEM_STAT_INFO)))
#define <API key>() ((dw_cfi_oprnd *)(<API key> (sizeof (dw_cfi_oprnd) MEM_STAT_INFO)))
#define <API key>() ((dw_cfi_oprnd *)(<API key> (sizeof (dw_cfi_oprnd) MEM_STAT_INFO)))
#define <API key>(n) ((dw_cfi_oprnd *)(<API key> (sizeof (dw_cfi_oprnd), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_cfi_oprnd *)(<API key> (sizeof (dw_cfi_oprnd), n MEM_STAT_INFO)))
#define <API key>() ((dw_loc_list_ref *)(<API key> (sizeof (dw_loc_list_ref) MEM_STAT_INFO)))
#define <API key>() ((dw_loc_list_ref *)(<API key> (sizeof (dw_loc_list_ref) MEM_STAT_INFO)))
#define <API key>(n) ((dw_loc_list_ref *)(<API key> (sizeof (dw_loc_list_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_loc_list_ref *)(<API key> (sizeof (dw_loc_list_ref), n MEM_STAT_INFO)))
#define <API key>() ((dw_loc_descr_ref *)(<API key> (sizeof (dw_loc_descr_ref) MEM_STAT_INFO)))
#define <API key>() ((dw_loc_descr_ref *)(<API key> (sizeof (dw_loc_descr_ref) MEM_STAT_INFO)))
#define <API key>(n) ((dw_loc_descr_ref *)(<API key> (sizeof (dw_loc_descr_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_loc_descr_ref *)(<API key> (sizeof (dw_loc_descr_ref), n MEM_STAT_INFO)))
#define <API key>() ((dw_cfi_ref *)(<API key> (sizeof (dw_cfi_ref) MEM_STAT_INFO)))
#define <API key>() ((dw_cfi_ref *)(<API key> (sizeof (dw_cfi_ref) MEM_STAT_INFO)))
#define <API key>(n) ((dw_cfi_ref *)(<API key> (sizeof (dw_cfi_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_cfi_ref *)(<API key> (sizeof (dw_cfi_ref), n MEM_STAT_INFO)))
#define <API key>() ((dw_val_ref *)(<API key> (sizeof (dw_val_ref) MEM_STAT_INFO)))
#define <API key>() ((dw_val_ref *)(<API key> (sizeof (dw_val_ref) MEM_STAT_INFO)))
#define <API key>(n) ((dw_val_ref *)(<API key> (sizeof (dw_val_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_val_ref *)(<API key> (sizeof (dw_val_ref), n MEM_STAT_INFO)))
#define <API key>() ((const_dw_die_ref *)(<API key> (sizeof (const_dw_die_ref) MEM_STAT_INFO)))
#define <API key>() ((const_dw_die_ref *)(<API key> (sizeof (const_dw_die_ref) MEM_STAT_INFO)))
#define <API key>(n) ((const_dw_die_ref *)(<API key> (sizeof (const_dw_die_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((const_dw_die_ref *)(<API key> (sizeof (const_dw_die_ref), n MEM_STAT_INFO)))
#define <API key>() ((dw_die_ref *)(<API key> (sizeof (dw_die_ref) MEM_STAT_INFO)))
#define <API key>() ((dw_die_ref *)(<API key> (sizeof (dw_die_ref) MEM_STAT_INFO)))
#define <API key>(n) ((dw_die_ref *)(<API key> (sizeof (dw_die_ref), n MEM_STAT_INFO)))
#define <API key>(n) ((dw_die_ref *)(<API key> (sizeof (dw_die_ref), n MEM_STAT_INFO)))
#define <API key>() ((alias_set_entry *)(<API key> (sizeof (alias_set_entry) MEM_STAT_INFO)))
#define <API key>() ((alias_set_entry *)(<API key> (sizeof (alias_set_entry) MEM_STAT_INFO)))
#define <API key>(n) ((alias_set_entry *)(<API key> (sizeof (alias_set_entry), n MEM_STAT_INFO)))
#define <API key>(n) ((alias_set_entry *)(<API key> (sizeof (alias_set_entry), n MEM_STAT_INFO)))
#define <API key>() ((cgraph_edge_p *)(<API key> (sizeof (cgraph_edge_p) MEM_STAT_INFO)))
#define <API key>() ((cgraph_edge_p *)(<API key> (sizeof (cgraph_edge_p) MEM_STAT_INFO)))
#define <API key>(n) ((cgraph_edge_p *)(<API key> (sizeof (cgraph_edge_p), n MEM_STAT_INFO)))
#define <API key>(n) ((cgraph_edge_p *)(<API key> (sizeof (cgraph_edge_p), n MEM_STAT_INFO)))
#define <API key>() ((varpool_node_ptr *)(<API key> (sizeof (varpool_node_ptr) MEM_STAT_INFO)))
#define <API key>() ((varpool_node_ptr *)(<API key> (sizeof (varpool_node_ptr) MEM_STAT_INFO)))
#define <API key>(n) ((varpool_node_ptr *)(<API key> (sizeof (varpool_node_ptr), n MEM_STAT_INFO)))
#define <API key>(n) ((varpool_node_ptr *)(<API key> (sizeof (varpool_node_ptr), n MEM_STAT_INFO)))
#define <API key>() ((cgraph_node_ptr *)(<API key> (sizeof (cgraph_node_ptr) MEM_STAT_INFO)))
#define <API key>() ((cgraph_node_ptr *)(<API key> (sizeof (cgraph_node_ptr) MEM_STAT_INFO)))
#define <API key>(n) ((cgraph_node_ptr *)(<API key> (sizeof (cgraph_node_ptr), n MEM_STAT_INFO)))
#define <API key>(n) ((cgraph_node_ptr *)(<API key> (sizeof (cgraph_node_ptr), n MEM_STAT_INFO)))
#define <API key>() ((ipa_replace_map_p *)(<API key> (sizeof (ipa_replace_map_p) MEM_STAT_INFO)))
#define <API key>() ((ipa_replace_map_p *)(<API key> (sizeof (ipa_replace_map_p) MEM_STAT_INFO)))
#define <API key>(n) ((ipa_replace_map_p *)(<API key> (sizeof (ipa_replace_map_p), n MEM_STAT_INFO)))
#define <API key>(n) ((ipa_replace_map_p *)(<API key> (sizeof (ipa_replace_map_p), n MEM_STAT_INFO)))
#define <API key>() ((ipa_ref_ptr *)(<API key> (sizeof (ipa_ref_ptr) MEM_STAT_INFO)))
#define <API key>() ((ipa_ref_ptr *)(<API key> (sizeof (ipa_ref_ptr) MEM_STAT_INFO)))
#define <API key>(n) ((ipa_ref_ptr *)(<API key> (sizeof (ipa_ref_ptr), n MEM_STAT_INFO)))
#define <API key>(n) ((ipa_ref_ptr *)(<API key> (sizeof (ipa_ref_ptr), n MEM_STAT_INFO)))
#define ggc_alloc_ipa_ref_t() ((ipa_ref_t *)(<API key> (sizeof (ipa_ref_t) MEM_STAT_INFO)))
#define <API key>() ((ipa_ref_t *)(<API key> (sizeof (ipa_ref_t) MEM_STAT_INFO)))
#define <API key>(n) ((ipa_ref_t *)(<API key> (sizeof (ipa_ref_t), n MEM_STAT_INFO)))
#define <API key>(n) ((ipa_ref_t *)(<API key> (sizeof (ipa_ref_t), n MEM_STAT_INFO)))
#define <API key>() ((const_symtab_node *)(<API key> (sizeof (const_symtab_node) MEM_STAT_INFO)))
#define <API key>() ((const_symtab_node *)(<API key> (sizeof (const_symtab_node) MEM_STAT_INFO)))
#define <API key>(n) ((const_symtab_node *)(<API key> (sizeof (const_symtab_node), n MEM_STAT_INFO)))
#define <API key>(n) ((const_symtab_node *)(<API key> (sizeof (const_symtab_node), n MEM_STAT_INFO)))
#define <API key>() ((symtab_node *)(<API key> (sizeof (symtab_node) MEM_STAT_INFO)))
#define <API key>() ((symtab_node *)(<API key> (sizeof (symtab_node) MEM_STAT_INFO)))
#define <API key>(n) ((symtab_node *)(<API key> (sizeof (symtab_node), n MEM_STAT_INFO)))
#define <API key>(n) ((symtab_node *)(<API key> (sizeof (symtab_node), n MEM_STAT_INFO)))
#define ggc_alloc_loop_p() ((loop_p *)(<API key> (sizeof (loop_p) MEM_STAT_INFO)))
#define <API key>() ((loop_p *)(<API key> (sizeof (loop_p) MEM_STAT_INFO)))
#define <API key>(n) ((loop_p *)(<API key> (sizeof (loop_p), n MEM_STAT_INFO)))
#define <API key>(n) ((loop_p *)(<API key> (sizeof (loop_p), n MEM_STAT_INFO)))
#define <API key>() ((temp_slot_p *)(<API key> (sizeof (temp_slot_p) MEM_STAT_INFO)))
#define <API key>() ((temp_slot_p *)(<API key> (sizeof (temp_slot_p) MEM_STAT_INFO)))
#define <API key>(n) ((temp_slot_p *)(<API key> (sizeof (temp_slot_p), n MEM_STAT_INFO)))
#define <API key>(n) ((temp_slot_p *)(<API key> (sizeof (temp_slot_p), n MEM_STAT_INFO)))
#define <API key>() ((call_site_record *)(<API key> (sizeof (call_site_record) MEM_STAT_INFO)))
#define <API key>() ((call_site_record *)(<API key> (sizeof (call_site_record) MEM_STAT_INFO)))
#define <API key>(n) ((call_site_record *)(<API key> (sizeof (call_site_record), n MEM_STAT_INFO)))
#define <API key>(n) ((call_site_record *)(<API key> (sizeof (call_site_record), n MEM_STAT_INFO)))
#define ggc_alloc_hashnode() ((hashnode *)(<API key> (sizeof (hashnode) MEM_STAT_INFO)))
#define <API key>() ((hashnode *)(<API key> (sizeof (hashnode) MEM_STAT_INFO)))
#define <API key>(n) ((hashnode *)(<API key> (sizeof (hashnode), n MEM_STAT_INFO)))
#define <API key>(n) ((hashnode *)(<API key> (sizeof (hashnode), n MEM_STAT_INFO)))
#define <API key>() ((ht_identifier_ptr *)(<API key> (sizeof (ht_identifier_ptr) MEM_STAT_INFO)))
#define <API key>() ((ht_identifier_ptr *)(<API key> (sizeof (ht_identifier_ptr) MEM_STAT_INFO)))
#define <API key>(n) ((ht_identifier_ptr *)(<API key> (sizeof (ht_identifier_ptr), n MEM_STAT_INFO)))
#define <API key>(n) ((ht_identifier_ptr *)(<API key> (sizeof (ht_identifier_ptr), n MEM_STAT_INFO)))
#define <API key>() ((builtin_info_type *)(<API key> (sizeof (builtin_info_type) MEM_STAT_INFO)))
#define <API key>() ((builtin_info_type *)(<API key> (sizeof (builtin_info_type) MEM_STAT_INFO)))
#define <API key>(n) ((builtin_info_type *)(<API key> (sizeof (builtin_info_type), n MEM_STAT_INFO)))
#define <API key>(n) ((builtin_info_type *)(<API key> (sizeof (builtin_info_type), n MEM_STAT_INFO)))
#define <API key>() ((ssa_use_operand_t *)(<API key> (sizeof (ssa_use_operand_t) MEM_STAT_INFO)))
#define <API key>() ((ssa_use_operand_t *)(<API key> (sizeof (ssa_use_operand_t) MEM_STAT_INFO)))
#define <API key>(n) ((ssa_use_operand_t *)(<API key> (sizeof (ssa_use_operand_t), n MEM_STAT_INFO)))
#define <API key>(n) ((ssa_use_operand_t *)(<API key> (sizeof (ssa_use_operand_t), n MEM_STAT_INFO)))
#define <API key>() ((constructor_elt *)(<API key> (sizeof (constructor_elt) MEM_STAT_INFO)))
#define <API key>() ((constructor_elt *)(<API key> (sizeof (constructor_elt) MEM_STAT_INFO)))
#define <API key>(n) ((constructor_elt *)(<API key> (sizeof (constructor_elt), n MEM_STAT_INFO)))
#define <API key>(n) ((constructor_elt *)(<API key> (sizeof (constructor_elt), n MEM_STAT_INFO)))
#define <API key>() ((bitmap_head *)(<API key> (sizeof (bitmap_head) MEM_STAT_INFO)))
#define <API key>() ((bitmap_head *)(<API key> (sizeof (bitmap_head) MEM_STAT_INFO)))
#define <API key>(n) ((bitmap_head *)(<API key> (sizeof (bitmap_head), n MEM_STAT_INFO)))
#define <API key>(n) ((bitmap_head *)(<API key> (sizeof (bitmap_head), n MEM_STAT_INFO)))
#define <API key>() ((bitmap_element *)(<API key> (sizeof (bitmap_element) MEM_STAT_INFO)))
#define <API key>() ((bitmap_element *)(<API key> (sizeof (bitmap_element) MEM_STAT_INFO)))
#define <API key>(n) ((bitmap_element *)(<API key> (sizeof (bitmap_element), n MEM_STAT_INFO)))
#define <API key>(n) ((bitmap_element *)(<API key> (sizeof (bitmap_element), n MEM_STAT_INFO)))
#define <API key>() ((splay_tree *)(<API key> (sizeof (splay_tree) MEM_STAT_INFO)))
#define <API key>() ((splay_tree *)(<API key> (sizeof (splay_tree) MEM_STAT_INFO)))
#define <API key>(n) ((splay_tree *)(<API key> (sizeof (splay_tree), n MEM_STAT_INFO)))
#define <API key>(n) ((splay_tree *)(<API key> (sizeof (splay_tree), n MEM_STAT_INFO)))
#define <API key>() ((splay_tree_node *)(<API key> (sizeof (splay_tree_node) MEM_STAT_INFO)))
#define <API key>() ((splay_tree_node *)(<API key> (sizeof (splay_tree_node) MEM_STAT_INFO)))
#define <API key>(n) ((splay_tree_node *)(<API key> (sizeof (splay_tree_node), n MEM_STAT_INFO)))
#define <API key>(n) ((splay_tree_node *)(<API key> (sizeof (splay_tree_node), n MEM_STAT_INFO)))
#define ggc_alloc_htab_t() ((htab_t *)(<API key> (sizeof (htab_t) MEM_STAT_INFO)))
#define <API key>() ((htab_t *)(<API key> (sizeof (htab_t) MEM_STAT_INFO)))
#define <API key>(n) ((htab_t *)(<API key> (sizeof (htab_t), n MEM_STAT_INFO)))
#define <API key>(n) ((htab_t *)(<API key> (sizeof (htab_t), n MEM_STAT_INFO)))
#define <API key>() ((const_basic_block *)(<API key> (sizeof (const_basic_block) MEM_STAT_INFO)))
#define <API key>() ((const_basic_block *)(<API key> (sizeof (const_basic_block) MEM_STAT_INFO)))
#define <API key>(n) ((const_basic_block *)(<API key> (sizeof (const_basic_block), n MEM_STAT_INFO)))
#define <API key>(n) ((const_basic_block *)(<API key> (sizeof (const_basic_block), n MEM_STAT_INFO)))
#define <API key>() ((basic_block *)(<API key> (sizeof (basic_block) MEM_STAT_INFO)))
#define <API key>() ((basic_block *)(<API key> (sizeof (basic_block) MEM_STAT_INFO)))
#define <API key>(n) ((basic_block *)(<API key> (sizeof (basic_block), n MEM_STAT_INFO)))
#define <API key>(n) ((basic_block *)(<API key> (sizeof (basic_block), n MEM_STAT_INFO)))
#define <API key>() ((const_edge *)(<API key> (sizeof (const_edge) MEM_STAT_INFO)))
#define <API key>() ((const_edge *)(<API key> (sizeof (const_edge) MEM_STAT_INFO)))
#define <API key>(n) ((const_edge *)(<API key> (sizeof (const_edge), n MEM_STAT_INFO)))
#define <API key>(n) ((const_edge *)(<API key> (sizeof (const_edge), n MEM_STAT_INFO)))
#define ggc_alloc_edge() ((edge *)(<API key> (sizeof (edge) MEM_STAT_INFO)))
#define <API key>() ((edge *)(<API key> (sizeof (edge) MEM_STAT_INFO)))
#define ggc_alloc_vec_edge(n) ((edge *)(<API key> (sizeof (edge), n MEM_STAT_INFO)))
#define <API key>(n) ((edge *)(<API key> (sizeof (edge), n MEM_STAT_INFO)))
#define <API key>() ((gimple_seq *)(<API key> (sizeof (gimple_seq) MEM_STAT_INFO)))
#define <API key>() ((gimple_seq *)(<API key> (sizeof (gimple_seq) MEM_STAT_INFO)))
#define <API key>(n) ((gimple_seq *)(<API key> (sizeof (gimple_seq), n MEM_STAT_INFO)))
#define <API key>(n) ((gimple_seq *)(<API key> (sizeof (gimple_seq), n MEM_STAT_INFO)))
#define <API key>() ((const_gimple *)(<API key> (sizeof (const_gimple) MEM_STAT_INFO)))
#define <API key>() ((const_gimple *)(<API key> (sizeof (const_gimple) MEM_STAT_INFO)))
#define <API key>(n) ((const_gimple *)(<API key> (sizeof (const_gimple), n MEM_STAT_INFO)))
#define <API key>(n) ((const_gimple *)(<API key> (sizeof (const_gimple), n MEM_STAT_INFO)))
#define ggc_alloc_gimple() ((gimple *)(<API key> (sizeof (gimple) MEM_STAT_INFO)))
#define <API key>() ((gimple *)(<API key> (sizeof (gimple) MEM_STAT_INFO)))
#define <API key>(n) ((gimple *)(<API key> (sizeof (gimple), n MEM_STAT_INFO)))
#define <API key>(n) ((gimple *)(<API key> (sizeof (gimple), n MEM_STAT_INFO)))
#define <API key>() ((const_tree *)(<API key> (sizeof (const_tree) MEM_STAT_INFO)))
#define <API key>() ((const_tree *)(<API key> (sizeof (const_tree) MEM_STAT_INFO)))
#define <API key>(n) ((const_tree *)(<API key> (sizeof (const_tree), n MEM_STAT_INFO)))
#define <API key>(n) ((const_tree *)(<API key> (sizeof (const_tree), n MEM_STAT_INFO)))
#define ggc_alloc_tree() ((tree *)(<API key> (sizeof (tree) MEM_STAT_INFO)))
#define <API key>() ((tree *)(<API key> (sizeof (tree) MEM_STAT_INFO)))
#define ggc_alloc_vec_tree(n) ((tree *)(<API key> (sizeof (tree), n MEM_STAT_INFO)))
#define <API key>(n) ((tree *)(<API key> (sizeof (tree), n MEM_STAT_INFO)))
#define <API key>() ((const_rtvec *)(<API key> (sizeof (const_rtvec) MEM_STAT_INFO)))
#define <API key>() ((const_rtvec *)(<API key> (sizeof (const_rtvec) MEM_STAT_INFO)))
#define <API key>(n) ((const_rtvec *)(<API key> (sizeof (const_rtvec), n MEM_STAT_INFO)))
#define <API key>(n) ((const_rtvec *)(<API key> (sizeof (const_rtvec), n MEM_STAT_INFO)))
#define ggc_alloc_rtvec() ((rtvec *)(<API key> (sizeof (rtvec) MEM_STAT_INFO)))
#define <API key>() ((rtvec *)(<API key> (sizeof (rtvec) MEM_STAT_INFO)))
#define ggc_alloc_vec_rtvec(n) ((rtvec *)(<API key> (sizeof (rtvec), n MEM_STAT_INFO)))
#define <API key>(n) ((rtvec *)(<API key> (sizeof (rtvec), n MEM_STAT_INFO)))
#define ggc_alloc_const_rtx() ((const_rtx *)(<API key> (sizeof (const_rtx) MEM_STAT_INFO)))
#define <API key>() ((const_rtx *)(<API key> (sizeof (const_rtx) MEM_STAT_INFO)))
#define <API key>(n) ((const_rtx *)(<API key> (sizeof (const_rtx), n MEM_STAT_INFO)))
#define <API key>(n) ((const_rtx *)(<API key> (sizeof (const_rtx), n MEM_STAT_INFO)))
#define ggc_alloc_rtx() ((rtx *)(<API key> (sizeof (rtx) MEM_STAT_INFO)))
#define <API key>() ((rtx *)(<API key> (sizeof (rtx) MEM_STAT_INFO)))
#define ggc_alloc_vec_rtx(n) ((rtx *)(<API key> (sizeof (rtx), n MEM_STAT_INFO)))
#define <API key>(n) ((rtx *)(<API key> (sizeof (rtx), n MEM_STAT_INFO)))
#define <API key>() ((const_bitmap *)(<API key> (sizeof (const_bitmap) MEM_STAT_INFO)))
#define <API key>() ((const_bitmap *)(<API key> (sizeof (const_bitmap) MEM_STAT_INFO)))
#define <API key>(n) ((const_bitmap *)(<API key> (sizeof (const_bitmap), n MEM_STAT_INFO)))
#define <API key>(n) ((const_bitmap *)(<API key> (sizeof (const_bitmap), n MEM_STAT_INFO)))
#define ggc_alloc_bitmap() ((bitmap *)(<API key> (sizeof (bitmap) MEM_STAT_INFO)))
#define <API key>() ((bitmap *)(<API key> (sizeof (bitmap) MEM_STAT_INFO)))
#define <API key>(n) ((bitmap *)(<API key> (sizeof (bitmap), n MEM_STAT_INFO)))
#define <API key>(n) ((bitmap *)(<API key> (sizeof (bitmap), n MEM_STAT_INFO)))
#define ggc_alloc_PTR() ((PTR *)(<API key> (sizeof (PTR) MEM_STAT_INFO)))
#define <API key>() ((PTR *)(<API key> (sizeof (PTR) MEM_STAT_INFO)))
#define ggc_alloc_vec_PTR(n) ((PTR *)(<API key> (sizeof (PTR), n MEM_STAT_INFO)))
#define <API key>(n) ((PTR *)(<API key> (sizeof (PTR), n MEM_STAT_INFO)))
/* GC marker procedures. */
/* Macros and declarations. */
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_9imp_entry(X) do { \
if (X != NULL) gt_ggc_mx_imp_entry (X);\
} while (0)
extern void gt_ggc_mx_imp_entry (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_5CPool(X) do { \
if (X != NULL) gt_ggc_mx_CPool (X);\
} while (0)
extern void gt_ggc_mx_CPool (void *);
#define gt_ggc_m_3JCF(X) do { \
if (X != NULL) gt_ggc_mx_JCF (X);\
} while (0)
extern void gt_ggc_mx_JCF (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_9cp_parser(X) do { \
if (X != NULL) gt_ggc_mx_cp_parser (X);\
} while (0)
extern void gt_ggc_mx_cp_parser (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_8cp_lexer(X) do { \
if (X != NULL) gt_ggc_mx_cp_lexer (X);\
} while (0)
extern void gt_ggc_mx_cp_lexer (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_8c_parser(X) do { \
if (X != NULL) gt_ggc_mx_c_parser (X);\
} while (0)
extern void gt_ggc_mx_c_parser (void *);
#define gt_ggc_m_9opt_stack(X) do { \
if (X != NULL) gt_ggc_mx_opt_stack (X);\
} while (0)
extern void gt_ggc_mx_opt_stack (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_7c_scope(X) do { \
if (X != NULL) gt_ggc_mx_c_scope (X);\
} while (0)
extern void gt_ggc_mx_c_scope (void *);
#define gt_ggc_m_9c_binding(X) do { \
if (X != NULL) gt_ggc_mx_c_binding (X);\
} while (0)
extern void gt_ggc_mx_c_binding (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_9elab_info(X) do { \
if (X != NULL) gt_ggc_mx_elab_info (X);\
} while (0)
extern void gt_ggc_mx_elab_info (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_9type_hash(X) do { \
if (X != NULL) gt_ggc_mx_type_hash (X);\
} while (0)
extern void gt_ggc_mx_type_hash (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_7chain_t(X) do { \
if (X != NULL) gt_ggc_mx_chain_t (X);\
} while (0)
extern void gt_ggc_mx_chain_t (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_8typeinfo(X) do { \
if (X != NULL) gt_ggc_mx_typeinfo (X);\
} while (0)
extern void gt_ggc_mx_typeinfo (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_8asm_node(X) do { \
if (X != NULL) gt_ggc_mx_asm_node (X);\
} while (0)
extern void gt_ggc_mx_asm_node (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_4loop(X) do { \
if (X != NULL) gt_ggc_mx_loop (X);\
} while (0)
extern void gt_ggc_mx_loop (void *);
#define gt_ggc_m_9loop_exit(X) do { \
if (X != NULL) gt_ggc_mx_loop_exit (X);\
} while (0)
extern void gt_ggc_mx_loop_exit (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_5loops(X) do { \
if (X != NULL) gt_ggc_mx_loops (X);\
} while (0)
extern void gt_ggc_mx_loops (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_9eh_status(X) do { \
if (X != NULL) gt_ggc_mx_eh_status (X);\
} while (0)
extern void gt_ggc_mx_eh_status (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_9temp_slot(X) do { \
if (X != NULL) gt_ggc_mx_temp_slot (X);\
} while (0)
extern void gt_ggc_mx_temp_slot (void *);
#define gt_ggc_m_9gimple_df(X) do { \
if (X != NULL) gt_ggc_mx_gimple_df (X);\
} while (0)
extern void gt_ggc_mx_gimple_df (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_8tree_map(X) do { \
if (X != NULL) gt_ggc_mx_tree_map (X);\
} while (0)
extern void gt_ggc_mx_tree_map (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_9lang_decl(X) do { \
if (X != NULL) gt_ggc_mx_lang_decl (X);\
} while (0)
extern void gt_ggc_mx_lang_decl (void *);
#define gt_ggc_m_9lang_type(X) do { \
if (X != NULL) gt_ggc_mx_lang_type (X);\
} while (0)
extern void gt_ggc_mx_lang_type (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_8function(X) do { \
if (X != NULL) gt_ggc_mx_function (X);\
} while (0)
extern void gt_ggc_mx_function (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_9reg_attrs(X) do { \
if (X != NULL) gt_ggc_mx_reg_attrs (X);\
} while (0)
extern void gt_ggc_mx_reg_attrs (void *);
#define gt_ggc_m_9mem_attrs(X) do { \
if (X != NULL) gt_ggc_mx_mem_attrs (X);\
} while (0)
extern void gt_ggc_mx_mem_attrs (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_8edge_def(X) do { \
if (X != NULL) gt_ggc_mx_edge_def (X);\
} while (0)
extern void gt_ggc_mx_edge_def (void *);
#define gt_ggc_m_7section(X) do { \
if (X != NULL) gt_ggc_mx_section (X);\
} while (0)
extern void gt_ggc_mx_section (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_9rtvec_def(X) do { \
if (X != NULL) gt_ggc_mx_rtvec_def (X);\
} while (0)
extern void gt_ggc_mx_rtvec_def (void *);
#define gt_ggc_m_7rtx_def(X) do { \
if (X != NULL) gt_ggc_mx_rtx_def (X);\
} while (0)
extern void gt_ggc_mx_rtx_def (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_ggc_m_6answer(X) do { \
if (X != NULL) gt_ggc_mx_answer (X);\
} while (0)
extern void gt_ggc_mx_answer (void *);
#define gt_ggc_m_9cpp_macro(X) do { \
if (X != NULL) gt_ggc_mx_cpp_macro (X);\
} while (0)
extern void gt_ggc_mx_cpp_macro (void *);
#define gt_ggc_m_9cpp_token(X) do { \
if (X != NULL) gt_ggc_mx_cpp_token (X);\
} while (0)
extern void gt_ggc_mx_cpp_token (void *);
#define gt_ggc_m_9line_maps(X) do { \
if (X != NULL) gt_ggc_mx_line_maps (X);\
} while (0)
extern void gt_ggc_mx_line_maps (void *);
#define gt_ggc_m_9tree_node(X) do { \
if (X != NULL) gt_ggc_mx_tree_node (X);\
} while (0)
#define gt_ggc_mx_tree_node <API key>
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
/* functions code */
/* PCH type-walking procedures. */
/* Macros and declarations. */
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_9imp_entry(X) do { \
if (X != NULL) gt_pch_nx_imp_entry (X);\
} while (0)
extern void gt_pch_nx_imp_entry (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_5CPool(X) do { \
if (X != NULL) gt_pch_nx_CPool (X);\
} while (0)
extern void gt_pch_nx_CPool (void *);
#define gt_pch_n_3JCF(X) do { \
if (X != NULL) gt_pch_nx_JCF (X);\
} while (0)
extern void gt_pch_nx_JCF (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_9cp_parser(X) do { \
if (X != NULL) gt_pch_nx_cp_parser (X);\
} while (0)
extern void gt_pch_nx_cp_parser (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_8cp_lexer(X) do { \
if (X != NULL) gt_pch_nx_cp_lexer (X);\
} while (0)
extern void gt_pch_nx_cp_lexer (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_8c_parser(X) do { \
if (X != NULL) gt_pch_nx_c_parser (X);\
} while (0)
extern void gt_pch_nx_c_parser (void *);
#define gt_pch_n_9opt_stack(X) do { \
if (X != NULL) gt_pch_nx_opt_stack (X);\
} while (0)
extern void gt_pch_nx_opt_stack (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_7c_scope(X) do { \
if (X != NULL) gt_pch_nx_c_scope (X);\
} while (0)
extern void gt_pch_nx_c_scope (void *);
#define gt_pch_n_9c_binding(X) do { \
if (X != NULL) gt_pch_nx_c_binding (X);\
} while (0)
extern void gt_pch_nx_c_binding (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_9elab_info(X) do { \
if (X != NULL) gt_pch_nx_elab_info (X);\
} while (0)
extern void gt_pch_nx_elab_info (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_9type_hash(X) do { \
if (X != NULL) gt_pch_nx_type_hash (X);\
} while (0)
extern void gt_pch_nx_type_hash (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_7chain_t(X) do { \
if (X != NULL) gt_pch_nx_chain_t (X);\
} while (0)
extern void gt_pch_nx_chain_t (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_8typeinfo(X) do { \
if (X != NULL) gt_pch_nx_typeinfo (X);\
} while (0)
extern void gt_pch_nx_typeinfo (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_8asm_node(X) do { \
if (X != NULL) gt_pch_nx_asm_node (X);\
} while (0)
extern void gt_pch_nx_asm_node (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_4loop(X) do { \
if (X != NULL) gt_pch_nx_loop (X);\
} while (0)
extern void gt_pch_nx_loop (void *);
#define gt_pch_n_9loop_exit(X) do { \
if (X != NULL) gt_pch_nx_loop_exit (X);\
} while (0)
extern void gt_pch_nx_loop_exit (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_5loops(X) do { \
if (X != NULL) gt_pch_nx_loops (X);\
} while (0)
extern void gt_pch_nx_loops (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_9eh_status(X) do { \
if (X != NULL) gt_pch_nx_eh_status (X);\
} while (0)
extern void gt_pch_nx_eh_status (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_9temp_slot(X) do { \
if (X != NULL) gt_pch_nx_temp_slot (X);\
} while (0)
extern void gt_pch_nx_temp_slot (void *);
#define gt_pch_n_9gimple_df(X) do { \
if (X != NULL) gt_pch_nx_gimple_df (X);\
} while (0)
extern void gt_pch_nx_gimple_df (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_8tree_map(X) do { \
if (X != NULL) gt_pch_nx_tree_map (X);\
} while (0)
extern void gt_pch_nx_tree_map (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_9lang_decl(X) do { \
if (X != NULL) gt_pch_nx_lang_decl (X);\
} while (0)
extern void gt_pch_nx_lang_decl (void *);
#define gt_pch_n_9lang_type(X) do { \
if (X != NULL) gt_pch_nx_lang_type (X);\
} while (0)
extern void gt_pch_nx_lang_type (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_8function(X) do { \
if (X != NULL) gt_pch_nx_function (X);\
} while (0)
extern void gt_pch_nx_function (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_9reg_attrs(X) do { \
if (X != NULL) gt_pch_nx_reg_attrs (X);\
} while (0)
extern void gt_pch_nx_reg_attrs (void *);
#define gt_pch_n_9mem_attrs(X) do { \
if (X != NULL) gt_pch_nx_mem_attrs (X);\
} while (0)
extern void gt_pch_nx_mem_attrs (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_8edge_def(X) do { \
if (X != NULL) gt_pch_nx_edge_def (X);\
} while (0)
extern void gt_pch_nx_edge_def (void *);
#define gt_pch_n_7section(X) do { \
if (X != NULL) gt_pch_nx_section (X);\
} while (0)
extern void gt_pch_nx_section (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_9rtvec_def(X) do { \
if (X != NULL) gt_pch_nx_rtvec_def (X);\
} while (0)
extern void gt_pch_nx_rtvec_def (void *);
#define gt_pch_n_7rtx_def(X) do { \
if (X != NULL) gt_pch_nx_rtx_def (X);\
} while (0)
extern void gt_pch_nx_rtx_def (void *);
#define <API key>(X) do { \
if (X != NULL) <API key> (X);\
} while (0)
extern void <API key> (void *);
#define gt_pch_n_6answer(X) do { \
if (X != NULL) gt_pch_nx_answer (X);\
} while (0)
extern void gt_pch_nx_answer (void *);
#define gt_pch_n_9cpp_macro(X) do { \
if (X != NULL) gt_pch_nx_cpp_macro (X);\
} while (0)
extern void gt_pch_nx_cpp_macro (void *);
#define gt_pch_n_9cpp_token(X) do { \
if (X != NULL) gt_pch_nx_cpp_token (X);\
} while (0)
extern void gt_pch_nx_cpp_token (void *);
#define gt_pch_n_9line_maps(X) do { \
if (X != NULL) gt_pch_nx_line_maps (X);\
} while (0)
extern void gt_pch_nx_line_maps (void *);
#define gt_pch_n_9tree_node(X) do { \
if (X != NULL) gt_pch_nx_tree_node (X);\
} while (0)
#define gt_pch_nx_tree_node <API key>
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
extern void <API key> (void *);
/* functions code */
/* Local pointer-walking routines. */
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9imp_entry
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_5CPool
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_3JCF
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9cp_parser
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8cp_lexer
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8c_parser
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9opt_stack
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7c_scope
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9c_binding
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9elab_info
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9type_hash
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7chain_t
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8typeinfo
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8asm_node
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_4loop
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9loop_exit
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_5loops
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9eh_status
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9temp_slot
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9gimple_df
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8tree_map
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9lang_decl
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9lang_type
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8function
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9reg_attrs
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9mem_attrs
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_8edge_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7section
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9rtvec_def
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_7rtx_def
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_6answer
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9cpp_macro
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9cpp_token
(void *, void *, gt_pointer_operator, void *);
extern void gt_pch_p_9line_maps
(void *, void *, gt_pointer_operator, void *);
#define gt_pch_p_9tree_node <API key>
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
extern void <API key>
(void *, void *, gt_pointer_operator, void *);
/* Splay tree callback allocators. */
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *);
extern void * <API key> (int, void *); |
#include <linux/pci.h>
#include <linux/pci-ats.h>
#include <linux/bitmap.h>
#include <linux/slab.h>
#include <linux/debugfs.h>
#include <linux/scatterlist.h>
#include <linux/dma-mapping.h>
#include <linux/iommu-helper.h>
#include <linux/iommu.h>
#include <linux/delay.h>
#include <linux/amd-iommu.h>
#include <asm/msidef.h>
#include <asm/proto.h>
#include <asm/iommu.h>
#include <asm/gart.h>
#include <asm/dma.h>
#include "amd_iommu_proto.h"
#include "amd_iommu_types.h"
#define CMD_SET_TYPE(cmd, t) ((cmd)->data[1] |= ((t) << 28))
#define LOOP_TIMEOUT 100000
static DEFINE_RWLOCK(<API key>);
/* A list of preallocated protection domains */
static LIST_HEAD(iommu_pd_list);
static DEFINE_SPINLOCK(iommu_pd_list_lock);
/* List of all available dev_data structures */
static LIST_HEAD(dev_data_list);
static DEFINE_SPINLOCK(dev_data_list_lock);
/*
* Domain for untranslated devices - only allocated
* if iommu=pt passed on kernel cmd line.
*/
static struct protection_domain *pt_domain;
static struct iommu_ops amd_iommu_ops;
/*
* general struct to manage commands send to an IOMMU
*/
struct iommu_cmd {
u32 data[4];
};
static void update_domain(struct protection_domain *domain);
static struct iommu_dev_data *alloc_dev_data(u16 devid)
{
struct iommu_dev_data *dev_data;
unsigned long flags;
dev_data = kzalloc(sizeof(*dev_data), GFP_KERNEL);
if (!dev_data)
return NULL;
dev_data->devid = devid;
atomic_set(&dev_data->bind, 0);
spin_lock_irqsave(&dev_data_list_lock, flags);
list_add_tail(&dev_data->dev_data_list, &dev_data_list);
<API key>(&dev_data_list_lock, flags);
return dev_data;
}
static void free_dev_data(struct iommu_dev_data *dev_data)
{
unsigned long flags;
spin_lock_irqsave(&dev_data_list_lock, flags);
list_del(&dev_data->dev_data_list);
<API key>(&dev_data_list_lock, flags);
kfree(dev_data);
}
static struct iommu_dev_data *search_dev_data(u16 devid)
{
struct iommu_dev_data *dev_data;
unsigned long flags;
spin_lock_irqsave(&dev_data_list_lock, flags);
list_for_each_entry(dev_data, &dev_data_list, dev_data_list) {
if (dev_data->devid == devid)
goto out_unlock;
}
dev_data = NULL;
out_unlock:
<API key>(&dev_data_list_lock, flags);
return dev_data;
}
static struct iommu_dev_data *find_dev_data(u16 devid)
{
struct iommu_dev_data *dev_data;
dev_data = search_dev_data(devid);
if (dev_data == NULL)
dev_data = alloc_dev_data(devid);
return dev_data;
}
static inline u16 get_device_id(struct device *dev)
{
struct pci_dev *pdev = to_pci_dev(dev);
return calc_devid(pdev->bus->number, pdev->devfn);
}
static struct iommu_dev_data *get_dev_data(struct device *dev)
{
return dev->archdata.iommu;
}
/*
* In this function the list of preallocated protection domains is traversed to
* find the domain for a specific device
*/
static struct dma_ops_domain *<API key>(u16 devid)
{
struct dma_ops_domain *entry, *ret = NULL;
unsigned long flags;
u16 alias = <API key>[devid];
if (list_empty(&iommu_pd_list))
return NULL;
spin_lock_irqsave(&iommu_pd_list_lock, flags);
list_for_each_entry(entry, &iommu_pd_list, list) {
if (entry->target_dev == devid ||
entry->target_dev == alias) {
ret = entry;
break;
}
}
<API key>(&iommu_pd_list_lock, flags);
return ret;
}
/*
* This function checks if the driver got a valid device from the caller to
* avoid dereferencing invalid pointers.
*/
static bool check_device(struct device *dev)
{
u16 devid;
if (!dev || !dev->dma_mask)
return false;
/* No device or no PCI device */
if (dev->bus != &pci_bus_type)
return false;
devid = get_device_id(dev);
/* Out of our scope? */
if (devid > amd_iommu_last_bdf)
return false;
if (<API key>[devid] == NULL)
return false;
return true;
}
static int iommu_init_device(struct device *dev)
{
struct iommu_dev_data *dev_data;
u16 alias;
if (dev->archdata.iommu)
return 0;
dev_data = find_dev_data(get_device_id(dev));
if (!dev_data)
return -ENOMEM;
alias = <API key>[dev_data->devid];
if (alias != dev_data->devid) {
struct iommu_dev_data *alias_data;
alias_data = find_dev_data(alias);
if (alias_data == NULL) {
pr_err("AMD-Vi: Warning: Unhandled device %s\n",
dev_name(dev));
free_dev_data(dev_data);
return -ENOTSUPP;
}
dev_data->alias_data = alias_data;
}
dev->archdata.iommu = dev_data;
return 0;
}
static void iommu_ignore_device(struct device *dev)
{
u16 devid, alias;
devid = get_device_id(dev);
alias = <API key>[devid];
memset(&amd_iommu_dev_table[devid], 0, sizeof(struct dev_table_entry));
memset(&amd_iommu_dev_table[alias], 0, sizeof(struct dev_table_entry));
<API key>[devid] = NULL;
<API key>[alias] = NULL;
}
static void iommu_uninit_device(struct device *dev)
{
/*
* Nothing to do here - we keep dev_data around for unplugged devices
* and reuse it when the device is re-plugged - not doing so would
* introduce a ton of races.
*/
}
void __init <API key>(void)
{
struct iommu_dev_data *dev_data, *n;
struct pci_dev *pdev = NULL;
for_each_pci_dev(pdev) {
if (!check_device(&pdev->dev))
continue;
iommu_uninit_device(&pdev->dev);
}
/* Free all of our dev_data structures */
<API key>(dev_data, n, &dev_data_list, dev_data_list)
free_dev_data(dev_data);
}
int __init <API key>(void)
{
struct pci_dev *pdev = NULL;
int ret = 0;
for_each_pci_dev(pdev) {
if (!check_device(&pdev->dev))
continue;
ret = iommu_init_device(&pdev->dev);
if (ret == -ENOTSUPP)
iommu_ignore_device(&pdev->dev);
else if (ret)
goto out_free;
}
return 0;
out_free:
<API key>();
return ret;
}
#ifdef <API key>
/*
* Initialization code for statistics collection
*/
<API key>(compl_wait);
<API key>(cnt_map_single);
<API key>(cnt_unmap_single);
<API key>(cnt_map_sg);
<API key>(cnt_unmap_sg);
<API key>(cnt_alloc_coherent);
<API key>(cnt_free_coherent);
<API key>(cross_page);
<API key>(domain_flush_single);
<API key>(domain_flush_all);
<API key>(alloced_io_mem);
<API key>(total_map_requests);
static struct dentry *stats_dir;
static struct dentry *de_fflush;
static void amd_iommu_stats_add(struct __iommu_counter *cnt)
{
if (stats_dir == NULL)
return;
cnt->dent = debugfs_create_u64(cnt->name, 0444, stats_dir,
&cnt->value);
}
static void <API key>(void)
{
stats_dir = debugfs_create_dir("amd-iommu", NULL);
if (stats_dir == NULL)
return;
de_fflush = debugfs_create_bool("fullflush", 0444, stats_dir,
(u32 *)&<API key>);
amd_iommu_stats_add(&compl_wait);
amd_iommu_stats_add(&cnt_map_single);
amd_iommu_stats_add(&cnt_unmap_single);
amd_iommu_stats_add(&cnt_map_sg);
amd_iommu_stats_add(&cnt_unmap_sg);
amd_iommu_stats_add(&cnt_alloc_coherent);
amd_iommu_stats_add(&cnt_free_coherent);
amd_iommu_stats_add(&cross_page);
amd_iommu_stats_add(&domain_flush_single);
amd_iommu_stats_add(&domain_flush_all);
amd_iommu_stats_add(&alloced_io_mem);
amd_iommu_stats_add(&total_map_requests);
}
#endif
static void dump_dte_entry(u16 devid)
{
int i;
for (i = 0; i < 8; ++i)
pr_err("AMD-Vi: DTE[%d]: %08x\n", i,
amd_iommu_dev_table[devid].data[i]);
}
static void dump_command(unsigned long phys_addr)
{
struct iommu_cmd *cmd = phys_to_virt(phys_addr);
int i;
for (i = 0; i < 4; ++i)
pr_err("AMD-Vi: CMD[%d]: %08x\n", i, cmd->data[i]);
}
static void iommu_print_event(struct amd_iommu *iommu, void *__evt)
{
u32 *event = __evt;
int type = (event[1] >> EVENT_TYPE_SHIFT) & EVENT_TYPE_MASK;
int devid = (event[0] >> EVENT_DEVID_SHIFT) & EVENT_DEVID_MASK;
int domid = (event[1] >> EVENT_DOMID_SHIFT) & EVENT_DOMID_MASK;
int flags = (event[1] >> EVENT_FLAGS_SHIFT) & EVENT_FLAGS_MASK;
u64 address = (u64)(((u64)event[3]) << 32) | event[2];
printk(KERN_ERR "AMD-Vi: Event logged [");
switch (type) {
case EVENT_TYPE_ILL_DEV:
printk("<API key> device=%02x:%02x.%x "
"address=0x%016llx flags=0x%04x]\n",
PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
address, flags);
dump_dte_entry(devid);
break;
case EVENT_TYPE_IO_FAULT:
printk("IO_PAGE_FAULT device=%02x:%02x.%x "
"domain=0x%04x address=0x%016llx flags=0x%04x]\n",
PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
domid, address, flags);
break;
case <API key>:
printk("<API key> device=%02x:%02x.%x "
"address=0x%016llx flags=0x%04x]\n",
PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
address, flags);
break;
case <API key>:
printk("<API key> device=%02x:%02x.%x "
"domain=0x%04x address=0x%016llx flags=0x%04x]\n",
PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
domid, address, flags);
break;
case EVENT_TYPE_ILL_CMD:
printk("<API key> address=0x%016llx]\n", address);
dump_command(address);
break;
case <API key>:
printk("<API key> address=0x%016llx "
"flags=0x%04x]\n", address, flags);
break;
case <API key>:
printk("IOTLB_INV_TIMEOUT device=%02x:%02x.%x "
"address=0x%016llx]\n",
PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
address);
break;
case <API key>:
printk("<API key> device=%02x:%02x.%x "
"address=0x%016llx flags=0x%04x]\n",
PCI_BUS(devid), PCI_SLOT(devid), PCI_FUNC(devid),
address, flags);
break;
default:
printk(KERN_ERR "UNKNOWN type=0x%02x]\n", type);
}
}
static void iommu_poll_events(struct amd_iommu *iommu)
{
u32 head, tail;
unsigned long flags;
spin_lock_irqsave(&iommu->lock, flags);
head = readl(iommu->mmio_base + <API key>);
tail = readl(iommu->mmio_base + <API key>);
while (head != tail) {
iommu_print_event(iommu, iommu->evt_buf + head);
head = (head + EVENT_ENTRY_SIZE) % iommu->evt_buf_size;
}
writel(head, iommu->mmio_base + <API key>);
<API key>(&iommu->lock, flags);
}
irqreturn_t <API key>(int irq, void *data)
{
struct amd_iommu *iommu;
for_each_iommu(iommu)
iommu_poll_events(iommu);
return IRQ_HANDLED;
}
irqreturn_t <API key>(int irq, void *data)
{
return IRQ_WAKE_THREAD;
}
static int wait_on_sem(volatile u64 *sem)
{
int i = 0;
while (*sem == 0 && i < LOOP_TIMEOUT) {
udelay(1);
i += 1;
}
if (i == LOOP_TIMEOUT) {
pr_alert("AMD-Vi: Completion-Wait loop timed out\n");
return -EIO;
}
return 0;
}
static void copy_cmd_to_buffer(struct amd_iommu *iommu,
struct iommu_cmd *cmd,
u32 tail)
{
u8 *target;
target = iommu->cmd_buf + tail;
tail = (tail + sizeof(*cmd)) % iommu->cmd_buf_size;
/* Copy command to buffer */
memcpy(target, cmd, sizeof(*cmd));
/* Tell the IOMMU about it */
writel(tail, iommu->mmio_base + <API key>);
}
static void <API key>(struct iommu_cmd *cmd, u64 address)
{
WARN_ON(address & 0x7ULL);
memset(cmd, 0, sizeof(*cmd));
cmd->data[0] = lower_32_bits(__pa(address)) | <API key>;
cmd->data[1] = upper_32_bits(__pa(address));
cmd->data[2] = 1;
CMD_SET_TYPE(cmd, CMD_COMPL_WAIT);
}
static void build_inv_dte(struct iommu_cmd *cmd, u16 devid)
{
memset(cmd, 0, sizeof(*cmd));
cmd->data[0] = devid;
CMD_SET_TYPE(cmd, CMD_INV_DEV_ENTRY);
}
static void <API key>(struct iommu_cmd *cmd, u64 address,
size_t size, u16 domid, int pde)
{
u64 pages;
int s;
pages = iommu_num_pages(address, size, PAGE_SIZE);
s = 0;
if (pages > 1) {
/*
* If we have to flush more than one page, flush all
* TLB entries for this domain
*/
address = <API key>;
s = 1;
}
address &= PAGE_MASK;
memset(cmd, 0, sizeof(*cmd));
cmd->data[1] |= domid;
cmd->data[2] = lower_32_bits(address);
cmd->data[3] = upper_32_bits(address);
CMD_SET_TYPE(cmd, CMD_INV_IOMMU_PAGES);
if (s) /* size bit - we flush more than one 4kb page */
cmd->data[2] |= <API key>;
if (pde) /* PDE bit - we wan't flush everything not only the PTEs */
cmd->data[2] |= <API key>;
}
static void <API key>(struct iommu_cmd *cmd, u16 devid, int qdep,
u64 address, size_t size)
{
u64 pages;
int s;
pages = iommu_num_pages(address, size, PAGE_SIZE);
s = 0;
if (pages > 1) {
/*
* If we have to flush more than one page, flush all
* TLB entries for this domain
*/
address = <API key>;
s = 1;
}
address &= PAGE_MASK;
memset(cmd, 0, sizeof(*cmd));
cmd->data[0] = devid;
cmd->data[0] |= (qdep & 0xff) << 24;
cmd->data[1] = devid;
cmd->data[2] = lower_32_bits(address);
cmd->data[3] = upper_32_bits(address);
CMD_SET_TYPE(cmd, CMD_INV_IOTLB_PAGES);
if (s)
cmd->data[2] |= <API key>;
}
static void build_inv_all(struct iommu_cmd *cmd)
{
memset(cmd, 0, sizeof(*cmd));
CMD_SET_TYPE(cmd, CMD_INV_ALL);
}
/*
* Writes the command to the IOMMUs command buffer and informs the
* hardware about the new command.
*/
static int <API key>(struct amd_iommu *iommu,
struct iommu_cmd *cmd,
bool sync)
{
u32 left, tail, head, next_tail;
unsigned long flags;
WARN_ON(iommu->cmd_buf_size & <API key>);
again:
spin_lock_irqsave(&iommu->lock, flags);
head = readl(iommu->mmio_base + <API key>);
tail = readl(iommu->mmio_base + <API key>);
next_tail = (tail + sizeof(*cmd)) % iommu->cmd_buf_size;
left = (head - next_tail) % iommu->cmd_buf_size;
if (left <= 2) {
struct iommu_cmd sync_cmd;
volatile u64 sem = 0;
int ret;
<API key>(&sync_cmd, (u64)&sem);
copy_cmd_to_buffer(iommu, &sync_cmd, tail);
<API key>(&iommu->lock, flags);
if ((ret = wait_on_sem(&sem)) != 0)
return ret;
goto again;
}
copy_cmd_to_buffer(iommu, cmd, tail);
/* We need to sync now to make sure all commands are processed */
iommu->need_sync = sync;
<API key>(&iommu->lock, flags);
return 0;
}
static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
{
return <API key>(iommu, cmd, true);
}
/*
* This function queues a completion wait command into the command
* buffer of an IOMMU
*/
static int <API key>(struct amd_iommu *iommu)
{
struct iommu_cmd cmd;
volatile u64 sem = 0;
int ret;
if (!iommu->need_sync)
return 0;
<API key>(&cmd, (u64)&sem);
ret = <API key>(iommu, &cmd, false);
if (ret)
return ret;
return wait_on_sem(&sem);
}
static int iommu_flush_dte(struct amd_iommu *iommu, u16 devid)
{
struct iommu_cmd cmd;
build_inv_dte(&cmd, devid);
return iommu_queue_command(iommu, &cmd);
}
static void iommu_flush_dte_all(struct amd_iommu *iommu)
{
u32 devid;
for (devid = 0; devid <= 0xffff; ++devid)
iommu_flush_dte(iommu, devid);
<API key>(iommu);
}
/*
* This function uses heavy locking and may disable irqs for some time. But
* this is no issue because it is only called during resume.
*/
static void iommu_flush_tlb_all(struct amd_iommu *iommu)
{
u32 dom_id;
for (dom_id = 0; dom_id <= 0xffff; ++dom_id) {
struct iommu_cmd cmd;
<API key>(&cmd, 0, <API key>,
dom_id, 1);
iommu_queue_command(iommu, &cmd);
}
<API key>(iommu);
}
static void iommu_flush_all(struct amd_iommu *iommu)
{
struct iommu_cmd cmd;
build_inv_all(&cmd);
iommu_queue_command(iommu, &cmd);
<API key>(iommu);
}
void <API key>(struct amd_iommu *iommu)
{
if (iommu_feature(iommu, FEATURE_IA)) {
iommu_flush_all(iommu);
} else {
iommu_flush_dte_all(iommu);
iommu_flush_tlb_all(iommu);
}
}
/*
* Command send function for flushing on-device TLB
*/
static int device_flush_iotlb(struct iommu_dev_data *dev_data,
u64 address, size_t size)
{
struct amd_iommu *iommu;
struct iommu_cmd cmd;
int qdep;
qdep = dev_data->ats.qdep;
iommu = <API key>[dev_data->devid];
<API key>(&cmd, dev_data->devid, qdep, address, size);
return iommu_queue_command(iommu, &cmd);
}
/*
* Command send function for invalidating a device table entry
*/
static int device_flush_dte(struct iommu_dev_data *dev_data)
{
struct amd_iommu *iommu;
int ret;
iommu = <API key>[dev_data->devid];
ret = iommu_flush_dte(iommu, dev_data->devid);
if (ret)
return ret;
if (dev_data->ats.enabled)
ret = device_flush_iotlb(dev_data, 0, ~0UL);
return ret;
}
/*
* TLB invalidation function which is called from the mapping functions.
* It invalidates a single PTE if the range to flush is within a single
* page. Otherwise it flushes the whole TLB of the IOMMU.
*/
static void <API key>(struct protection_domain *domain,
u64 address, size_t size, int pde)
{
struct iommu_dev_data *dev_data;
struct iommu_cmd cmd;
int ret = 0, i;
<API key>(&cmd, address, size, domain->id, pde);
for (i = 0; i < amd_iommus_present; ++i) {
if (!domain->dev_iommu[i])
continue;
/*
* Devices of this domain are behind this IOMMU
* We need a TLB flush
*/
ret |= iommu_queue_command(amd_iommus[i], &cmd);
}
list_for_each_entry(dev_data, &domain->dev_list, list) {
if (!dev_data->ats.enabled)
continue;
ret |= device_flush_iotlb(dev_data, address, size);
}
WARN_ON(ret);
}
static void domain_flush_pages(struct protection_domain *domain,
u64 address, size_t size)
{
<API key>(domain, address, size, 0);
}
/* Flush the whole IO/TLB for a given protection domain */
static void domain_flush_tlb(struct protection_domain *domain)
{
<API key>(domain, 0, <API key>, 0);
}
/* Flush the whole IO/TLB for a given protection domain - including PDE */
static void <API key>(struct protection_domain *domain)
{
<API key>(domain, 0, <API key>, 1);
}
static void <API key>(struct protection_domain *domain)
{
int i;
for (i = 0; i < amd_iommus_present; ++i) {
if (!domain->dev_iommu[i])
continue;
/*
* Devices of this domain are behind this IOMMU
* We need to wait for completion of all commands.
*/
<API key>(amd_iommus[i]);
}
}
/*
* This function flushes the DTEs for all devices in domain
*/
static void <API key>(struct protection_domain *domain)
{
struct iommu_dev_data *dev_data;
list_for_each_entry(dev_data, &domain->dev_list, list)
device_flush_dte(dev_data);
}
/*
* This function is used to add another level to an IO page table. Adding
* another level increases the size of the address space by 9 bits to a size up
* to 64 bits.
*/
static bool <API key>(struct protection_domain *domain,
gfp_t gfp)
{
u64 *pte;
if (domain->mode == PAGE_MODE_6_LEVEL)
/* address space already 64 bit large */
return false;
pte = (void *)get_zeroed_page(gfp);
if (!pte)
return false;
*pte = PM_LEVEL_PDE(domain->mode,
virt_to_phys(domain->pt_root));
domain->pt_root = pte;
domain->mode += 1;
domain->updated = true;
return true;
}
static u64 *alloc_pte(struct protection_domain *domain,
unsigned long address,
unsigned long page_size,
u64 **pte_page,
gfp_t gfp)
{
int level, end_lvl;
u64 *pte, *page;
BUG_ON(!is_power_of_2(page_size));
while (address > PM_LEVEL_SIZE(domain->mode))
<API key>(domain, gfp);
level = domain->mode - 1;
pte = &domain->pt_root[PM_LEVEL_INDEX(level, address)];
address = PAGE_SIZE_ALIGN(address, page_size);
end_lvl = PAGE_SIZE_LEVEL(page_size);
while (level > end_lvl) {
if (!IOMMU_PTE_PRESENT(*pte)) {
page = (u64 *)get_zeroed_page(gfp);
if (!page)
return NULL;
*pte = PM_LEVEL_PDE(level, virt_to_phys(page));
}
/* No level skipping support yet */
if (PM_PTE_LEVEL(*pte) != level)
return NULL;
level -= 1;
pte = IOMMU_PTE_PAGE(*pte);
if (pte_page && level == end_lvl)
*pte_page = pte;
pte = &pte[PM_LEVEL_INDEX(level, address)];
}
return pte;
}
/*
* This function checks if there is a PTE for a given dma address. If
* there is one, it returns the pointer to it.
*/
static u64 *fetch_pte(struct protection_domain *domain, unsigned long address)
{
int level;
u64 *pte;
if (address > PM_LEVEL_SIZE(domain->mode))
return NULL;
level = domain->mode - 1;
pte = &domain->pt_root[PM_LEVEL_INDEX(level, address)];
while (level > 0) {
/* Not Present */
if (!IOMMU_PTE_PRESENT(*pte))
return NULL;
/* Large PTE */
if (PM_PTE_LEVEL(*pte) == 0x07) {
unsigned long pte_mask, __pte;
/*
* If we have a series of large PTEs, make
* sure to return a pointer to the first one.
*/
pte_mask = PTE_PAGE_SIZE(*pte);
pte_mask = ~((PAGE_SIZE_PTE_COUNT(pte_mask) << 3) - 1);
__pte = ((unsigned long)pte) & pte_mask;
return (u64 *)__pte;
}
/* No level skipping support yet */
if (PM_PTE_LEVEL(*pte) != level)
return NULL;
level -= 1;
/* Walk to the next level */
pte = IOMMU_PTE_PAGE(*pte);
pte = &pte[PM_LEVEL_INDEX(level, address)];
}
return pte;
}
/*
* Generic mapping functions. It maps a physical address into a DMA
* address space. It allocates the page table pages if necessary.
* In the future it can be extended to a generic mapping function
* supporting all features of AMD IOMMU page tables like level skipping
* and full 64 bit address spaces.
*/
static int iommu_map_page(struct protection_domain *dom,
unsigned long bus_addr,
unsigned long phys_addr,
int prot,
unsigned long page_size)
{
u64 __pte, *pte;
int i, count;
if (!(prot & IOMMU_PROT_MASK))
return -EINVAL;
bus_addr = PAGE_ALIGN(bus_addr);
phys_addr = PAGE_ALIGN(phys_addr);
count = PAGE_SIZE_PTE_COUNT(page_size);
pte = alloc_pte(dom, bus_addr, page_size, NULL, GFP_KERNEL);
for (i = 0; i < count; ++i)
if (IOMMU_PTE_PRESENT(pte[i]))
return -EBUSY;
if (page_size > PAGE_SIZE) {
__pte = PAGE_SIZE_PTE(phys_addr, page_size);
__pte |= PM_LEVEL_ENC(7) | IOMMU_PTE_P | IOMMU_PTE_FC;
} else
__pte = phys_addr | IOMMU_PTE_P | IOMMU_PTE_FC;
if (prot & IOMMU_PROT_IR)
__pte |= IOMMU_PTE_IR;
if (prot & IOMMU_PROT_IW)
__pte |= IOMMU_PTE_IW;
for (i = 0; i < count; ++i)
pte[i] = __pte;
update_domain(dom);
return 0;
}
static unsigned long iommu_unmap_page(struct protection_domain *dom,
unsigned long bus_addr,
unsigned long page_size)
{
unsigned long long unmap_size, unmapped;
u64 *pte;
BUG_ON(!is_power_of_2(page_size));
unmapped = 0;
while (unmapped < page_size) {
pte = fetch_pte(dom, bus_addr);
if (!pte) {
/*
* No PTE for this address
* move forward in 4kb steps
*/
unmap_size = PAGE_SIZE;
} else if (PM_PTE_LEVEL(*pte) == 0) {
/* 4kb PTE found for this address */
unmap_size = PAGE_SIZE;
*pte = 0ULL;
} else {
int count, i;
/* Large PTE found which maps this address */
unmap_size = PTE_PAGE_SIZE(*pte);
count = PAGE_SIZE_PTE_COUNT(unmap_size);
for (i = 0; i < count; i++)
pte[i] = 0ULL;
}
bus_addr = (bus_addr & ~(unmap_size - 1)) + unmap_size;
unmapped += unmap_size;
}
BUG_ON(!is_power_of_2(unmapped));
return unmapped;
}
/*
* This function checks if a specific unity mapping entry is needed for
* this specific IOMMU.
*/
static int iommu_for_unity_map(struct amd_iommu *iommu,
struct unity_map_entry *entry)
{
u16 bdf, i;
for (i = entry->devid_start; i <= entry->devid_end; ++i) {
bdf = <API key>[i];
if (<API key>[bdf] == iommu)
return 1;
}
return 0;
}
/*
* This function actually applies the mapping to the page table of the
* dma_ops domain.
*/
static int dma_ops_unity_map(struct dma_ops_domain *dma_dom,
struct unity_map_entry *e)
{
u64 addr;
int ret;
for (addr = e->address_start; addr < e->address_end;
addr += PAGE_SIZE) {
ret = iommu_map_page(&dma_dom->domain, addr, addr, e->prot,
PAGE_SIZE);
if (ret)
return ret;
/*
* if unity mapping is in aperture range mark the page
* as allocated in the aperture
*/
if (addr < dma_dom->aperture_size)
__set_bit(addr >> PAGE_SHIFT,
dma_dom->aperture[0]->bitmap);
}
return 0;
}
/*
* Init the unity mappings for a specific IOMMU in the system
*
* Basically iterates over all unity mapping entries and applies them to
* the default domain DMA of that IOMMU if necessary.
*/
static int <API key>(struct amd_iommu *iommu)
{
struct unity_map_entry *entry;
int ret;
list_for_each_entry(entry, &amd_iommu_unity_map, list) {
if (!iommu_for_unity_map(iommu, entry))
continue;
ret = dma_ops_unity_map(iommu->default_dom, entry);
if (ret)
return ret;
}
return 0;
}
/*
* Inits the unity mappings required for a specific device
*/
static int <API key>(struct dma_ops_domain *dma_dom,
u16 devid)
{
struct unity_map_entry *e;
int ret;
list_for_each_entry(e, &amd_iommu_unity_map, list) {
if (!(devid >= e->devid_start && devid <= e->devid_end))
continue;
ret = dma_ops_unity_map(dma_dom, e);
if (ret)
return ret;
}
return 0;
}
/*
* The address allocator core functions.
*
* called with domain->lock held
*/
/*
* Used to reserve address ranges in the aperture (e.g. for exclusion
* ranges.
*/
static void <API key>(struct dma_ops_domain *dom,
unsigned long start_page,
unsigned int pages)
{
unsigned int i, last_page = dom->aperture_size >> PAGE_SHIFT;
if (start_page + pages > last_page)
pages = last_page - start_page;
for (i = start_page; i < start_page + pages; ++i) {
int index = i / <API key>;
int page = i % <API key>;
__set_bit(page, dom->aperture[index]->bitmap);
}
}
/*
* This function is used to add a new aperture range to an existing
* aperture in case of dma_ops domain allocation or address allocation
* failure.
*/
static int alloc_new_range(struct dma_ops_domain *dma_dom,
bool populate, gfp_t gfp)
{
int index = dma_dom->aperture_size >> <API key>;
struct amd_iommu *iommu;
unsigned long i, old_size;
#ifdef CONFIG_IOMMU_STRESS
populate = false;
#endif
if (index >= APERTURE_MAX_RANGES)
return -ENOMEM;
dma_dom->aperture[index] = kzalloc(sizeof(struct aperture_range), gfp);
if (!dma_dom->aperture[index])
return -ENOMEM;
dma_dom->aperture[index]->bitmap = (void *)get_zeroed_page(gfp);
if (!dma_dom->aperture[index]->bitmap)
goto out_free;
dma_dom->aperture[index]->offset = dma_dom->aperture_size;
if (populate) {
unsigned long address = dma_dom->aperture_size;
int i, num_ptes = <API key> / 512;
u64 *pte, *pte_page;
for (i = 0; i < num_ptes; ++i) {
pte = alloc_pte(&dma_dom->domain, address, PAGE_SIZE,
&pte_page, gfp);
if (!pte)
goto out_free;
dma_dom->aperture[index]->pte_pages[i] = pte_page;
address += APERTURE_RANGE_SIZE / 64;
}
}
old_size = dma_dom->aperture_size;
dma_dom->aperture_size += APERTURE_RANGE_SIZE;
/* Reserve address range used for MSI messages */
if (old_size < MSI_ADDR_BASE_LO &&
dma_dom->aperture_size > MSI_ADDR_BASE_LO) {
unsigned long spage;
int pages;
pages = iommu_num_pages(MSI_ADDR_BASE_LO, 0x10000, PAGE_SIZE);
spage = MSI_ADDR_BASE_LO >> PAGE_SHIFT;
<API key>(dma_dom, spage, pages);
}
/* Initialize the exclusion range if necessary */
for_each_iommu(iommu) {
if (iommu->exclusion_start &&
iommu->exclusion_start >= dma_dom->aperture[index]->offset
&& iommu->exclusion_start < dma_dom->aperture_size) {
unsigned long startpage;
int pages = iommu_num_pages(iommu->exclusion_start,
iommu->exclusion_length,
PAGE_SIZE);
startpage = iommu->exclusion_start >> PAGE_SHIFT;
<API key>(dma_dom, startpage, pages);
}
}
/*
* Check for areas already mapped as present in the new aperture
* range and mark those pages as reserved in the allocator. Such
* mappings may already exist as a result of requested unity
* mappings for devices.
*/
for (i = dma_dom->aperture[index]->offset;
i < dma_dom->aperture_size;
i += PAGE_SIZE) {
u64 *pte = fetch_pte(&dma_dom->domain, i);
if (!pte || !IOMMU_PTE_PRESENT(*pte))
continue;
<API key>(dma_dom, i >> PAGE_SHIFT, 1);
}
update_domain(&dma_dom->domain);
return 0;
out_free:
update_domain(&dma_dom->domain);
free_page((unsigned long)dma_dom->aperture[index]->bitmap);
kfree(dma_dom->aperture[index]);
dma_dom->aperture[index] = NULL;
return -ENOMEM;
}
static unsigned long dma_ops_area_alloc(struct device *dev,
struct dma_ops_domain *dom,
unsigned int pages,
unsigned long align_mask,
u64 dma_mask,
unsigned long start)
{
unsigned long next_bit = dom->next_address % APERTURE_RANGE_SIZE;
int max_index = dom->aperture_size >> <API key>;
int i = start >> <API key>;
unsigned long boundary_size;
unsigned long address = -1;
unsigned long limit;
next_bit >>= PAGE_SHIFT;
boundary_size = ALIGN(<API key>(dev) + 1,
PAGE_SIZE) >> PAGE_SHIFT;
for (;i < max_index; ++i) {
unsigned long offset = dom->aperture[i]->offset >> PAGE_SHIFT;
if (dom->aperture[i]->offset >= dma_mask)
break;
limit = <API key>(<API key>, offset,
dma_mask >> PAGE_SHIFT);
address = iommu_area_alloc(dom->aperture[i]->bitmap,
limit, next_bit, pages, 0,
boundary_size, align_mask);
if (address != -1) {
address = dom->aperture[i]->offset +
(address << PAGE_SHIFT);
dom->next_address = address + (pages << PAGE_SHIFT);
break;
}
next_bit = 0;
}
return address;
}
static unsigned long <API key>(struct device *dev,
struct dma_ops_domain *dom,
unsigned int pages,
unsigned long align_mask,
u64 dma_mask)
{
unsigned long address;
#ifdef CONFIG_IOMMU_STRESS
dom->next_address = 0;
dom->need_flush = true;
#endif
address = dma_ops_area_alloc(dev, dom, pages, align_mask,
dma_mask, dom->next_address);
if (address == -1) {
dom->next_address = 0;
address = dma_ops_area_alloc(dev, dom, pages, align_mask,
dma_mask, 0);
dom->need_flush = true;
}
if (unlikely(address == -1))
address = DMA_ERROR_CODE;
WARN_ON((address + (PAGE_SIZE*pages)) > dom->aperture_size);
return address;
}
/*
* The address free function.
*
* called with domain->lock held
*/
static void <API key>(struct dma_ops_domain *dom,
unsigned long address,
unsigned int pages)
{
unsigned i = address >> <API key>;
struct aperture_range *range = dom->aperture[i];
BUG_ON(i >= APERTURE_MAX_RANGES || range == NULL);
#ifdef CONFIG_IOMMU_STRESS
if (i < 4)
return;
#endif
if (address >= dom->next_address)
dom->need_flush = true;
address = (address % APERTURE_RANGE_SIZE) >> PAGE_SHIFT;
bitmap_clear(range->bitmap, address, pages);
}
/*
* This function adds a protection domain to the global protection domain list
*/
static void add_domain_to_list(struct protection_domain *domain)
{
unsigned long flags;
spin_lock_irqsave(&amd_iommu_pd_lock, flags);
list_add(&domain->list, &amd_iommu_pd_list);
<API key>(&amd_iommu_pd_lock, flags);
}
/*
* This function removes a protection domain to the global
* protection domain list
*/
static void <API key>(struct protection_domain *domain)
{
unsigned long flags;
spin_lock_irqsave(&amd_iommu_pd_lock, flags);
list_del(&domain->list);
<API key>(&amd_iommu_pd_lock, flags);
}
static u16 domain_id_alloc(void)
{
unsigned long flags;
int id;
write_lock_irqsave(&<API key>, flags);
id = find_first_zero_bit(<API key>, MAX_DOMAIN_ID);
BUG_ON(id == 0);
if (id > 0 && id < MAX_DOMAIN_ID)
__set_bit(id, <API key>);
else
id = 0;
<API key>(&<API key>, flags);
return id;
}
static void domain_id_free(int id)
{
unsigned long flags;
write_lock_irqsave(&<API key>, flags);
if (id > 0 && id < MAX_DOMAIN_ID)
__clear_bit(id, <API key>);
<API key>(&<API key>, flags);
}
static void free_pagetable(struct protection_domain *domain)
{
int i, j;
u64 *p1, *p2, *p3;
p1 = domain->pt_root;
if (!p1)
return;
for (i = 0; i < 512; ++i) {
if (!IOMMU_PTE_PRESENT(p1[i]))
continue;
p2 = IOMMU_PTE_PAGE(p1[i]);
for (j = 0; j < 512; ++j) {
if (!IOMMU_PTE_PRESENT(p2[j]))
continue;
p3 = IOMMU_PTE_PAGE(p2[j]);
free_page((unsigned long)p3);
}
free_page((unsigned long)p2);
}
free_page((unsigned long)p1);
domain->pt_root = NULL;
}
/*
* Free a domain, only used if something went wrong in the
* allocation path and we need to free an already allocated page table
*/
static void dma_ops_domain_free(struct dma_ops_domain *dom)
{
int i;
if (!dom)
return;
<API key>(&dom->domain);
free_pagetable(&dom->domain);
for (i = 0; i < APERTURE_MAX_RANGES; ++i) {
if (!dom->aperture[i])
continue;
free_page((unsigned long)dom->aperture[i]->bitmap);
kfree(dom->aperture[i]);
}
kfree(dom);
}
/*
* Allocates a new protection domain usable for the dma_ops functions.
* It also initializes the page table and the address allocator data
* structures required for the dma_ops interface
*/
static struct dma_ops_domain *<API key>(void)
{
struct dma_ops_domain *dma_dom;
dma_dom = kzalloc(sizeof(struct dma_ops_domain), GFP_KERNEL);
if (!dma_dom)
return NULL;
spin_lock_init(&dma_dom->domain.lock);
dma_dom->domain.id = domain_id_alloc();
if (dma_dom->domain.id == 0)
goto free_dma_dom;
INIT_LIST_HEAD(&dma_dom->domain.dev_list);
dma_dom->domain.mode = PAGE_MODE_2_LEVEL;
dma_dom->domain.pt_root = (void *)get_zeroed_page(GFP_KERNEL);
dma_dom->domain.flags = PD_DMA_OPS_MASK;
dma_dom->domain.priv = dma_dom;
if (!dma_dom->domain.pt_root)
goto free_dma_dom;
dma_dom->need_flush = false;
dma_dom->target_dev = 0xffff;
add_domain_to_list(&dma_dom->domain);
if (alloc_new_range(dma_dom, true, GFP_KERNEL))
goto free_dma_dom;
/*
* mark the first page as allocated so we never return 0 as
* a valid dma-address. So we can use 0 as error value
*/
dma_dom->aperture[0]->bitmap[0] = 1;
dma_dom->next_address = 0;
return dma_dom;
free_dma_dom:
dma_ops_domain_free(dma_dom);
return NULL;
}
/*
* little helper function to check whether a given protection domain is a
* dma_ops domain
*/
static bool dma_ops_domain(struct protection_domain *domain)
{
return domain->flags & PD_DMA_OPS_MASK;
}
static void set_dte_entry(u16 devid, struct protection_domain *domain, bool ats)
{
u64 pte_root = virt_to_phys(domain->pt_root);
u32 flags = 0;
pte_root |= (domain->mode & DEV_ENTRY_MODE_MASK)
<< <API key>;
pte_root |= IOMMU_PTE_IR | IOMMU_PTE_IW | IOMMU_PTE_P | IOMMU_PTE_TV;
if (ats)
flags |= DTE_FLAG_IOTLB;
amd_iommu_dev_table[devid].data[3] |= flags;
amd_iommu_dev_table[devid].data[2] = domain->id;
amd_iommu_dev_table[devid].data[1] = upper_32_bits(pte_root);
amd_iommu_dev_table[devid].data[0] = lower_32_bits(pte_root);
}
static void clear_dte_entry(u16 devid)
{
/* remove entry from the device table seen by the hardware */
amd_iommu_dev_table[devid].data[0] = IOMMU_PTE_P | IOMMU_PTE_TV;
amd_iommu_dev_table[devid].data[1] = 0;
amd_iommu_dev_table[devid].data[2] = 0;
<API key>(devid);
}
static void do_attach(struct iommu_dev_data *dev_data,
struct protection_domain *domain)
{
struct amd_iommu *iommu;
bool ats;
iommu = <API key>[dev_data->devid];
ats = dev_data->ats.enabled;
/* Update data structures */
dev_data->domain = domain;
list_add(&dev_data->list, &domain->dev_list);
set_dte_entry(dev_data->devid, domain, ats);
/* Do reference counting */
domain->dev_iommu[iommu->index] += 1;
domain->dev_cnt += 1;
/* Flush the DTE entry */
device_flush_dte(dev_data);
}
static void do_detach(struct iommu_dev_data *dev_data)
{
struct amd_iommu *iommu;
iommu = <API key>[dev_data->devid];
/* decrease reference counters */
dev_data->domain->dev_iommu[iommu->index] -= 1;
dev_data->domain->dev_cnt -= 1;
/* Update data structures */
dev_data->domain = NULL;
list_del(&dev_data->list);
clear_dte_entry(dev_data->devid);
/* Flush the DTE entry */
device_flush_dte(dev_data);
}
/*
* If a device is not yet associated with a domain, this function does
* assigns it visible for the hardware
*/
static int __attach_device(struct iommu_dev_data *dev_data,
struct protection_domain *domain)
{
int ret;
/* lock domain */
spin_lock(&domain->lock);
if (dev_data->alias_data != NULL) {
struct iommu_dev_data *alias_data = dev_data->alias_data;
/* Some sanity checks */
ret = -EBUSY;
if (alias_data->domain != NULL &&
alias_data->domain != domain)
goto out_unlock;
if (dev_data->domain != NULL &&
dev_data->domain != domain)
goto out_unlock;
/* Do real assignment */
if (alias_data->domain == NULL)
do_attach(alias_data, domain);
atomic_inc(&alias_data->bind);
}
if (dev_data->domain == NULL)
do_attach(dev_data, domain);
atomic_inc(&dev_data->bind);
ret = 0;
out_unlock:
/* ready */
spin_unlock(&domain->lock);
return ret;
}
/*
* If a device is not yet associated with a domain, this function does
* assigns it visible for the hardware
*/
static int attach_device(struct device *dev,
struct protection_domain *domain)
{
struct pci_dev *pdev = to_pci_dev(dev);
struct iommu_dev_data *dev_data;
unsigned long flags;
int ret;
dev_data = get_dev_data(dev);
if (amd_iommu_iotlb_sup && pci_enable_ats(pdev, PAGE_SHIFT) == 0) {
dev_data->ats.enabled = true;
dev_data->ats.qdep = pci_ats_queue_depth(pdev);
}
write_lock_irqsave(&<API key>, flags);
ret = __attach_device(dev_data, domain);
<API key>(&<API key>, flags);
/*
* We might boot into a crash-kernel here. The crashed kernel
* left the caches in the IOMMU dirty. So we have to flush
* here to evict all dirty stuff.
*/
<API key>(domain);
return ret;
}
/*
* Removes a device from a protection domain (unlocked)
*/
static void __detach_device(struct iommu_dev_data *dev_data)
{
struct protection_domain *domain;
unsigned long flags;
BUG_ON(!dev_data->domain);
domain = dev_data->domain;
spin_lock_irqsave(&domain->lock, flags);
if (dev_data->alias_data != NULL) {
struct iommu_dev_data *alias_data = dev_data->alias_data;
if (atomic_dec_and_test(&alias_data->bind))
do_detach(alias_data);
}
if (atomic_dec_and_test(&dev_data->bind))
do_detach(dev_data);
<API key>(&domain->lock, flags);
/*
* If we run in passthrough mode the device must be assigned to the
* passthrough domain if it is detached from any other domain.
* Make sure we can deassign from the pt_domain itself.
*/
if (iommu_pass_through &&
(dev_data->domain == NULL && domain != pt_domain))
__attach_device(dev_data, pt_domain);
}
/*
* Removes a device from a protection domain (with devtable_lock held)
*/
static void detach_device(struct device *dev)
{
struct iommu_dev_data *dev_data;
unsigned long flags;
dev_data = get_dev_data(dev);
/* lock device table */
write_lock_irqsave(&<API key>, flags);
__detach_device(dev_data);
<API key>(&<API key>, flags);
if (dev_data->ats.enabled) {
pci_disable_ats(to_pci_dev(dev));
dev_data->ats.enabled = false;
}
}
/*
* Find out the protection domain structure for a given PCI device. This
* will give us the pointer to the page table root for example.
*/
static struct protection_domain *domain_for_device(struct device *dev)
{
struct iommu_dev_data *dev_data;
struct protection_domain *dom = NULL;
unsigned long flags;
dev_data = get_dev_data(dev);
if (dev_data->domain)
return dev_data->domain;
if (dev_data->alias_data != NULL) {
struct iommu_dev_data *alias_data = dev_data->alias_data;
read_lock_irqsave(&<API key>, flags);
if (alias_data->domain != NULL) {
__attach_device(dev_data, alias_data->domain);
dom = alias_data->domain;
}
<API key>(&<API key>, flags);
}
return dom;
}
static int <API key>(struct notifier_block *nb,
unsigned long action, void *data)
{
struct device *dev = data;
u16 devid;
struct protection_domain *domain;
struct dma_ops_domain *dma_domain;
struct amd_iommu *iommu;
unsigned long flags;
if (!check_device(dev))
return 0;
devid = get_device_id(dev);
iommu = <API key>[devid];
switch (action) {
case <API key>:
domain = domain_for_device(dev);
if (!domain)
goto out;
if (iommu_pass_through)
break;
detach_device(dev);
break;
case <API key>:
iommu_init_device(dev);
domain = domain_for_device(dev);
/* allocate a protection domain if a device is added */
dma_domain = <API key>(devid);
if (dma_domain)
goto out;
dma_domain = <API key>();
if (!dma_domain)
goto out;
dma_domain->target_dev = devid;
spin_lock_irqsave(&iommu_pd_list_lock, flags);
list_add_tail(&dma_domain->list, &iommu_pd_list);
<API key>(&iommu_pd_list_lock, flags);
break;
case <API key>:
iommu_uninit_device(dev);
default:
goto out;
}
<API key>(iommu);
out:
return 0;
}
static struct notifier_block device_nb = {
.notifier_call = <API key>,
};
void <API key>(void)
{
<API key>(&pci_bus_type, &device_nb);
}
/*
* In the dma_ops path we only have the struct device. This function
* finds the corresponding IOMMU, the protection domain and the
* requestor id for a given device.
* If the device is not yet associated with a domain this is also done
* in this function.
*/
static struct protection_domain *get_domain(struct device *dev)
{
struct protection_domain *domain;
struct dma_ops_domain *dma_dom;
u16 devid = get_device_id(dev);
if (!check_device(dev))
return ERR_PTR(-EINVAL);
domain = domain_for_device(dev);
if (domain != NULL && !dma_ops_domain(domain))
return ERR_PTR(-EBUSY);
if (domain != NULL)
return domain;
/* Device not bount yet - bind it */
dma_dom = <API key>(devid);
if (!dma_dom)
dma_dom = <API key>[devid]->default_dom;
attach_device(dev, &dma_dom->domain);
DUMP_printk("Using protection domain %d for device %s\n",
dma_dom->domain.id, dev_name(dev));
return &dma_dom->domain;
}
static void update_device_table(struct protection_domain *domain)
{
struct iommu_dev_data *dev_data;
list_for_each_entry(dev_data, &domain->dev_list, list)
set_dte_entry(dev_data->devid, domain, dev_data->ats.enabled);
}
static void update_domain(struct protection_domain *domain)
{
if (!domain->updated)
return;
update_device_table(domain);
<API key>(domain);
<API key>(domain);
domain->updated = false;
}
/*
* This function fetches the PTE for a given address in the aperture
*/
static u64* dma_ops_get_pte(struct dma_ops_domain *dom,
unsigned long address)
{
struct aperture_range *aperture;
u64 *pte, *pte_page;
aperture = dom->aperture[<API key>(address)];
if (!aperture)
return NULL;
pte = aperture->pte_pages[APERTURE_PAGE_INDEX(address)];
if (!pte) {
pte = alloc_pte(&dom->domain, address, PAGE_SIZE, &pte_page,
GFP_ATOMIC);
aperture->pte_pages[APERTURE_PAGE_INDEX(address)] = pte_page;
} else
pte += PM_LEVEL_INDEX(0, address);
update_domain(&dom->domain);
return pte;
}
/*
* This is the generic map function. It maps one 4kb page at paddr to
* the given address in the DMA address space for the domain.
*/
static dma_addr_t dma_ops_domain_map(struct dma_ops_domain *dom,
unsigned long address,
phys_addr_t paddr,
int direction)
{
u64 *pte, __pte;
WARN_ON(address > dom->aperture_size);
paddr &= PAGE_MASK;
pte = dma_ops_get_pte(dom, address);
if (!pte)
return DMA_ERROR_CODE;
__pte = paddr | IOMMU_PTE_P | IOMMU_PTE_FC;
if (direction == DMA_TO_DEVICE)
__pte |= IOMMU_PTE_IR;
else if (direction == DMA_FROM_DEVICE)
__pte |= IOMMU_PTE_IW;
else if (direction == DMA_BIDIRECTIONAL)
__pte |= IOMMU_PTE_IR | IOMMU_PTE_IW;
WARN_ON(*pte);
*pte = __pte;
return (dma_addr_t)address;
}
/*
* The generic unmapping function for on page in the DMA address space.
*/
static void <API key>(struct dma_ops_domain *dom,
unsigned long address)
{
struct aperture_range *aperture;
u64 *pte;
if (address >= dom->aperture_size)
return;
aperture = dom->aperture[<API key>(address)];
if (!aperture)
return;
pte = aperture->pte_pages[APERTURE_PAGE_INDEX(address)];
if (!pte)
return;
pte += PM_LEVEL_INDEX(0, address);
WARN_ON(!*pte);
*pte = 0ULL;
}
/*
* This function contains common code for mapping of a physically
* contiguous memory region into DMA address space. It is used by all
* mapping functions provided with this IOMMU driver.
* Must be called with the domain lock held.
*/
static dma_addr_t __map_single(struct device *dev,
struct dma_ops_domain *dma_dom,
phys_addr_t paddr,
size_t size,
int dir,
bool align,
u64 dma_mask)
{
dma_addr_t offset = paddr & ~PAGE_MASK;
dma_addr_t address, start, ret;
unsigned int pages;
unsigned long align_mask = 0;
int i;
pages = iommu_num_pages(paddr, size, PAGE_SIZE);
paddr &= PAGE_MASK;
INC_STATS_COUNTER(total_map_requests);
if (pages > 1)
INC_STATS_COUNTER(cross_page);
if (align)
align_mask = (1UL << get_order(size)) - 1;
retry:
address = <API key>(dev, dma_dom, pages, align_mask,
dma_mask);
if (unlikely(address == DMA_ERROR_CODE)) {
/*
* setting next_address here will let the address
* allocator only scan the new allocated range in the
* first run. This is a small optimization.
*/
dma_dom->next_address = dma_dom->aperture_size;
if (alloc_new_range(dma_dom, false, GFP_ATOMIC))
goto out;
/*
* aperture was successfully enlarged by 128 MB, try
* allocation again
*/
goto retry;
}
start = address;
for (i = 0; i < pages; ++i) {
ret = dma_ops_domain_map(dma_dom, start, paddr, dir);
if (ret == DMA_ERROR_CODE)
goto out_unmap;
paddr += PAGE_SIZE;
start += PAGE_SIZE;
}
address += offset;
ADD_STATS_COUNTER(alloced_io_mem, size);
if (unlikely(dma_dom->need_flush && !<API key>)) {
domain_flush_tlb(&dma_dom->domain);
dma_dom->need_flush = false;
} else if (unlikely(amd_iommu_np_cache))
domain_flush_pages(&dma_dom->domain, address, size);
out:
return address;
out_unmap:
for (--i; i >= 0; --i) {
start -= PAGE_SIZE;
<API key>(dma_dom, start);
}
<API key>(dma_dom, address, pages);
return DMA_ERROR_CODE;
}
/*
* Does the reverse of the __map_single function. Must be called with
* the domain lock held too
*/
static void __unmap_single(struct dma_ops_domain *dma_dom,
dma_addr_t dma_addr,
size_t size,
int dir)
{
dma_addr_t flush_addr;
dma_addr_t i, start;
unsigned int pages;
if ((dma_addr == DMA_ERROR_CODE) ||
(dma_addr + size > dma_dom->aperture_size))
return;
flush_addr = dma_addr;
pages = iommu_num_pages(dma_addr, size, PAGE_SIZE);
dma_addr &= PAGE_MASK;
start = dma_addr;
for (i = 0; i < pages; ++i) {
<API key>(dma_dom, start);
start += PAGE_SIZE;
}
SUB_STATS_COUNTER(alloced_io_mem, size);
<API key>(dma_dom, dma_addr, pages);
if (<API key> || dma_dom->need_flush) {
domain_flush_pages(&dma_dom->domain, flush_addr, size);
dma_dom->need_flush = false;
}
}
/*
* The exported map_single function for dma_ops.
*/
static dma_addr_t map_page(struct device *dev, struct page *page,
unsigned long offset, size_t size,
enum dma_data_direction dir,
struct dma_attrs *attrs)
{
unsigned long flags;
struct protection_domain *domain;
dma_addr_t addr;
u64 dma_mask;
phys_addr_t paddr = page_to_phys(page) + offset;
INC_STATS_COUNTER(cnt_map_single);
domain = get_domain(dev);
if (PTR_ERR(domain) == -EINVAL)
return (dma_addr_t)paddr;
else if (IS_ERR(domain))
return DMA_ERROR_CODE;
dma_mask = *dev->dma_mask;
spin_lock_irqsave(&domain->lock, flags);
addr = __map_single(dev, domain->priv, paddr, size, dir, false,
dma_mask);
if (addr == DMA_ERROR_CODE)
goto out;
<API key>(domain);
out:
<API key>(&domain->lock, flags);
return addr;
}
/*
* The exported unmap_single function for dma_ops.
*/
static void unmap_page(struct device *dev, dma_addr_t dma_addr, size_t size,
enum dma_data_direction dir, struct dma_attrs *attrs)
{
unsigned long flags;
struct protection_domain *domain;
INC_STATS_COUNTER(cnt_unmap_single);
domain = get_domain(dev);
if (IS_ERR(domain))
return;
spin_lock_irqsave(&domain->lock, flags);
__unmap_single(domain->priv, dma_addr, size, dir);
<API key>(domain);
<API key>(&domain->lock, flags);
}
/*
* This is a special map_sg function which is used if we should map a
* device which is not handled by an AMD IOMMU in the system.
*/
static int map_sg_no_iommu(struct device *dev, struct scatterlist *sglist,
int nelems, int dir)
{
struct scatterlist *s;
int i;
for_each_sg(sglist, s, nelems, i) {
s->dma_address = (dma_addr_t)sg_phys(s);
s->dma_length = s->length;
}
return nelems;
}
/*
* The exported map_sg function for dma_ops (handles scatter-gather
* lists).
*/
static int map_sg(struct device *dev, struct scatterlist *sglist,
int nelems, enum dma_data_direction dir,
struct dma_attrs *attrs)
{
unsigned long flags;
struct protection_domain *domain;
int i;
struct scatterlist *s;
phys_addr_t paddr;
int mapped_elems = 0;
u64 dma_mask;
INC_STATS_COUNTER(cnt_map_sg);
domain = get_domain(dev);
if (PTR_ERR(domain) == -EINVAL)
return map_sg_no_iommu(dev, sglist, nelems, dir);
else if (IS_ERR(domain))
return 0;
dma_mask = *dev->dma_mask;
spin_lock_irqsave(&domain->lock, flags);
for_each_sg(sglist, s, nelems, i) {
paddr = sg_phys(s);
s->dma_address = __map_single(dev, domain->priv,
paddr, s->length, dir, false,
dma_mask);
if (s->dma_address) {
s->dma_length = s->length;
mapped_elems++;
} else
goto unmap;
}
<API key>(domain);
out:
<API key>(&domain->lock, flags);
return mapped_elems;
unmap:
for_each_sg(sglist, s, mapped_elems, i) {
if (s->dma_address)
__unmap_single(domain->priv, s->dma_address,
s->dma_length, dir);
s->dma_address = s->dma_length = 0;
}
mapped_elems = 0;
goto out;
}
/*
* The exported map_sg function for dma_ops (handles scatter-gather
* lists).
*/
static void unmap_sg(struct device *dev, struct scatterlist *sglist,
int nelems, enum dma_data_direction dir,
struct dma_attrs *attrs)
{
unsigned long flags;
struct protection_domain *domain;
struct scatterlist *s;
int i;
INC_STATS_COUNTER(cnt_unmap_sg);
domain = get_domain(dev);
if (IS_ERR(domain))
return;
spin_lock_irqsave(&domain->lock, flags);
for_each_sg(sglist, s, nelems, i) {
__unmap_single(domain->priv, s->dma_address,
s->dma_length, dir);
s->dma_address = s->dma_length = 0;
}
<API key>(domain);
<API key>(&domain->lock, flags);
}
/*
* The exported alloc_coherent function for dma_ops.
*/
static void *alloc_coherent(struct device *dev, size_t size,
dma_addr_t *dma_addr, gfp_t flag)
{
unsigned long flags;
void *virt_addr;
struct protection_domain *domain;
phys_addr_t paddr;
u64 dma_mask = dev->coherent_dma_mask;
INC_STATS_COUNTER(cnt_alloc_coherent);
domain = get_domain(dev);
if (PTR_ERR(domain) == -EINVAL) {
virt_addr = (void *)__get_free_pages(flag, get_order(size));
*dma_addr = __pa(virt_addr);
return virt_addr;
} else if (IS_ERR(domain))
return NULL;
dma_mask = dev->coherent_dma_mask;
flag &= ~(__GFP_DMA | __GFP_HIGHMEM | __GFP_DMA32);
flag |= __GFP_ZERO;
virt_addr = (void *)__get_free_pages(flag, get_order(size));
if (!virt_addr)
return NULL;
paddr = virt_to_phys(virt_addr);
if (!dma_mask)
dma_mask = *dev->dma_mask;
spin_lock_irqsave(&domain->lock, flags);
*dma_addr = __map_single(dev, domain->priv, paddr,
size, DMA_BIDIRECTIONAL, true, dma_mask);
if (*dma_addr == DMA_ERROR_CODE) {
<API key>(&domain->lock, flags);
goto out_free;
}
<API key>(domain);
<API key>(&domain->lock, flags);
return virt_addr;
out_free:
free_pages((unsigned long)virt_addr, get_order(size));
return NULL;
}
/*
* The exported free_coherent function for dma_ops.
*/
static void free_coherent(struct device *dev, size_t size,
void *virt_addr, dma_addr_t dma_addr)
{
unsigned long flags;
struct protection_domain *domain;
INC_STATS_COUNTER(cnt_free_coherent);
domain = get_domain(dev);
if (IS_ERR(domain))
goto free_mem;
spin_lock_irqsave(&domain->lock, flags);
__unmap_single(domain->priv, dma_addr, size, DMA_BIDIRECTIONAL);
<API key>(domain);
<API key>(&domain->lock, flags);
free_mem:
free_pages((unsigned long)virt_addr, get_order(size));
}
/*
* This function is called by the DMA layer to find out if we can handle a
* particular device. It is part of the dma_ops.
*/
static int <API key>(struct device *dev, u64 mask)
{
return check_device(dev);
}
/*
* The function for pre-allocating protection domains.
*
* If the driver core informs the DMA layer if a driver grabs a device
* we don't need to preallocate the protection domains anymore.
* For now we have to.
*/
static void __init <API key>(void)
{
struct pci_dev *dev = NULL;
struct dma_ops_domain *dma_dom;
u16 devid;
for_each_pci_dev(dev) {
/* Do we handle this device? */
if (!check_device(&dev->dev))
continue;
/* Is there already any domain for it? */
if (domain_for_device(&dev->dev))
continue;
devid = get_device_id(&dev->dev);
dma_dom = <API key>();
if (!dma_dom)
continue;
<API key>(dma_dom, devid);
dma_dom->target_dev = devid;
attach_device(&dev->dev, &dma_dom->domain);
list_add_tail(&dma_dom->list, &iommu_pd_list);
}
}
static struct dma_map_ops amd_iommu_dma_ops = {
.alloc_coherent = alloc_coherent,
.free_coherent = free_coherent,
.map_page = map_page,
.unmap_page = unmap_page,
.map_sg = map_sg,
.unmap_sg = unmap_sg,
.dma_supported = <API key>,
};
static unsigned device_dma_ops_init(void)
{
struct pci_dev *pdev = NULL;
unsigned unhandled = 0;
for_each_pci_dev(pdev) {
if (!check_device(&pdev->dev)) {
iommu_ignore_device(&pdev->dev);
unhandled += 1;
continue;
}
pdev->dev.archdata.dma_ops = &amd_iommu_dma_ops;
}
return unhandled;
}
/*
* The function which clues the AMD IOMMU driver into dma_ops.
*/
void __init amd_iommu_init_api(void)
{
bus_set_iommu(&pci_bus_type, &amd_iommu_ops);
}
int __init <API key>(void)
{
struct amd_iommu *iommu;
int ret, unhandled;
/*
* first allocate a default protection domain for every IOMMU we
* found in the system. Devices not assigned to any other
* protection domain will be assigned to the default one.
*/
for_each_iommu(iommu) {
iommu->default_dom = <API key>();
if (iommu->default_dom == NULL)
return -ENOMEM;
iommu->default_dom->domain.flags |= PD_DEFAULT_MASK;
ret = <API key>(iommu);
if (ret)
goto free_domains;
}
/*
* Pre-allocate the protection domains for each device.
*/
<API key>();
iommu_detected = 1;
swiotlb = 0;
/* Make the driver finally visible to the drivers */
unhandled = device_dma_ops_init();
if (unhandled && max_pfn > MAX_DMA32_PFN) {
/* There are unhandled devices - initialize swiotlb for them */
swiotlb = 1;
}
<API key>();
return 0;
free_domains:
for_each_iommu(iommu) {
if (iommu->default_dom)
dma_ops_domain_free(iommu->default_dom);
}
return ret;
}
static void cleanup_domain(struct protection_domain *domain)
{
struct iommu_dev_data *dev_data, *next;
unsigned long flags;
write_lock_irqsave(&<API key>, flags);
<API key>(dev_data, next, &domain->dev_list, list) {
__detach_device(dev_data);
atomic_set(&dev_data->bind, 0);
}
<API key>(&<API key>, flags);
}
static void <API key>(struct protection_domain *domain)
{
if (!domain)
return;
<API key>(domain);
if (domain->id)
domain_id_free(domain->id);
kfree(domain);
}
static struct protection_domain *<API key>(void)
{
struct protection_domain *domain;
domain = kzalloc(sizeof(*domain), GFP_KERNEL);
if (!domain)
return NULL;
spin_lock_init(&domain->lock);
mutex_init(&domain->api_lock);
domain->id = domain_id_alloc();
if (!domain->id)
goto out_err;
INIT_LIST_HEAD(&domain->dev_list);
add_domain_to_list(domain);
return domain;
out_err:
kfree(domain);
return NULL;
}
static int <API key>(struct iommu_domain *dom)
{
struct protection_domain *domain;
domain = <API key>();
if (!domain)
goto out_free;
domain->mode = PAGE_MODE_3_LEVEL;
domain->pt_root = (void *)get_zeroed_page(GFP_KERNEL);
if (!domain->pt_root)
goto out_free;
dom->priv = domain;
return 0;
out_free:
<API key>(domain);
return -ENOMEM;
}
static void <API key>(struct iommu_domain *dom)
{
struct protection_domain *domain = dom->priv;
if (!domain)
return;
if (domain->dev_cnt > 0)
cleanup_domain(domain);
BUG_ON(domain->dev_cnt != 0);
free_pagetable(domain);
<API key>(domain);
dom->priv = NULL;
}
static void <API key>(struct iommu_domain *dom,
struct device *dev)
{
struct iommu_dev_data *dev_data = dev->archdata.iommu;
struct amd_iommu *iommu;
u16 devid;
if (!check_device(dev))
return;
devid = get_device_id(dev);
if (dev_data->domain != NULL)
detach_device(dev);
iommu = <API key>[devid];
if (!iommu)
return;
<API key>(iommu);
}
static int <API key>(struct iommu_domain *dom,
struct device *dev)
{
struct protection_domain *domain = dom->priv;
struct iommu_dev_data *dev_data;
struct amd_iommu *iommu;
int ret;
if (!check_device(dev))
return -EINVAL;
dev_data = dev->archdata.iommu;
iommu = <API key>[dev_data->devid];
if (!iommu)
return -EINVAL;
if (dev_data->domain)
detach_device(dev);
ret = attach_device(dev, domain);
<API key>(iommu);
return ret;
}
static int amd_iommu_map(struct iommu_domain *dom, unsigned long iova,
phys_addr_t paddr, int gfp_order, int iommu_prot)
{
unsigned long page_size = 0x1000UL << gfp_order;
struct protection_domain *domain = dom->priv;
int prot = 0;
int ret;
if (iommu_prot & IOMMU_READ)
prot |= IOMMU_PROT_IR;
if (iommu_prot & IOMMU_WRITE)
prot |= IOMMU_PROT_IW;
mutex_lock(&domain->api_lock);
ret = iommu_map_page(domain, iova, paddr, prot, page_size);
mutex_unlock(&domain->api_lock);
return ret;
}
static int amd_iommu_unmap(struct iommu_domain *dom, unsigned long iova,
int gfp_order)
{
struct protection_domain *domain = dom->priv;
unsigned long page_size, unmap_size;
page_size = 0x1000UL << gfp_order;
mutex_lock(&domain->api_lock);
unmap_size = iommu_unmap_page(domain, iova, page_size);
mutex_unlock(&domain->api_lock);
<API key>(domain);
return get_order(unmap_size);
}
static phys_addr_t <API key>(struct iommu_domain *dom,
unsigned long iova)
{
struct protection_domain *domain = dom->priv;
unsigned long offset_mask;
phys_addr_t paddr;
u64 *pte, __pte;
pte = fetch_pte(domain, iova);
if (!pte || !IOMMU_PTE_PRESENT(*pte))
return 0;
if (PM_PTE_LEVEL(*pte) == 0)
offset_mask = PAGE_SIZE - 1;
else
offset_mask = PTE_PAGE_SIZE(*pte) - 1;
__pte = *pte & PM_ADDR_MASK;
paddr = (__pte & ~offset_mask) | (iova & offset_mask);
return paddr;
}
static int <API key>(struct iommu_domain *domain,
unsigned long cap)
{
switch (cap) {
case <API key>:
return 1;
}
return 0;
}
static struct iommu_ops amd_iommu_ops = {
.domain_init = <API key>,
.domain_destroy = <API key>,
.attach_dev = <API key>,
.detach_dev = <API key>,
.map = amd_iommu_map,
.unmap = amd_iommu_unmap,
.iova_to_phys = <API key>,
.domain_has_cap = <API key>,
};
int __init <API key>(void)
{
struct amd_iommu *iommu;
struct pci_dev *dev = NULL;
u16 devid;
/* allocate passthrough domain */
pt_domain = <API key>();
if (!pt_domain)
return -ENOMEM;
pt_domain->mode |= PAGE_MODE_NONE;
for_each_pci_dev(dev) {
if (!check_device(&dev->dev))
continue;
devid = get_device_id(&dev->dev);
iommu = <API key>[devid];
if (!iommu)
continue;
attach_device(&dev->dev, pt_domain);
}
pr_info("AMD-Vi: Initialized for Passthrough Mode\n");
return 0;
} |
// Class: Vertex Array
// Authors: LiXizhi
// desc:
#include "ParaEngine.h"
#if defined (USE_OPENGL_RENDERER) || defined (USE_NULL_RENDERER)
#include "<API key>.h"
using namespace ParaEngine;
<API key>::<API key>()
: m_dwBase(0),
m_dwNextBase(0),
// better be contains a factor of 3*4=12
// 24000=800KB, Please note that this number must be a multiple of 3
m_dwDiscard(24000),
// normally 1000 vertex is a good choice for current TnL
m_dwFlush(240),
// default unit size.
m_nUnitSize(sizeof(my_vertex))
{
};
HRESULT <API key>::<API key>()
{
if (m_bIsInitialized)
return S_OK;
m_bIsInitialized = true;
m_lpVB.resize(m_dwDiscard*m_nUnitSize);
return S_OK;
}
HRESULT <API key>::<API key>()
{
m_bIsInitialized = false;
m_lpVB.clear();
return S_OK;
}
nSizeOfData: number of vertices to be moved into the vertex buffer.
return the number of vertices locked
uint32 <API key>::Lock(uint32 nSize, void** pVertices)
{
LoadAsset();
// Check to see if the entire vertex buffer has been used up yet.
if (nSize > m_dwDiscard - m_dwNextBase)
{
// No space remains. Start over from the beginning
// of the vertex buffer.
m_dwNextBase = 0;
// Bug fixed 2008.5.27: if the requested buffer is larger than the total dynamic buffer size, we will break the input.
if (nSize > m_dwDiscard)
{
nSize = m_dwDiscard;
}
}
// Lock the vertex buffer.
*pVertices = (void*)((&(m_lpVB[0])) + m_dwNextBase * m_nUnitSize);
// Advance to the next position in the vertex buffer.
m_dwBase = m_dwNextBase;
m_dwNextBase += nSize;
return nSize;
}
void <API key>::Unlock()
{
}
GLuint ParaEngine::<API key>::GetBuffer()
{
return 0;
}
void* ParaEngine::<API key>::<API key>()
{
return (void*)((&(m_lpVB[0])) + m_dwBase * m_nUnitSize);
}
bool ParaEngine::<API key>::IsMemoryBuffer()
{
return true;
}
DWORD ParaEngine::<API key>::GetBaseVertex()
{
return m_dwBase;
}
#endif |
#include <console/streams.h>
#include <console/early_print.h>
/* Include the sources. */
#if <API key> && <API key>
#include "drivers/uart/util.c"
#include "drivers/uart/uart8250io.c"
#endif
#if CONFIG_CONSOLE_NE2K
#include "drivers/net/ne2k.c"
#endif
void console_hw_init(void)
{
#if <API key>
uart_init(<API key>);
#endif
#if CONFIG_CONSOLE_NE2K
ne2k_init(<API key>);
#endif
}
void console_tx_byte(unsigned char byte)
{
#if <API key>
uart_tx_byte(<API key>, byte);
#endif
#if CONFIG_CONSOLE_NE2K
<API key>(byte, <API key>);
#endif
}
void console_tx_flush(void)
{
#if <API key>
uart_tx_flush(<API key>);
#endif
#if CONFIG_CONSOLE_NE2K
ne2k_transmit(<API key>);
#endif
}
#include <console/early_print.c>
#include <console/init.c>
#include <console/post.c>
#include <console/die.c> |
#include "config.h"
#include "ArrayProfile.h"
#include "CodeBlock.h"
#include <wtf/StringExtras.h>
#include <wtf/StringPrintStream.h>
namespace JSC {
void dumpArrayModes(PrintStream& out, ArrayModes arrayModes)
{
if (!arrayModes) {
out.print("0:<empty>");
return;
}
if (arrayModes == ALL_ARRAY_MODES) {
out.print("TOP");
return;
}
out.print(arrayModes, ":");
if (arrayModes & asArrayModes(NonArray))
out.print("NonArray");
if (arrayModes & asArrayModes(NonArrayWithInt32))
out.print("NonArrayWithInt32");
if (arrayModes & asArrayModes(NonArrayWithDouble))
out.print("NonArrayWithDouble");
if (arrayModes & asArrayModes(<API key>))
out.print("<API key>");
if (arrayModes & asArrayModes(<API key>))
out.print("<API key>");
if (arrayModes & asArrayModes(<API key>))
out.print("<API key>");
if (arrayModes & asArrayModes(ArrayClass))
out.print("ArrayClass");
if (arrayModes & asArrayModes(ArrayWithUndecided))
out.print("ArrayWithUndecided");
if (arrayModes & asArrayModes(ArrayWithInt32))
out.print("ArrayWithInt32");
if (arrayModes & asArrayModes(ArrayWithDouble))
out.print("ArrayWithDouble");
if (arrayModes & asArrayModes(ArrayWithContiguous))
out.print("ArrayWithContiguous");
if (arrayModes & asArrayModes(<API key>))
out.print("<API key>");
if (arrayModes & asArrayModes(<API key>))
out.print("<API key>");
}
ArrayModes ArrayProfile::<API key>() const
{
if (m_lastSeenStructure)
return <API key> | <API key>(m_lastSeenStructure);
return <API key>;
}
void ArrayProfile::<API key>(CodeBlock* codeBlock, OperationInProgress operation)
{
const bool verbose = false;
if (m_lastSeenStructure) {
<API key> |= <API key>(m_lastSeenStructure);
<API key> |=
m_lastSeenStructure->typeInfo().<API key>();
if (!codeBlock->globalObject()-><API key>(m_lastSeenStructure))
<API key> = false;
if (!<API key>()) {
if (!m_expectedStructure)
m_expectedStructure = m_lastSeenStructure;
else if (m_expectedStructure != m_lastSeenStructure) {
if (verbose)
dataLog(*codeBlock, " bc#", m_bytecodeOffset, ": making structure polymorphic because ", RawPointer(m_expectedStructure), " (", m_expectedStructure->classInfo()->className, ") != ", RawPointer(m_lastSeenStructure), " (", m_lastSeenStructure->classInfo()->className, ")\n");
m_expectedStructure = <API key>();
}
}
m_lastSeenStructure = 0;
}
if (hasTwoOrMoreBitsSet(<API key>)) {
if (verbose)
dataLog(*codeBlock, " bc#", m_bytecodeOffset, ": making structure polymorphic because two or more bits are set in <API key>\n");
m_expectedStructure = <API key>();
}
if (operation == Collection
&& expectedStructure()
&& !Heap::isMarked(m_expectedStructure)) {
if (verbose)
dataLog(*codeBlock, " bc#", m_bytecodeOffset, ": making structure during GC\n");
m_expectedStructure = <API key>();
}
}
CString ArrayProfile::briefDescription(CodeBlock* codeBlock)
{
<API key>(codeBlock);
StringPrintStream out;
bool hasPrinted = false;
if (<API key>) {
if (hasPrinted)
out.print(", ");
out.print(ArrayModesDump(<API key>));
hasPrinted = true;
}
if (<API key>()) {
if (hasPrinted)
out.print(", ");
out.print("struct = TOP");
hasPrinted = true;
} else if (m_expectedStructure) {
if (hasPrinted)
out.print(", ");
out.print("struct = ", RawPointer(m_expectedStructure));
hasPrinted = true;
}
if (m_mayStoreToHole) {
if (hasPrinted)
out.print(", ");
out.print("Hole");
hasPrinted = true;
}
if (m_outOfBounds) {
if (hasPrinted)
out.print(", ");
out.print("OutOfBounds");
hasPrinted = true;
}
if (<API key>) {
if (hasPrinted)
out.print(", ");
out.print("Intercept");
hasPrinted = true;
}
if (<API key>) {
if (hasPrinted)
out.print(", ");
out.print("Original");
hasPrinted = true;
}
UNUSED_PARAM(hasPrinted);
return out.toCString();
}
} // namespace JSC |
#include <linux/earlysuspend.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/cpufreq.h>
#include <linux/workqueue.h>
#include <linux/completion.h>
#include <linux/cpu.h>
#include <linux/cpumask.h>
#include <linux/sched.h>
#include <linux/suspend.h>
#include <linux/err.h>
#include <mach/socinfo.h>
#include <mach/cpufreq.h>
#include "acpuclock.h"
struct cpufreq_work_struct {
struct work_struct work;
struct cpufreq_policy *policy;
struct completion complete;
int frequency;
int status;
};
static DEFINE_PER_CPU(struct cpufreq_work_struct, cpufreq_work);
static struct workqueue_struct *msm_cpufreq_wq;
struct cpufreq_suspend_t {
struct mutex suspend_mutex;
int device_suspended;
};
static DEFINE_PER_CPU(struct cpufreq_suspend_t, cpufreq_suspend);
struct cpu_freq {
uint32_t max;
uint32_t min;
uint32_t allowed_max;
uint32_t allowed_min;
uint32_t limits_init;
};
static DEFINE_PER_CPU(struct cpu_freq, cpu_freq_info);
#ifdef CONFIG_SEC_DVFS
static unsigned int upper_limit_freq;
static unsigned int lower_limit_freq;
static unsigned int cpuinfo_max_freq;
static unsigned int cpuinfo_min_freq;
unsigned int get_min_lock(void)
{
return lower_limit_freq;
}
unsigned int get_max_lock(void)
{
return upper_limit_freq;
}
void set_min_lock(int freq)
{
if (freq <= MIN_FREQ_LIMIT)
lower_limit_freq = 0;
else if (freq > MAX_FREQ_LIMIT)
lower_limit_freq = 0;
else
lower_limit_freq = freq;
}
void set_max_lock(int freq)
{
if (freq < MIN_FREQ_LIMIT)
upper_limit_freq = 0;
else if (freq >= MAX_FREQ_LIMIT)
upper_limit_freq = 0;
else
upper_limit_freq = freq;
}
int get_max_freq(void)
{
return cpuinfo_max_freq;
}
int get_min_freq(void)
{
return cpuinfo_min_freq;
}
#endif
static int set_cpu_freq(struct cpufreq_policy *policy, unsigned int new_freq)
{
int ret = 0;
int saved_sched_policy = -EINVAL;
int saved_sched_rt_prio = -EINVAL;
struct cpufreq_freqs freqs;
struct cpu_freq *limit = &per_cpu(cpu_freq_info, policy->cpu);
struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
if (limit->limits_init) {
if (new_freq > limit->allowed_max) {
new_freq = limit->allowed_max;
pr_debug("max: limiting freq to %d\n", new_freq);
}
if (new_freq < limit->allowed_min) {
new_freq = limit->allowed_min;
pr_debug("min: limiting freq to %d\n", new_freq);
}
}
#ifdef CONFIG_SEC_DVFS
if (lower_limit_freq || upper_limit_freq) {
unsigned int t_freq = new_freq;
if (lower_limit_freq && new_freq < lower_limit_freq)
t_freq = lower_limit_freq;
if (upper_limit_freq && new_freq > upper_limit_freq)
t_freq = upper_limit_freq;
new_freq = t_freq;
if (new_freq < policy->min)
new_freq = policy->min;
if (new_freq > policy->max)
new_freq = policy->max;
if (new_freq == policy->cur)
return 0;
}
#endif
freqs.old = policy->cur;
freqs.new = new_freq;
freqs.cpu = policy->cpu;
/*
* Put the caller into SCHED_FIFO priority to avoid cpu starvation
* in the acpuclk_set_rate path while increasing frequencies
*/
if (freqs.new > freqs.old && current->policy != SCHED_FIFO) {
saved_sched_policy = current->policy;
saved_sched_rt_prio = current->rt_priority;
<API key>(current, SCHED_FIFO, ¶m);
}
<API key>(&freqs, CPUFREQ_PRECHANGE);
ret = acpuclk_set_rate(policy->cpu, new_freq, SETRATE_CPUFREQ);
if (!ret)
<API key>(&freqs, CPUFREQ_POSTCHANGE);
/* Restore priority after clock ramp-up */
if (freqs.new > freqs.old && saved_sched_policy >= 0) {
param.sched_priority = saved_sched_rt_prio;
<API key>(current, saved_sched_policy, ¶m);
}
return ret;
}
static void set_cpu_work(struct work_struct *work)
{
struct cpufreq_work_struct *cpu_work =
container_of(work, struct cpufreq_work_struct, work);
cpu_work->status = set_cpu_freq(cpu_work->policy, cpu_work->frequency);
complete(&cpu_work->complete);
}
static int msm_cpufreq_target(struct cpufreq_policy *policy,
unsigned int target_freq,
unsigned int relation)
{
int ret = -EFAULT;
int index;
struct <API key> *table;
struct cpufreq_work_struct *cpu_work = NULL;
cpumask_var_t mask;
if (!cpu_active(policy->cpu)) {
pr_info("cpufreq: cpu %d is not active.\n", policy->cpu);
return -ENODEV;
}
if (!alloc_cpumask_var(&mask, GFP_KERNEL))
return -ENOMEM;
mutex_lock(&per_cpu(cpufreq_suspend, policy->cpu).suspend_mutex);
if (per_cpu(cpufreq_suspend, policy->cpu).device_suspended) {
pr_debug("cpufreq: cpu%d scheduling frequency change "
"in suspend.\n", policy->cpu);
ret = -EFAULT;
goto done;
}
table = <API key>(policy->cpu);
if (<API key>(policy, table, target_freq, relation,
&index)) {
pr_err("cpufreq: invalid target_freq: %d\n", target_freq);
ret = -EINVAL;
goto done;
}
pr_debug("CPU[%d] target %d relation %d (%d-%d) selected %d\n",
policy->cpu, target_freq, relation,
policy->min, policy->max, table[index].frequency);
cpu_work = &per_cpu(cpufreq_work, policy->cpu);
cpu_work->policy = policy;
cpu_work->frequency = table[index].frequency;
cpu_work->status = -ENODEV;
cpumask_clear(mask);
cpumask_set_cpu(policy->cpu, mask);
if (cpumask_equal(mask, ¤t->cpus_allowed)) {
ret = set_cpu_freq(cpu_work->policy, cpu_work->frequency);
goto done;
} else {
cancel_work_sync(&cpu_work->work);
INIT_COMPLETION(cpu_work->complete);
queue_work_on(policy->cpu, msm_cpufreq_wq, &cpu_work->work);
wait_for_completion(&cpu_work->complete);
}
ret = cpu_work->status;
done:
free_cpumask_var(mask);
mutex_unlock(&per_cpu(cpufreq_suspend, policy->cpu).suspend_mutex);
return ret;
}
static int msm_cpufreq_verify(struct cpufreq_policy *policy)
{
<API key>(policy, policy->cpuinfo.min_freq,
policy->cpuinfo.max_freq);
return 0;
}
static unsigned int <API key>(unsigned int cpu)
{
return acpuclk_get_rate(cpu);
}
static inline int <API key>(void)
{
int cpu = 0;
int i = 0;
struct <API key> *table = NULL;
uint32_t min = (uint32_t) -1;
uint32_t max = 0;
struct cpu_freq *limit = NULL;
<API key>(cpu) {
limit = &per_cpu(cpu_freq_info, cpu);
table = <API key>(cpu);
if (table == NULL) {
pr_err("%s: error reading cpufreq table for cpu %d\n",
__func__, cpu);
continue;
}
for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
if (table[i].frequency > max)
max = table[i].frequency;
if (table[i].frequency < min)
min = table[i].frequency;
}
limit->allowed_min = min;
limit->allowed_max = max;
limit->min = min;
limit->max = max;
limit->limits_init = 1;
}
return 0;
}
int <API key>(uint32_t cpu, uint32_t min, uint32_t max)
{
struct cpu_freq *limit = &per_cpu(cpu_freq_info, cpu);
if (!limit->limits_init)
<API key>();
if ((min != <API key>) &&
min >= limit->min && min <= limit->max)
limit->allowed_min = min;
else
limit->allowed_min = limit->min;
if ((max != <API key>) &&
max <= limit->max && max >= limit->min)
limit->allowed_max = max;
else
limit->allowed_max = limit->max;
pr_debug("%s: Limiting cpu %d min = %d, max = %d\n",
__func__, cpu,
limit->allowed_min, limit->allowed_max);
return 0;
}
EXPORT_SYMBOL(<API key>);
static int __cpuinit msm_cpufreq_init(struct cpufreq_policy *policy)
{
int cur_freq;
int index;
struct <API key> *table;
struct cpufreq_work_struct *cpu_work = NULL;
table = <API key>(policy->cpu);
if (table == NULL)
return -ENODEV;
/*
* In 8625 both cpu core's frequency can not
* be changed independently. Each cpu is bound to
* same frequency. Hence set the cpumask to all cpu.
*/
if (cpu_is_msm8625())
cpumask_setall(policy->cpus);
if (<API key>(policy, table)) {
#ifdef <API key>
policy->cpuinfo.min_freq = <API key>;
policy->cpuinfo.max_freq = <API key>;
#endif
}
#ifdef <API key>
policy->min = <API key>;
policy->max = <API key>;
#endif
#ifdef CONFIG_SEC_DVFS
cpuinfo_max_freq = policy->cpuinfo.max_freq;
cpuinfo_min_freq = policy->cpuinfo.min_freq;
#endif
cur_freq = acpuclk_get_rate(policy->cpu);
if (<API key>(policy, table, cur_freq,
CPUFREQ_RELATION_H, &index) &&
<API key>(policy, table, cur_freq,
CPUFREQ_RELATION_L, &index)) {
pr_info("cpufreq: cpu%d at invalid freq: %d\n",
policy->cpu, cur_freq);
return -EINVAL;
}
if (cur_freq != table[index].frequency) {
int ret = 0;
ret = acpuclk_set_rate(policy->cpu, table[index].frequency,
SETRATE_CPUFREQ);
if (ret)
return ret;
pr_info("cpufreq: cpu%d init at %d switching to %d\n",
policy->cpu, cur_freq, table[index].frequency);
cur_freq = table[index].frequency;
}
policy->cur = cur_freq;
policy->cpuinfo.transition_latency =
<API key>() * NSEC_PER_USEC;
cpu_work = &per_cpu(cpufreq_work, policy->cpu);
INIT_WORK(&cpu_work->work, set_cpu_work);
init_completion(&cpu_work->complete);
return 0;
}
static int __cpuinit <API key>(struct notifier_block *nfb,
unsigned long action, void *hcpu)
{
unsigned int cpu = (unsigned long)hcpu;
switch (action) {
case CPU_ONLINE:
case CPU_ONLINE_FROZEN:
per_cpu(cpufreq_suspend, cpu).device_suspended = 0;
break;
case CPU_DOWN_PREPARE:
case <API key>:
mutex_lock(&per_cpu(cpufreq_suspend, cpu).suspend_mutex);
per_cpu(cpufreq_suspend, cpu).device_suspended = 1;
mutex_unlock(&per_cpu(cpufreq_suspend, cpu).suspend_mutex);
break;
case CPU_DOWN_FAILED:
case <API key>:
per_cpu(cpufreq_suspend, cpu).device_suspended = 0;
break;
}
return NOTIFY_OK;
}
static struct notifier_block __refdata <API key> = {
.notifier_call = <API key>,
};
/*
* Define suspend/resume for cpufreq_driver. Kernel will call
* these during suspend/resume with interrupts disabled. This
* helps the suspend/resume variable get's updated before cpufreq
* governor tries to change the frequency after coming out of suspend.
*/
static int msm_cpufreq_suspend(struct cpufreq_policy *policy)
{
int cpu;
<API key>(cpu) {
per_cpu(cpufreq_suspend, cpu).device_suspended = 1;
}
return 0;
}
static int msm_cpufreq_resume(struct cpufreq_policy *policy)
{
int cpu;
<API key>(cpu) {
per_cpu(cpufreq_suspend, cpu).device_suspended = 0;
}
return 0;
}
static struct freq_attr *msm_freq_attr[] = {
&<API key>,
NULL,
};
static struct cpufreq_driver msm_cpufreq_driver = {
/* lps calculations are handled here. */
.flags = CPUFREQ_STICKY | CPUFREQ_CONST_LOOPS,
.init = msm_cpufreq_init,
.verify = msm_cpufreq_verify,
.target = msm_cpufreq_target,
.get = <API key>,
.suspend = msm_cpufreq_suspend,
.resume = msm_cpufreq_resume,
.name = "msm",
.attr = msm_freq_attr,
};
static int __init <API key>(void)
{
int cpu;
<API key>(cpu) {
mutex_init(&(per_cpu(cpufreq_suspend, cpu).suspend_mutex));
per_cpu(cpufreq_suspend, cpu).device_suspended = 0;
}
msm_cpufreq_wq = create_workqueue("msm-cpufreq");
if(IS_ERR_OR_NULL(msm_cpufreq_wq))
return PTR_ERR(msm_cpufreq_wq);
<API key>(&<API key>);
return <API key>(&msm_cpufreq_driver);
}
late_initcall(<API key>); |
Restaurant Base
============
Provides base configuration and structure for the Restaurant Distribution.
See project on drupal.org: http://drupal.org/project/restaurant_base. |
/** @file
* DnD: Path list class.
*/
#include <iprt/string.h>
#include <VBox/GuestHost/DragAndDrop.h>
bool DnDMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax)
{
/** @todo "text/uri" also an official variant? */
return ( RTStrNICmp(pcszFormat, "text/uri-list", cchFormatMax) == 0
|| RTStrNICmp(pcszFormat, "x-special/gnome-icon-list", cchFormatMax) == 0);
}
bool DnDMIMENeedsDropDir(const char *pcszFormat, size_t cchFormatMax)
{
bool fNeedsDropDir = false;
if (!RTStrNICmp(pcszFormat, "text/uri-list", cchFormatMax)) /** @todo Add "x-special/gnome-icon-list"? */
fNeedsDropDir = true;
return fNeedsDropDir;
} |
#<API key> li {
list-style-type: none;
position: relative;
font-family: Trebuchet MS, Lucida Sans Unicode, Arial, sans-serif;
font-size: 10pt;
width: 190px;
overflow: hidden;
}
#<API key> ul {
margin: 0px;
padding: 0px;
position: relative;
}
#<API key> div {
margin: 0px;
padding: 0px;
}
/* Layout CSS */
#<API key> {
width: 190px;
visibility: hidden;
overflow: hidden;
}
/* All A tags - i.e menu items. */
#<API key> a {
color: #000;
text-decoration: none;
display: block;
clear: both;
white-space: nowrap;
}
/*
A tags
*/
#<API key> .slMenuItem_depth1 { /* Main menu items */
margin-top: 1px;
border-bottom: 1px solid #000;
font-weight: bold;
background-color: #def;
}
#<API key> .slMenuItem_depth2 { /* Sub menu items */
height:16px;
background-color: #FFFFDD;
padding: 2px;
color: blue;
font-size: 1em;
border-bottom: 2px solid #FFF;
}
#<API key> .slMenuItem_depth3 { /* Sub menu items */
margin-top: 1px;
background-color: #FFFFDD;
font-size: 0.9em;
color: blue;
}
#<API key> .slMenuItem_depth4 { /* Sub menu items */
margin-top: 1px;
color: red;
}
#<API key> .slMenuItem_depth5 { /* Sub menu items */
margin-top: 1px;
}
/* UL tags, i.e group of menu utems.
It's important to add style to the UL if you're specifying margins. If not, assign the style directly
to the parent DIV, i.e.
#<API key> .slideMenuDiv1
instead of
#<API key> .slideMenuDiv1 ul
*/
#<API key> .slideMenuDiv1 ul {
padding: 1px;
}
#<API key> .slideMenuDiv2 ul {
margin-left: 5px;
margin-right: 5px;
padding: 1px;
}
#<API key> .slideMenuDiv3 ul {
margin-left: 10px;
padding: 1px;
}
#<API key> .slMenuItem_depth4 ul {
margin-left: 15px;
padding: 1px;
}
#menu li {
list-style-type: none;
position: relative;
font-family: Trebuchet MS, Lucida Sans Unicode, Arial, sans-serif;
font-size: 11pt;
width: 190px;
overflow: hidden;
}
#menu ul {
margin: 0px;
padding: 0px;
position: relative;
}
#menu div {
margin: 0px;
padding: 0px;
}
/* Layout CSS */
#menu {
margin-top: 1px;
border-bottom: 1px solid #000;
font-weight: bold;
list-style-type: none;
position: relative;
font-family: Trebuchet MS, Lucida Sans Unicode, Arial, sans-serif;
font-size: 10pt;
width: 190px;
overflow: hidden;
background-color: #def;
}
/* All A tags - i.e menu items. */
#menu a {
color: #000;
text-decoration: none;
display: block;
clear: both;
white-space: nowrap;
} |
#ifndef RPL_MI_H
#define RPL_MI_H
#ifdef HAVE_REPLICATION
#include "rpl_rli.h"
#include "rpl_reporting.h"
#include "my_sys.h"
#include "rpl_filter.h"
#include "keycaches.h"
typedef struct st_mysql MYSQL;
/**
Domain id based filter to handle DO_DOMAIN_IDS and IGNORE_DOMAIN_IDS used to
set filtering on replication slave based on event's GTID domain_id.
*/
class Domain_id_filter
{
private:
/*
Flag to tell whether the events in the current GTID group get written to
the relay log. It is set according to the domain_id based filtering rule
on every GTID_EVENT and reset at the end of current GTID event group.
*/
bool m_filter;
/*
DO_DOMAIN_IDS (0):
Ignore all the events which do not belong to any of the domain ids in the
list.
IGNORE_DOMAIN_IDS (1):
Ignore the events which belong to one of the domain ids in the list.
*/
DYNAMIC_ARRAY m_domain_ids[2];
public:
/* domain id list types */
enum enum_list_type {
DO_DOMAIN_IDS= 0,
IGNORE_DOMAIN_IDS
};
Domain_id_filter();
~Domain_id_filter();
/*
Returns whether the current group needs to be filtered.
*/
bool is_group_filtered() { return m_filter; }
/*
Checks whether the group with the specified domain_id needs to be
filtered and updates m_filter flag accordingly.
*/
void do_filter(ulong domain_id);
/*
Reset m_filter. It should be called when IO thread receives COMMIT_EVENT or
XID_EVENT.
*/
void reset_filter();
/*
Update the do/ignore domain id filter lists.
@param do_ids [IN] domain ids to be kept
@param ignore_ids [IN] domain ids to be filtered out
@param using_gtid [IN] use GTID?
@retval false Success
true Error
*/
bool update_ids(DYNAMIC_ARRAY *do_ids, DYNAMIC_ARRAY *ignore_ids,
bool using_gtid);
/*
Serialize and store the ids from domain id lists into the thd's protocol
buffer.
@param thd [IN] thread handler
@retval void
*/
void store_ids(THD *thd);
/*
Initialize the given domain id list (DYNAMIC_ARRAY) with the
space-separated list of numbers from the specified IO_CACHE where
the first number is the total number of entries to follows.
@param f [IN] IO_CACHE file
@param type [IN] domain id list type
@retval false Success
true Error
*/
bool init_ids(IO_CACHE *f, enum_list_type type);
/*
Return the elements of the give domain id list type as string.
@param type [IN] domain id list type
@retval a string buffer storing the total number
of elements followed by the individual
elements (space-separated) in the
specified list.
Note: Its caller's responsibility to free the returned string buffer.
*/
char *as_string(enum_list_type type);
};
extern TYPELIB <API key>;
class Master_info : public <API key>
{
public:
enum enum_using_gtid {
USE_GTID_NO= 0, <API key>= 1, USE_GTID_SLAVE_POS= 2
};
Master_info(LEX_STRING *connection_name, bool is_slave_recovery);
~Master_info();
bool <API key>(ulong s_id);
void <API key>(bool all);
bool error()
{
/* If malloc() in initialization failed */
return connection_name.str == 0;
}
static const char *using_gtid_astext(enum enum_using_gtid arg);
bool using_parallel()
{
return <API key> > 0 &&
parallel_mode > SLAVE_PARALLEL_NONE;
}
/* the variables below are needed because we can change masters on the fly */
char master_log_name[FN_REFLEN+6]; /* Room for multi-*/
char host[HOSTNAME_LENGTH*<API key>+1];
char user[USERNAME_LENGTH+1];
char password[MAX_PASSWORD_LENGTH*<API key>+1];
LEX_STRING connection_name; /* User supplied connection name */
LEX_STRING cmp_connection_name; /* Connection name in lower case */
bool ssl; // enables use of SSL connection if true
char ssl_ca[FN_REFLEN], ssl_capath[FN_REFLEN], ssl_cert[FN_REFLEN];
char ssl_cipher[FN_REFLEN], ssl_key[FN_REFLEN];
char ssl_crl[FN_REFLEN], ssl_crlpath[FN_REFLEN];
bool <API key>;
my_off_t master_log_pos;
File fd; // we keep the file open, so we need to remember the file pointer
IO_CACHE file;
mysql_mutex_t data_lock, run_lock, sleep_lock;
mysql_cond_t data_cond, start_cond, stop_cond, sleep_cond;
THD *io_thd;
MYSQL* mysql;
uint32 file_id; /* for 3.23 load data infile */
Relay_log_info rli;
uint port;
Rpl_filter* rpl_filter; /* Each replication can set its filter rule*/
/*
to hold checksum alg in use until IO thread has received FD.
Initialized to novalue, then set to the queried from master
@@global.binlog_checksum and deactivated once FD has been received.
*/
enum <API key> <API key>;
uint connect_retry;
#ifndef DBUG_OFF
int <API key>;
/*
The following are auxiliary DBUG variables used to kill IO thread in the
middle of a group/transaction (see "<API key>").
*/
bool dbug_do_disconnect;
int dbug_event_counter;
#endif
bool inited;
volatile bool abort_slave;
volatile uint slave_running;
volatile ulong slave_run_id;
/*
The difference in seconds between the clock of the master and the clock of
the slave (second - first). It must be signed as it may be <0 or >0.
<API key> is computed when the I/O thread starts; for this the
I/O thread does a SELECT UNIX_TIMESTAMP() on the master.
"how late the slave is compared to the master" is computed like this:
clock_of_slave - <API key> - <API key>
*/
long <API key>;
/*
Keeps track of the number of events before fsyncing.
The option --sync-master-info determines how many
events should happen before fsyncing.
*/
uint sync_counter;
float heartbeat_period; // interface with CHANGE MASTER or master.info
ulonglong received_heartbeats; // counter of received heartbeat events
DYNAMIC_ARRAY ignore_server_ids;
ulong master_id;
/*
At reconnect and until the first rotate event is seen, prev_master_id is
the value of master_id during the previous connection, used to detect
silent change of master server during reconnects.
*/
ulong prev_master_id;
/*
Which kind of GTID position (if any) is used when connecting to master.
Note that you can not change the numeric values of these, they are used
in master.info.
*/
enum enum_using_gtid using_gtid;
/*
This GTID position records how far we have fetched into the relay logs.
This is used to continue fetching when the IO thread reconnects to the
master.
(Full slave stop/start does not use it, as it resets the relay logs).
*/
<API key> gtid_current_pos;
/*
If <API key> is non-zero, it is the number of events
queued so far in the relaylog of a GTID-prefixed event group.
It is zero when no partial event group has been queued at the moment.
*/
uint64 <API key>;
/*
The GTID of the partially-queued event group, when
<API key> is non-zero.
*/
rpl_gtid last_queued_gtid;
/* Whether last_queued_gtid had the FL_STANDALONE flag set. */
bool <API key>;
/*
When slave IO thread needs to reconnect, <API key>
counts number of events to skip from the first GTID-prefixed event group,
to avoid duplicating events in the relay log.
*/
uint64 <API key>;
/* gtid_event_seen is false until we receive first GTID event from master. */
bool gtid_event_seen;
/* domain-id based filter */
Domain_id_filter domain_id_filter;
/* The parallel replication mode. */
<API key> parallel_mode;
};
int init_master_info(Master_info* mi, const char* master_info_fname,
const char* slave_info_fname,
bool <API key>,
int thread_mask);
void end_master_info(Master_info* mi);
int flush_master_info(Master_info* mi,
bool <API key>,
bool need_lock_relay_log);
void copy_filter_setting(Rpl_filter* dst_filter, Rpl_filter* src_filter);
void <API key>(DYNAMIC_ARRAY *new_ids, DYNAMIC_ARRAY *old_ids);
void prot_store_ids(THD *thd, DYNAMIC_ARRAY *ids);
/*
Multi master are handled trough this struct.
Changes to this needs to be protected by LOCK_active_mi;
*/
class Master_info_index
{
private:
IO_CACHE index_file;
char index_file_name[FN_REFLEN];
public:
Master_info_index();
~Master_info_index();
HASH master_info_hash;
bool <API key>();
bool <API key>(LEX_STRING *connection_name,
bool do_sync);
bool <API key>(LEX_STRING *connection_name,
const char *host, uint port);
bool add_master_info(Master_info *mi, bool write_to_file);
bool remove_master_info(LEX_STRING *connection_name);
Master_info *get_master_info(const LEX_STRING *connection_name,
Sql_condition::enum_warning_level warning);
bool <API key>();
bool <API key>();
bool start_all_slaves(THD *thd);
bool stop_all_slaves(THD *thd);
};
/*
The class rpl_io_thread_info is the THD::system_thread_info for the IO thread.
*/
class rpl_io_thread_info
{
public:
};
bool <API key>(LEX_STRING *name);
void <API key>(char *res_file_name, size_t length,
const char *info_file,
bool append,
LEX_STRING *suffix);
uchar *get_key_master_info(Master_info *mi, size_t *length,
my_bool not_used __attribute__((unused)));
void <API key>(Master_info *mi);
#endif /* HAVE_REPLICATION */
#endif /* RPL_MI_H */ |
#ifdef HAS_DX
#include <windows.h>
#include <d3d9.h>
#include <Initguid.h>
#include <dxva.h>
#include <dxva2api.h>
#include "DXVA.h"
#include "windowing/WindowingFactory.h"
#include "WinRenderer.h"
#include "settings/Settings.h"
#include "settings/MediaSettings.h"
#include "boost/shared_ptr.hpp"
#include "utils/AutoPtrHandle.h"
#include "utils/StringUtils.h"
#include "settings/AdvancedSettings.h"
#include "settings/MediaSettings.h"
#include "cores/VideoRenderers/RenderManager.h"
#include "win32/WIN32Util.h"
#include "utils/Log.h"
using namespace DXVA;
using namespace AUTOPTR;
using namespace std;
DEFINE_GUID(<API key>, 0x3C5323C1,0x6fb7,0x44f5,0x90,0x81,0x05,0x6b,0xf2,0xee,0x44,0x9d);
DEFINE_GUID(<API key>, 0x552C0DAD,0xccbc,0x420b,0x83,0xc8,0x74,0x94,0x3c,0xf9,0xf1,0xa6);
DEFINE_GUID(<API key>, 0x6E8329FF,0xb642,0x418b,0xbc,0xf0,0xbc,0xb6,0x59,0x1e,0x25,0x5f);
DEFINE_GUID(<API key>, 0x6CB69578,0x7617,0x4637,0x91,0xE5,0x1C,0x02,0xDB,0x81,0x02,0x85);
DEFINE_GUID(<API key>, 0xBF752EF6,0x8CC4,0x457A,0xBE,0x1B,0x08,0xBD,0x1C,0xAE,0xEE,0x9F);
DEFINE_GUID(<API key>, 0xF9F19DA5,0x3B09,0x4B2F,0x9D,0x89,0xC6,0x47,0x53,0xE3,0xEA,0xAB);
typedef struct {
const char *name;
const GUID *guid;
} dxva2_device_t;
static const dxva2_device_t dxva2_devices[] = {
{ "Progressive Device", &<API key> },
{ "Bob Device", &<API key> },
{ "Vector Adaptative Device", &<API key> },
{ "Motion Adaptative Device", &<API key> },
{ "Adaptative Device", &<API key> },
{ "Spatial-temporal device", &<API key> },
{ "Edge directed device", &<API key> },
{ "Unknown device (nVidia)", &<API key> },
{ NULL, NULL }
};
typedef struct {
const char *name;
unsigned flags;
} <API key>;
static const <API key> <API key>[] = {
{ "Inverse Telecine", <API key> },
{ "Motion vector steered", <API key> },
{ "Pixel adaptive", <API key> },
{ "Field adaptive", <API key> },
{ "Edge filtering", <API key> },
{ "Median filtering", <API key> },
{ "Bob vertical stretch 4-tap", <API key> },
{ "Bob vertical stretch", <API key> },
{ "Bob line replicate", <API key> },
{ "Unknown", <API key> },
{ NULL, 0 }
};
// Prefered targets must be first
static const D3DFORMAT render_targets[] = {
(D3DFORMAT)MAKEFOURCC('N','V','1','2'),
(D3DFORMAT)MAKEFOURCC('Y','V','1','2'),
D3DFMT_UNKNOWN
};
typedef struct {
DWORD VendorID;
DWORD DeviceID;
} pci_device;
// List of devices that drop frames with a deinterlacing processor for progressive material.
static const pci_device <API key>[] = {
{ PCIV_nVidia, 0x0865 }, // ION
{ PCIV_nVidia, 0x0874 }, // ION
{ PCIV_nVidia, 0x0876 }, // ION
{ PCIV_nVidia, 0x087D }, // ION
{ PCIV_nVidia, 0x087E }, // ION LE
{ PCIV_nVidia, 0x087F }, // ION LE
{ 0 , 0x0000 }
};
static CStdString GUIDToString(const GUID& guid)
{
CStdString buffer = StringUtils::Format("%08X-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x"
, guid.Data1, guid.Data2, guid.Data3
, guid.Data4[0], guid.Data4[1]
, guid.Data4[2], guid.Data4[3], guid.Data4[4]
, guid.Data4[5], guid.Data4[6], guid.Data4[7]);
return buffer;
}
static const dxva2_device_t *dxva2_find_device(const GUID *guid)
{
for (unsigned i = 0; dxva2_devices[i].name; i++) {
if (IsEqualGUID(*dxva2_devices[i].guid, *guid))
return &dxva2_devices[i];
}
return NULL;
}
static const <API key> *<API key>(unsigned flags)
{
for (unsigned i = 0; <API key>[i].name; i++) {
if (<API key>[i].flags == flags)
return &<API key>[i];
}
return NULL;
}
#define SCOPE(type, var) boost::shared_ptr<type> var##_holder(var, CoTaskMemFree);
CCriticalSection CProcessor::m_dlSection;
HMODULE CProcessor::m_dlHandle = NULL;
<API key> CProcessor::<API key> = NULL;
CProcessor::CProcessor()
{
m_service = NULL;
m_process = NULL;
g_Windowing.Register(this);
m_context = NULL;
m_progressive = true;
}
CProcessor::~CProcessor()
{
g_Windowing.Unregister(this);
UnInit();
}
void CProcessor::UnInit()
{
CSingleLock lock(m_section);
Close();
SAFE_RELEASE(m_service);
}
void CProcessor::Close()
{
CSingleLock lock(m_section);
SAFE_RELEASE(m_process);
SAFE_RELEASE(m_context);
}
bool CProcessor::UpdateSize(const DXVA2_VideoDesc& dsc)
{
// TODO: print the D3FORMAT text version in log
CLog::Log(LOGDEBUG, "DXVA - checking samples array size using %d render target", dsc.Format);
GUID* deint_guid_list = NULL;
unsigned guid_count = 0;
if (FAILED(m_service-><API key>(&dsc, &guid_count, &deint_guid_list)))
return false;
SCOPE(GUID, deint_guid_list);
for (unsigned i = 0; i < guid_count; i++)
{
<API key> caps;
CHECK(m_service-><API key>(deint_guid_list[i], &dsc, D3DFMT_X8R8G8B8, &caps));
if (caps.<API key> + caps.<API key> > m_size)
{
m_size = caps.<API key> + caps.<API key>;
CLog::Log(LOGDEBUG, "DXVA - updated maximum samples count to %d", m_size);
}
m_max_back_refs = std::max(caps.<API key>, m_max_back_refs);
m_max_fwd_refs = std::max(caps.<API key>, m_max_fwd_refs);
}
return true;
}
bool CProcessor::PreInit()
{
if (!LoadSymbols())
return false;
UnInit();
CSingleLock lock(m_section);
if (FAILED(<API key>(g_Windowing.Get3DDevice(), <API key>, (void**)&m_service)))
return false;
m_size = 0;
// We try to find the maximum count of reference frames using a standard resolution and all known render target formats
DXVA2_VideoDesc dsc = {};
dsc.SampleWidth = 640;
dsc.SampleHeight = 480;
dsc.SampleFormat.SampleFormat = <API key>;
m_max_back_refs = 0;
m_max_fwd_refs = 0;
for (unsigned i = 0; render_targets[i] != D3DFMT_UNKNOWN; i++)
{
dsc.Format = render_targets[i];
if (!UpdateSize(dsc))
CLog::Log(LOGDEBUG, "DXVA - render target not supported by processor");
}
m_size = m_max_back_refs + 1 + m_max_fwd_refs + 2; // refs + 1 display + 2 safety frames
return true;
}
bool CProcessor::Open(UINT width, UINT height, unsigned int flags, unsigned int format, unsigned int extended_format)
{
Close();
CSingleLock lock(m_section);
if (!m_service)
return false;
DXVA2_VideoDesc dsc;
memset(&dsc, 0, sizeof(DXVA2_VideoDesc));
dsc.SampleWidth = width;
dsc.SampleHeight = height;
dsc.SampleFormat.VideoLighting = <API key>;
switch (<API key>(flags))
{
case <API key>:
dsc.SampleFormat.<API key> = <API key>
| <API key>;
break;
case <API key>:
dsc.SampleFormat.<API key> = <API key>;
break;
case <API key>:
dsc.SampleFormat.<API key> = <API key>
| <API key>;
break;
default:
dsc.SampleFormat.<API key> = <API key>;
}
if (flags & <API key>)
dsc.SampleFormat.NominalRange = <API key>;
else
dsc.SampleFormat.NominalRange = <API key>;
switch (<API key>(flags))
{
case <API key>:
dsc.SampleFormat.VideoTransferMatrix = <API key>;
break;
case <API key>:
dsc.SampleFormat.VideoTransferMatrix = <API key>;
break;
case <API key>:
dsc.SampleFormat.VideoTransferMatrix = <API key>;
break;
default:
dsc.SampleFormat.VideoTransferMatrix = <API key>;
}
switch (<API key>(flags))
{
case <API key>:
dsc.SampleFormat.VideoPrimaries = <API key>;
break;
case <API key>:
dsc.SampleFormat.VideoPrimaries = <API key>;
break;
case <API key>:
dsc.SampleFormat.VideoPrimaries = <API key>;
break;
case <API key>:
dsc.SampleFormat.VideoPrimaries = <API key>;
break;
case <API key>:
dsc.SampleFormat.VideoPrimaries = <API key>;
break;
default:
dsc.SampleFormat.VideoPrimaries = <API key>;
}
switch (CONF_FLAGS_TRC_MASK(flags))
{
case <API key>:
dsc.SampleFormat.<API key> = <API key>;
break;
case <API key>:
dsc.SampleFormat.<API key> = <API key>;
break;
case <API key>:
dsc.SampleFormat.<API key> = <API key>;
break;
default:
dsc.SampleFormat.<API key> = <API key>;
}
m_desc = dsc;
if (format == RENDER_FMT_DXVA)
m_desc.Format = (D3DFORMAT)extended_format;
else
{
// Only NV12 software colorspace conversion is implemented for now
m_desc.Format = (D3DFORMAT)MAKEFOURCC('N','V','1','2');
if (!CreateSurfaces())
return false;
}
// frame flags are not available to do the complete calculation of the deinterlacing mode, as done in Render()
// It's OK, as it doesn't make any difference for all hardware except the few GPUs on the quirk list.
// And for those GPUs, the correct values will be calculated with the first Render() and the correct processor
// will replace the one allocated here, before the user sees anything.
// It's a bit inefficient, that's all.
m_deinterlace_mode = CMediaSettings::Get().<API key>().m_DeinterlaceMode;
m_interlace_method = g_renderManager.AutoInterlaceMethod(CMediaSettings::Get().<API key>().m_InterlaceMethod);;
<API key>();
if (g_advancedSettings.<API key> || <API key>)
CLog::Log(LOGNOTICE, "DXVA: Auto deinterlacing mode workaround activated. Deinterlacing processor will be used only for interlaced frames.");
if (!OpenProcessor())
return false;
return true;
}
void CProcessor::<API key>()
{
<API key> AIdentifier = g_Windowing.GetAIdentifier();
for (unsigned idx = 0; <API key>[idx].VendorID != 0; idx++)
{
if(<API key>[idx].VendorID == AIdentifier.VendorId
&& <API key>[idx].DeviceID == AIdentifier.DeviceId)
{
<API key> = true;
return;
}
}
<API key> = false;
}
bool CProcessor::SelectProcessor()
{
// The CProcessor can be run after dxva or software decoding, possibly after software deinterlacing.
// Deinterlace mode off: force progressive
// Deinterlace mode auto or force, with a dxva deinterlacing method: create an deinterlacing capable processor. The frame flags will tell it to deinterlace or not.
m_progressive = m_deinterlace_mode == <API key>
|| ( m_interlace_method != <API key>
&& m_interlace_method != <API key>);
if (m_progressive)
m_desc.SampleFormat.SampleFormat = <API key>;
else
m_desc.SampleFormat.SampleFormat = <API key>;
GUID* guid_list;
unsigned guid_count;
CHECK(m_service-><API key>(&m_desc, &guid_count, &guid_list));
SCOPE(GUID, guid_list);
if(guid_count == 0)
{
CLog::Log(LOGDEBUG, "DXVA - unable to find any processors");
return false;
}
for(unsigned i = 0; i < guid_count; i++)
{
const GUID* g = &guid_list[i];
const dxva2_device_t* device = dxva2_find_device(g);
if (device)
{
CLog::Log(LOGDEBUG, "DXVA - processor found %s", device->name);
}
else
{
CHECK(m_service-><API key>(*g, &m_desc, D3DFMT_X8R8G8B8, &m_caps));
const <API key>* tech = <API key>(m_caps.<API key>);
if (tech != NULL)
CLog::Log(LOGDEBUG, "DXVA - unknown processor %s found, deinterlace technology %s", GUIDToString(*g).c_str(), tech->name);
else
CLog::Log(LOGDEBUG, "DXVA - unknown processor %s found, unknown technology", GUIDToString(*g).c_str());
}
}
if (m_progressive)
m_device = <API key>;
else if(m_interlace_method == <API key>)
m_device = guid_list[0];
else
m_device = <API key>;
return true;
}
bool CProcessor::OpenProcessor()
{
if (!SelectProcessor())
return false;
SAFE_RELEASE(m_process);
const dxva2_device_t* device = dxva2_find_device(&m_device);
if (device)
CLog::Log(LOGDEBUG, "DXVA - processor selected %s", device->name);
else
CLog::Log(LOGDEBUG, "DXVA - processor selected %s", GUIDToString(m_device).c_str());
D3DFORMAT rtFormat = D3DFMT_X8R8G8B8;
CHECK(m_service-><API key>(m_device, &m_desc, rtFormat, &m_caps))
/* HACK for Intel Egde Device.
* won't work if backward refs is equals value from the capabilities *
* Possible reasons are: *
* 1) The device capabilities are incorrectly reported *
* 2) The device is broken */
if (IsEqualGUID(m_device, <API key>))
m_caps.<API key> = 0;
if (m_caps.DeviceCaps & <API key>)
CLog::Log(LOGDEBUG, "DXVA - processor is software device");
if (m_caps.DeviceCaps & <API key>)
CLog::Log(LOGDEBUG, "DXVA - processor is emulated dxva1");
CLog::Log(LOGDEBUG, "DXVA - processor requires %d past frames and %d future frames", m_caps.<API key>, m_caps.<API key>);
if (m_caps.<API key> + m_caps.<API key> + 3 > m_size)
{
CLog::Log(LOGERROR, "DXVA - used an incorrect number of reference frames creating processor");
return false;
}
CHECK(m_service-><API key>(m_device, &m_desc, rtFormat, 0, &m_process));
CHECK(m_service->GetProcAmpRange(m_device, &m_desc, rtFormat, <API key>, &m_brightness));
CHECK(m_service->GetProcAmpRange(m_device, &m_desc, rtFormat, <API key> , &m_contrast));
CHECK(m_service->GetProcAmpRange(m_device, &m_desc, rtFormat, DXVA2_ProcAmp_Hue , &m_hue));
CHECK(m_service->GetProcAmpRange(m_device, &m_desc, rtFormat, <API key>, &m_saturation));
return true;
}
bool CProcessor::CreateSurfaces()
{
LPDIRECT3DDEVICE9 pD3DDevice = g_Windowing.Get3DDevice();
LPDIRECT3DSURFACE9 surfaces[32];
for (unsigned idx = 0; idx < m_size; idx++)
{
CHECK(pD3DDevice-><API key>(
(m_desc.SampleWidth + 15) & ~15,
(m_desc.SampleHeight + 15) & ~15,
m_desc.Format,
D3DPOOL_DEFAULT,
&surfaces[idx],
NULL));
}
m_context = new CSurfaceContext();
for (int i = 0; i < m_size; i++)
{
m_context->AddSurface(surfaces[i]);
}
return true;
}
CRenderPicture *CProcessor::Convert(DVDVideoPicture* picture)
{
if (picture->format != RENDER_FMT_YUV420P)
{
CLog::Log(LOGERROR, "%s - colorspace not supported by processor, skipping frame.", __FUNCTION__);
return NULL;
}
IDirect3DSurface9* surface = m_context->GetFree(NULL);
if (!surface)
{
CLog::Log(LOGERROR, "%s - no free video surface", __FUNCTION__);
return NULL;
}
D3DLOCKED_RECT rectangle;
if (FAILED(surface->LockRect(&rectangle, NULL, 0)))
{
CLog::Log(LOGERROR, "%s - could not lock rect", __FUNCTION__);
m_context->ClearReference(surface);
return NULL;
}
// Convert to NV12 - Luma
// TODO: Optimize this later using shaders/swscale/etc.
uint8_t *s = picture->data[0];
uint8_t* bits = (uint8_t*)(rectangle.pBits);
for (unsigned y = 0; y < picture->iHeight; y++)
{
memcpy(bits, s, picture->iWidth);
s += picture->iLineSize[0];
bits += rectangle.Pitch;
}
D3DSURFACE_DESC desc;
if (FAILED(surface->GetDesc(&desc)))
{
CLog::Log(LOGERROR, "%s - could not get surface descriptor", __FUNCTION__);
m_context->ClearReference(surface);
return NULL;
}
// Convert to NV12 - Chroma
uint8_t *s_u, *s_v, *d_uv;
for (unsigned y = 0; y < picture->iHeight / 2; y++)
{
s_u = picture->data[1] + (y * picture->iLineSize[1]);
s_v = picture->data[2] + (y * picture->iLineSize[2]);
d_uv = ((uint8_t*)(rectangle.pBits)) + (desc.Height + y) * rectangle.Pitch;
for (unsigned x = 0; x < picture->iWidth / 2; x++)
{
*d_uv++ = *s_u++;
*d_uv++ = *s_v++;
}
}
if (FAILED(surface->UnlockRect()))
{
CLog::Log(LOGERROR, "%s - failed to unlock surface", __FUNCTION__);
m_context->ClearReference(surface);
return NULL;
}
m_context->ClearReference(surface);
m_context->MarkRender(surface);
CRenderPicture *pic = new CRenderPicture(m_context);
pic->surface = surface;
return pic;
}
static DXVA2_Fixed32 ConvertRange(const DXVA2_ValueRange& range, int value, int min, int max, int def)
{
if(value > def)
return DXVA2FloatToFixed( DXVA2FixedToFloat(range.DefaultValue)
+ (DXVA2FixedToFloat(range.MaxValue) - DXVA2FixedToFloat(range.DefaultValue))
* (value - def) / (max - def) );
else if(value < def)
return DXVA2FloatToFixed( DXVA2FixedToFloat(range.DefaultValue)
+ (DXVA2FixedToFloat(range.MinValue) - DXVA2FixedToFloat(range.DefaultValue))
* (value - def) / (min - def) );
else
return range.DefaultValue;
}
bool CProcessor::Render(CRect src, CRect dst, IDirect3DSurface9* target, IDirect3DSurface9** source, DWORD flags, UINT frameIdx)
{
CSingleLock lock(m_section);
if (!source[2])
return false;
// With auto deinterlacing, the Ion Gen. 1 drops some frames with deinterlacing processor + progressive flags for progressive material.
// For that GPU (or when specified by an advanced setting), use the progressive processor.
// This is at the expense of the switch speed when video interlacing flags change and a deinterlacing processor is actually required.
EDEINTERLACEMODE mode = CMediaSettings::Get().<API key>().m_DeinterlaceMode;
if (g_advancedSettings.<API key> || <API key>)
mode = (flags & RENDER_FLAG_FIELD0 || flags & RENDER_FLAG_FIELD1) ? <API key> : <API key>;
EINTERLACEMETHOD method = g_renderManager.AutoInterlaceMethod(CMediaSettings::Get().<API key>().m_InterlaceMethod);
if(m_interlace_method != method
|| m_deinterlace_mode != mode
|| !m_process)
{
m_deinterlace_mode = mode;
m_interlace_method = method;
if (!OpenProcessor())
return false;
}
D3DSURFACE_DESC desc;
CHECK(target->GetDesc(&desc));
CRect rectTarget(0, 0, desc.Width, desc.Height);
CWIN32Util::CropSource(src, dst, rectTarget);
RECT sourceRECT = { src.x1, src.y1, src.x2, src.y2 };
RECT dstRECT = { dst.x1, dst.y1, dst.x2, dst.y2 };
// set sample format for progressive and interlaced
UINT sampleFormat = <API key>;
if (flags & RENDER_FLAG_FIELD0 && flags & RENDER_FLAG_TOP)
sampleFormat = <API key>;
else if (flags & RENDER_FLAG_FIELD1 && flags & RENDER_FLAG_BOT)
sampleFormat = <API key>;
if (flags & RENDER_FLAG_FIELD0 && flags & RENDER_FLAG_BOT)
sampleFormat = <API key>;
if (flags & RENDER_FLAG_FIELD1 && flags & RENDER_FLAG_TOP)
sampleFormat = <API key>;
// How to prepare the samples array for VideoProcessBlt
// - always provide current picture + the number of forward and backward references required by the current processor.
// - provide the surfaces in the array in increasing temporal order
// - at the start of playback, there may not be enough samples available. Use SampleFormat.SampleFormat = DXVA2_SampleUnknown for the missing samples.
unsigned int providedPast = 0;
for (int i = 3; i < 8; i++)
{
if (source[i])
providedPast++;
}
unsigned int providedFuture = 0;
for (int i = 1; i >= 0; i
{
if (source[i])
providedFuture++;
}
int futureFrames = std::min(providedFuture, m_caps.<API key>);
int pastFrames = std::min(providedPast, m_caps.<API key>);
int count = 1 + pastFrames + futureFrames;
auto_aptr<DXVA2_VideoSample> samp(new DXVA2_VideoSample[count]);
int start = 2 - futureFrames;
int end = 2 + pastFrames;
int sampIdx = 0;
for (int i = end; i >= start; i
{
if (!source[i])
continue;
DXVA2_VideoSample& vs = samp[sampIdx];
vs.SrcSurface = source[i];
vs.SrcRect = sourceRECT;
vs.DstRect = dstRECT;
vs.SampleData = 0;
vs.Start = frameIdx + (sampIdx - pastFrames) * 2;
vs.End = vs.Start + 2;
vs.PlanarAlpha = <API key>();
vs.SampleFormat = m_desc.SampleFormat;
vs.SampleFormat.SampleFormat = sampleFormat;
// Override the sample format when the processor doesn't need to deinterlace or when deinterlacing is forced and flags are missing.
if (m_progressive)
vs.SampleFormat.SampleFormat = <API key>;
else if (m_deinterlace_mode == <API key> && vs.SampleFormat.SampleFormat == <API key>)
vs.SampleFormat.SampleFormat = <API key>;
sampIdx++;
}
<API key> blt = {};
blt.TargetFrame = frameIdx;
if (flags & RENDER_FLAG_FIELD1)
blt.TargetFrame += 1;
blt.TargetRect = dstRECT;
blt.ConstrictionSize.cx = 0;
blt.ConstrictionSize.cy = 0;
blt.DestFormat.<API key> = <API key>;
blt.DestFormat.SampleFormat = <API key>;
if(g_Windowing.UseLimitedColor())
blt.DestFormat.NominalRange = <API key>;
else
blt.DestFormat.NominalRange = <API key>;
blt.Alpha = <API key>();
blt.ProcAmpValues.Brightness = ConvertRange( m_brightness, CMediaSettings::Get().<API key>().m_Brightness
, 0, 100, 50);
blt.ProcAmpValues.Contrast = ConvertRange( m_contrast, CMediaSettings::Get().<API key>().m_Contrast
, 0, 100, 50);
blt.ProcAmpValues.Hue = m_hue.DefaultValue;
blt.ProcAmpValues.Saturation = m_saturation.DefaultValue;
blt.BackgroundColor.Y = 0x1000;
blt.BackgroundColor.Cb = 0x8000;
blt.BackgroundColor.Cr = 0x8000;
blt.BackgroundColor.Alpha = 0xffff;
/* HACK to kickstart certain DXVA drivers (poulsbo) which oddly *
* won't render anything until someting else have been rendered. */
g_Windowing.Get3DDevice()->SetFVF( D3DFVF_XYZ );
float verts[2][3]= {};
g_Windowing.Get3DDevice()->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 1, verts, 3*sizeof(float));
CHECK(m_process->VideoProcessBlt(target, &blt, &samp[0], count, NULL));
return true;
}
bool CProcessor::LoadSymbols()
{
CSingleLock lock(m_dlSection);
if(m_dlHandle == NULL)
m_dlHandle = LoadLibraryEx("dxva2.dll", NULL, 0);
if(m_dlHandle == NULL)
return false;
<API key> = (<API key>)GetProcAddress(m_dlHandle, "<API key>");
if(<API key> == NULL)
return false;
return true;
}
#endif |
<!DOCTYPE HTML PUBLIC "-
<!-- NewPage -->
<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
<title>Uses of Interface org.apache.commons.math3.ode.sampling.StepInterpolator (Apache Commons Math 3.3 API)</title>
<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
</head>
<body>
<script type="text/javascript"><!
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Interface org.apache.commons.math3.ode.sampling.StepInterpolator (Apache Commons Math 3.3 API)";
}
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="topNav"><a name="navbar_top">
</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage"><em><script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=<API key>"></script></em></div>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../index.html?org/apache/commons/math3/ode/sampling/class-use/StepInterpolator.html" target="_top">Frames</a></li>
<li><a href="StepInterpolator.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip-navbar_top">
</a></div>
<div class="header">
<h2 title="Uses of Interface org.apache.commons.math3.ode.sampling.StepInterpolator" class="title">Uses of Interface<br>org.apache.commons.math3.ode.sampling.StepInterpolator</h2>
</div>
<div class="classUseContainer">
<ul class="blockList">
<li class="blockList">
<table border="0" cellpadding="3" cellspacing="0" summary="Use table, listing packages, and an explanation">
<caption><span>Packages that use <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Package</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><a href="#org.apache.commons.math3.ode">org.apache.commons.math3.ode</a></td>
<td class="colLast">
<div class="block">
This package provides classes to solve Ordinary Differential Equations problems.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><a href="#org.apache.commons.math3.ode.events">org.apache.commons.math3.ode.events</a></td>
<td class="colLast">
<div class="block">
This package provides classes to handle discrete events occurring during
Ordinary Differential Equations integration.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><a href="#org.apache.commons.math3.ode.sampling">org.apache.commons.math3.ode.sampling</a></td>
<td class="colLast">
<div class="block">
This package provides classes to handle sampling steps during
Ordinary Differential Equations integration.</div>
</td>
</tr>
</tbody>
</table>
</li>
<li class="blockList">
<ul class="blockList">
<li class="blockList"><a name="org.apache.commons.math3.ode">
</a>
<h3>Uses of <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a> in <a href="../../../../../../../org/apache/commons/math3/ode/package-summary.html">org.apache.commons.math3.ode</a></h3>
<table border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../../../org/apache/commons/math3/ode/package-summary.html">org.apache.commons.math3.ode</a> with parameters of type <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><span class="strong"><API key>.</span><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/<API key>.html#handleStep(org.apache.commons.math3.ode.sampling.StepInterpolator, boolean)">handleStep</a></strong>(<a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a> interpolator,
boolean isLast)</code>
<div class="block">Handle the last accepted step.</div>
</td>
</tr>
</tbody>
</table>
</li>
<li class="blockList"><a name="org.apache.commons.math3.ode.events">
</a>
<h3>Uses of <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a> in <a href="../../../../../../../org/apache/commons/math3/ode/events/package-summary.html">org.apache.commons.math3.ode.events</a></h3>
<table border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../../../org/apache/commons/math3/ode/events/package-summary.html">org.apache.commons.math3.ode.events</a> with parameters of type <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><span class="strong">EventState.</span><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/events/EventState.html#evaluateStep(org.apache.commons.math3.ode.sampling.StepInterpolator)">evaluateStep</a></strong>(<a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a> interpolator)</code>
<div class="block">Evaluate the impact of the proposed step on the event handler.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><span class="strong">EventState.</span><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/events/EventState.html#reinitializeBegin(org.apache.commons.math3.ode.sampling.StepInterpolator)">reinitializeBegin</a></strong>(<a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a> interpolator)</code>
<div class="block">Reinitialize the beginning of the step.</div>
</td>
</tr>
</tbody>
</table>
</li>
<li class="blockList"><a name="org.apache.commons.math3.ode.sampling">
</a>
<h3>Uses of <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a> in <a href="../../../../../../../org/apache/commons/math3/ode/sampling/package-summary.html">org.apache.commons.math3.ode.sampling</a></h3>
<table border="0" cellpadding="3" cellspacing="0" summary="Use table, listing classes, and an explanation">
<caption><span>Classes in <a href="../../../../../../../org/apache/commons/math3/ode/sampling/package-summary.html">org.apache.commons.math3.ode.sampling</a> that implement <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Class and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>class </code></td>
<td class="colLast"><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/sampling/<API key>.html" title="class in org.apache.commons.math3.ode.sampling"><API key></a></strong></code>
<div class="block">This abstract class represents an interpolator over the last step
during an ODE integration.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>class </code></td>
<td class="colLast"><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/sampling/<API key>.html" title="class in org.apache.commons.math3.ode.sampling"><API key></a></strong></code>
<div class="block">This class implements an interpolator for integrators using Nordsieck representation.</div>
</td>
</tr>
</tbody>
</table>
<table border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../../../org/apache/commons/math3/ode/sampling/package-summary.html">org.apache.commons.math3.ode.sampling</a> that return <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code><a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a></code></td>
<td class="colLast"><span class="strong">StepInterpolator.</span><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html#copy()">copy</a></strong>()</code>
<div class="block">Copy the instance.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code><a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a></code></td>
<td class="colLast"><span class="strong"><API key>.</span><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/sampling/<API key>.html#copy()">copy</a></strong>()</code>
<div class="block">Copy the instance.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a></code></td>
<td class="colLast"><span class="strong"><API key>.</span><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/sampling/<API key>.html#doCopy()">doCopy</a></strong>()</code>
<div class="block">Really copy the finalized instance.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected abstract <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a></code></td>
<td class="colLast"><span class="strong"><API key>.</span><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/sampling/<API key>.html#doCopy()">doCopy</a></strong>()</code>
<div class="block">Really copy the finalized instance.</div>
</td>
</tr>
</tbody>
</table>
<table border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../../../org/apache/commons/math3/ode/sampling/package-summary.html">org.apache.commons.math3.ode.sampling</a> with parameters of type <a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><span class="strong">StepNormalizer.</span><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepNormalizer.html#handleStep(org.apache.commons.math3.ode.sampling.StepInterpolator, boolean)">handleStep</a></strong>(<a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a> interpolator,
boolean isLast)</code>
<div class="block">Handle the last accepted step</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><span class="strong">StepHandler.</span><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepHandler.html#handleStep(org.apache.commons.math3.ode.sampling.StepInterpolator, boolean)">handleStep</a></strong>(<a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a> interpolator,
boolean isLast)</code>
<div class="block">Handle the last accepted step</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><span class="strong">DummyStepHandler.</span><code><strong><a href="../../../../../../../org/apache/commons/math3/ode/sampling/DummyStepHandler.html#handleStep(org.apache.commons.math3.ode.sampling.StepInterpolator, boolean)">handleStep</a></strong>(<a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">StepInterpolator</a> interpolator,
boolean isLast)</code>
<div class="block">Handle the last accepted step.</div>
</td>
</tr>
</tbody>
</table>
</li>
</ul>
</li>
</ul>
</div>
<div class="bottomNav"><a name="navbar_bottom">
</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="<API key>">
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../../../org/apache/commons/math3/ode/sampling/StepInterpolator.html" title="interface in org.apache.commons.math3.ode.sampling">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage"><em><script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=<API key>"></script></em></div>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../index.html?org/apache/commons/math3/ode/sampling/class-use/StepInterpolator.html" target="_top">Frames</a></li>
<li><a href="StepInterpolator.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="<API key>">
<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!
allClassesLink = document.getElementById("<API key>");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
</script>
</div>
<a name="skip-navbar_bottom">
</a></div>
<p class="legalCopy"><small>Copyright &
</body>
</html> |
<?php
/**
* Group Tools
*
* Save the group welcome message
*
* @author ColdTrick IT Solutions
*/
$group_guid = (int) get_input("group_guid");
$welcome_message = get_input("welcome_message");
$forward_url = REFERER;
if (!empty($group_guid)) {
$group = get_entity($group_guid);
if (!empty($group) && elgg_instanceof($group, "group")) {
if ($group->canEdit()) {
$check_message = trim(strip_tags($welcome_message));
if (!empty($check_message)) {
$group->setPrivateSetting("group_tools:welcome_message", $welcome_message);
} else {
$group-><API key>("group_tools:welcome_message");
}
system_message(elgg_echo("group_tools:action:welcome_message:success"));
$forward_url = $group->getURL();
} else {
register_error(elgg_echo("groups:cantedit"));
}
} else {
register_error(elgg_echo("groups:notfound:details"));
}
} else {
register_error(elgg_echo("<API key>:MissingParameter"));
}
forward($forward_url); |
<?php
namespace VuFind\Recommend;
use Zend\Http\Client as HttpClient,
Zend\Http\Client\Adapter\Exception\TimeoutException;
class DPLATerms implements RecommendInterface
{
/**
* Config
*
* @var string
*/
protected $apiKey;
/**
* Vufind HTTP Client
*
* @var HttpClient
*/
protected $client;
/**
* Setting of initial collapsedness
*
* @var bool
*/
protected $collapsed;
/**
* Search results object
*
* @var \VuFind\Search\Base\Results
*/
protected $searchObject;
/**
* Map of Solr field names to equivalent API parameters
*
* @var array
*/
protected $formatMap = [
'author_facet' => 'sourceResource.creator',
'building' => 'provider.name',
'format' => 'sourceResource.format',
'geographic_facet' => 'sourceResource.spatial.region',
'institution' => 'provider.name',
'language' => 'sourceResource.language.name',
'publishDate' => 'sourceResource.date.begin',
];
/**
* List of fields to retrieve from the API
*
* @var array
*/
protected $returnFields = [
'id',
'dataProvider',
'sourceResource.title',
'sourceResource.description',
];
/**
* Constructor
*
* @param string $apiKey API key
* @param HttpClient $client VuFind HTTP client
*/
public function __construct($apiKey, HttpClient $client)
{
$this->apiKey = $apiKey;
$this->client = $client;
}
/**
* Store the configuration of the recommendation module.
*
* @param string $settings Settings from searches.ini.
*
* @return void
*/
public function setConfig($settings)
{
$this->collapsed = filter_var($settings, <API key>);
}
/**
* Abstract-required method
*
* @param \VuFind\Search\Base\Params $params Search parameter object
* @param \Zend\StdLib\Parameters $request Parameter object representing user
* request.
*
* @return void
*
* @SuppressWarnings(PHPMD.<API key>)
*/
public function init($params, $request)
{
// No action needed.
}
/**
* Called after the Search Results object has performed its main search. This
* may be used to extract necessary information from the Search Results object
* or to perform completely unrelated processing.
*
* @param \VuFind\Search\Base\Results $results Search results object
*
* @return void
*/
public function process($results)
{
$this->searchObject = $results;
}
/**
* Get terms related to the query.
*
* @return array
*/
public function getResults()
{
$this->client->setUri('http://api.dp.la/v2/items');
$this->client->setMethod('GET');
$this->client->setParameterGet($this->getApiInput());
try {
$response = $this->client->send();
} catch (TimeoutException $e) {
error_log('DPLA API timeout -- skipping recommendations.');
return [];
}
if (!$response->isSuccess()) {
return [];
}
return $this->processResults($response->getBody());
}
/**
* Get input parameters for API call.
*
* @return array
*/
protected function getApiInput()
{
// Extract the first search term from the search object:
$search = $this->searchObject->getParams()->getQuery();
$filters = $this->searchObject->getParams()->getFilters();
$lookfor = ($search instanceof \VuFindSearch\Query\Query)
? $search->getString()
: '';
$params = [
'q' => $lookfor,
'fields' => implode(',', $this->returnFields),
'api_key' => $this->apiKey
];
foreach ($filters as $field => $filter) {
if (isset($this->formatMap[$field])) {
$params[$this->formatMap[$field]] = implode(',', $filter);
}
}
return $params;
}
/**
* Process the API response.
*
* @param string $response API response
*
* @return array
*/
protected function processResults($response)
{
$body = json_decode($response);
$results = [];
if ($body->count > 0) {
$title = 'sourceResource.title';
$desc = 'sourceResource.description';
foreach ($body->docs as $i => $doc) {
$results[$i] = [
'title' => is_array($doc->$title)
? current($doc->$title)
: $doc->$title,
'provider' => is_array($doc->dataProvider)
? current($doc->dataProvider)
: $doc->dataProvider,
'link' => 'http://dp.la/item/' . $doc->id
];
if (isset($doc->$desc)) {
$results[$i]['desc'] = is_array($doc->$desc)
? current($doc->$desc)
: $doc->$desc;
}
}
}
return $results;
}
/**
* Return the list of facets configured to be collapsed
*
* @return array
*/
public function isCollapsed()
{
return $this->collapsed;
}
} |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <pthread.h>
#include <errno.h>
#include "rpc.h"
//Standard define
#define PROCNUM 1
#define VERSNUM 1
static void exm_proc();
static int *thread_array_result;
int run_mode;
int progNum;
int callNb;
void *my_thread_process(void *arg)
{
SVCXPRT *transp = NULL;
struct netconfig *nconf = NULL;
int i;
if (run_mode == 1) {
fprintf(stderr, "Thread %ld\n", (long)arg);
}
nconf = getnetconfigent("udp");
if (nconf == NULL) {
//syslog(LOG_ERR, "getnetconfigent for udp failed");
printf("err nconf\n");
pthread_exit((void*)1l);
}
transp = svc_tli_create(RPC_ANYFD, nconf, NULL, 0, 0);
for (i = 0; i < callNb; i++) {
svc_unreg(progNum + atoi(arg), VERSNUM);
thread_array_result[atoi(arg)] +=
svc_reg(transp, progNum + atoi(arg), VERSNUM, exm_proc,
nconf);
}
pthread_exit(0);
}
int main(int argn, char *argc[])
{
//Program parameters : argc[1] : HostName or Host IP
// argc[2] : Server Program Number
// argc[3] : Number of threads
// argc[4] : Number of calls per thread
// other arguments depend on test case
//run_mode can switch into stand alone program or program launch by shell script
//1 : stand alone, debug mode, more screen information
//0 : launch by shell script as test case, only one printf -> result status
run_mode = 0;
int test_status = 1; //Default test result set to FAILED
int threadNb = atoi(argc[3]);
long i;
pthread_t *pThreadArray;
void *ret;
progNum = atoi(argc[2]);
callNb = atoi(argc[4]);
if (run_mode == 1) {
printf("Server #%d\n", progNum);
printf("Thread to create %d\n", threadNb);
}
//Initialization : create threads results array, init elements to 0
//Each thread will put function result (pas/fail) into array
thread_array_result = malloc(threadNb * sizeof(int));
memset(&thread_array_result[0], 0, threadNb * sizeof(int));
//Create all threads
//Run all threads
pThreadArray = malloc(threadNb * sizeof(pthread_t));
for (i = 0; i < threadNb; i++) {
if (run_mode == 1)
fprintf(stderr, "Try to create thread %ld\n", i);
if (pthread_create(&pThreadArray[i], NULL, my_thread_process, (void*)i)
< 0) {
fprintf(stderr, "pthread_create error for thread 1\n");
exit(1);
}
}
//Clean threads
for (i = 0; i < threadNb; i++) {
(void)pthread_join(pThreadArray[i], &ret);
}
//Check if all threads results are ok
test_status = 0;
for (i = 0; i < threadNb; i++) {
if (thread_array_result[i] != callNb) {
test_status = 1;
break;
}
}
if (run_mode == 1) {
for (i = 0; i < threadNb; i++) {
fprintf(stderr, "Result[%ld]=%d\n", i,
thread_array_result[i]);
}
}
//This last printf gives the result status to the tests suite
//normally should be 0: test has passed or 1: test has failed
printf("%d\n", test_status);
return test_status;
}
static void exm_proc(struct svc_req *rqstp, SVCXPRT * transp)
{
//Nothing to do here in that test case
} |
// This file is part of Check_MK.
// check_mk is free software; you can redistribute it and/or modify it
// the Free Software Foundation in version 2. check_mk is distributed
// ails. You should have received a copy of the GNU General Public
// to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
// Boston, MA 02110-1301 USA.
#ifndef CountAggregator_h
#define CountAggregator_h
#include "Aggregator.h"
#include "StatsColumn.h"
class Filter;
class CountAggregator : public Aggregator
{
Filter *_filter;
public:
CountAggregator(Filter *f) : Aggregator(STATS_OP_COUNT), _filter(f) {}
void consume(void *data, Query *);
void output(Query *);
};
#endif // CountAggregator_h |
if (not gadgetHandler:IsSyncedCode()) then
return false
end
function gadget:GetInfo()
return {
name = "UnitStealth",
desc = "Adds passive unit stealth capability",
author = "Sprung",
date = "2016-12-15",
license = "PD",
layer = 0,
enabled = true,
}
end
local spSetUnitStealth = Spring.SetUnitStealth
local <API key> = Spring.SetUnitSonarStealth
function gadget:UnitCloaked(unitID)
spSetUnitStealth(unitID, true)
<API key>(unitID, true)
end
function gadget:UnitDecloaked(unitID)
spSetUnitStealth(unitID, false)
<API key>(unitID, false)
end |
#ifndef _COMMONINC_HH_
#define _COMMONINC_HH_
//STL stuff
#include <iostream>
#include <fstream>
#include <sstream>
#include <cfloat>
#include <cassert>
#include <cmath>
#include <string>
#include <complex>
#include <vector>
#include <set>
#include <map>
#include <deque>
#include <queue>
#include <utility>
#include <algorithm>
//complex number
#define cpx cpx8
#define zpx cpx16
//aux functions
inline int pow2(int l) { assert(l>=0); return (1<<l); }
#define iC(fun) { int ierr=fun; assert(ierr==0); }
#define iA(expr) { if((expr)==0) { std::cerr<<"wrong "<<__LINE__<<" in " <<__FILE__<<endl; assert(expr); } }
using std::istream;
using std::ostream;
using std::ios_base;
using std::endl;
using std::abs;
using std::cerr;
#endif |
#define PARAM_FILE_COUNTER 0x38
// DRYOS-Notes:
// propertycase
// 196 - overall brightness (of viewport?)
#include "platform.h"
const ApertureSize <API key>[] = {
{ 9, 283, "2.8" },
{ 10, 320, "3.2" },
{ 11, 352, "3.5" },
{ 12, 384, "4.0" },
{ 13, 416, "4.5" },
{ 14, 448, "5.0" },
{ 15, 480, "5.6" },
{ 16, 512, "6.3" },
{ 17, 544, "7.1" },
{ 18, 576, "8.0" },
};
const ShutterSpeed <API key>[] = {
{ -12, -384, "15", 15000000 },
{ -11, -352, "13", 13000000 },
{ -10, -320, "10", 10000000 },
{ -9, -288, "8", 8000000 },
{ -8, -256, "6", 6000000 },
{ -7, -224, "5", 5000000 },
{ -6, -192, "4", 4000000 },
{ -5, -160, "3.2", 3200000 },
{ -4, -128, "2.5", 2500000 },
{ -3, -96, "2", 2000000 },
{ -2, -64, "1.6", 1600000 },
{ -1, -32, "1.3", 1300000 },
{ 0, 0, "1", 1000000 },
{ 1, 32, "0.8", 800000 },
{ 2, 64, "0.6", 600000 },
{ 3, 96, "0.5", 500000 },
{ 4, 128, "0.4", 400000 },
{ 5, 160, "0.3", 300000 },
{ 6, 192, "1/4", 250000 },
{ 7, 224, "1/5", 200000 },
{ 8, 256, "1/6", 166667 },
{ 9, 288, "1/8", 125000 },
{ 10, 320, "1/10", 100000 },
{ 11, 352, "1/13", 76923 },
{ 12, 384, "1/15", 66667 },
{ 13, 416, "1/20", 50000 },
{ 14, 448, "1/25", 40000 },
{ 15, 480, "1/30", 33333 },
{ 16, 512, "1/40", 25000 },
{ 17, 544, "1/50", 20000 },
{ 18, 576, "1/60", 16667 },
{ 19, 608, "1/80", 12500 },
{ 20, 640, "1/100", 10000 },
{ 21, 672, "1/125", 8000 },
{ 22, 704, "1/160", 6250 },
{ 23, 736, "1/200", 5000 },
{ 24, 768, "1/250", 4000 },
{ 25, 800, "1/320", 3125 },
{ 26, 832, "1/400", 2500 },
{ 27, 864, "1/500", 2000 },
{ 28, 896, "1/640", 1563 },
{ 29, 928, "1/800", 1250 },
{ 30, 960, "1/1000", 1000 },
{ 31, 992, "1/1250", 800 },
{ 32, 1021, "1/1600", 625 },
{ 33, 1053, "1/2000", 500 },
};
const ISOTable iso_table[] = {
{ -1, 1, "HI", -1},
{ 0, 0, "Auto", -1},
{ 1, 80, "80", -1},
{ 2, 100, "100", -1},
{ 3, 200, "200", -1},
{ 4, 400, "400", -1},
{ 5, 800, "800", -1},
{ 6, 1600, "1600", -1},
};
static const CapturemodeMap modemap[] = {
{ MODE_AUTO, 32768 },
{ MODE_P, 32772 },
{ MODE_TV, 32771 },
{ MODE_AV, 32770 },
{ MODE_M, 32769 },
{ MODE_VIDEO_STD, 2597 },
{ MODE_VIDEO_COMPACT, 2599 },
{ MODE_STITCH, 33290 },
{ MODE_SCN_UNDERWATER, 16406 },
{ MODE_SCN_AQUARIUM, 16407 },
{ <API key>, 16398 },
{ MODE_SCN_FOLIAGE, 16402 },
{ MODE_SCN_SNOW, 16403 },
{ MODE_SCN_BEACH, 16404 },
{ MODE_SCN_FIREWORK, 16405 },
{ MODE_INDOOR, 32785 },
{ MODE_KIDS_PETS, 32784 },
{ MODE_NIGHT_SNAPSHOT, 32779 },
{ MODE_LANDSCAPE, 32780 },
{ MODE_PORTRAIT, 32781 },
};
#include "../generic/shooting.c"
const int dof_tbl[] = {5800, 6420, 7060, 7700, 8340, 9950, 11550, 13160, 14750, 17150, 19570, 22760, 26750, 30750, 34800};
const int dof_tbl_size = sizeof(dof_tbl)/sizeof(dof_tbl[0]);
long <API key>() {
return get_file_counter();
}
long get_target_file_num() {
long n;
n = <API key>();
n = (n>>4)&0x3FFF;
return n;
}
long get_target_dir_num() {
long n;
n = <API key>();
n = (n>>18)&0x3FF;
return n;
}
int circle_of_confusion = 5; |
<div class="container" id="mainContent">
<div id="topOfPage">
</div>
<h1>
Submit Feedback
</h1>
<br>
<form action="/page/<API key>" method="post" name="<API key>">
<input name="fsname" type="hidden" value="First feedback session">
<input name="courseid" type="hidden" value="IESFPTCourse">
<input name="token" type="hidden" value="${sessionToken}">
<input name="user" type="hidden" value="IESFPTCourseinstr">
<div id="<API key>">
<div class="overflow-auto alert alert-success icon-success statusMessage">
All responses submitted successfully!
</div>
</div>
<script defer="" src="/js/statusMessage.js" type="text/javascript">
</script>
<div class="well well-plain" id="course1">
<div class="panel-body">
<div class="form-horizontal">
<div class="panel-heading">
<div class="form-group">
<label class="col-sm-2 control-label">
Course ID:
</label>
<div class="col-sm-10">
<p class="form-control-static">
IESFPTCourse
</p>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">
Session:
</label>
<div class="col-sm-10">
<p class="form-control-static">
First feedback session
</p>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">
Opening time:
</label>
<div class="col-sm-10">
<p class="form-control-static">
Sun, 01 Apr 2012, 11:59 PM UTC+0200
</p>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">
Closing time:
</label>
<div class="col-sm-10">
<p class="form-control-static" data-end-time="2027-04-30T21:59:00Z" id="end-time">
Fri, 30 Apr 2027, 11:59 PM UTC+0200
</p>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">
Instructions:
</label>
<div class="col-sm-10">
<p class="form-control-static text-preserve-space">
Please please fill in the following questions.
</p>
</div>
</div>
</div>
</div>
</div>
</div>
<br>
<input name="questiontype-1" type="hidden" value="TEXT">
<input name="questionid-1" type="hidden" value="${question.id}">
<input name="<API key>" type="hidden" value="1">
<div class="form-horizontal">
<div class="panel panel-primary">
<div class="panel-heading">
Question 1:
<br>
<span class="text-preserve-space">
What is the best selling point of your product?
</span>
</div>
<div class="panel-body">
<p class="text-muted">
Only the following persons can see your responses:
</p>
<ul class="text-muted">
<li class="unordered">
Instructors in this course can see your response, the name of the recipient, and your name.
</li>
</ul>
<br>
<div class="form-group margin-0">
<div class="col-sm-2 form-inline mobile-align-left" style="display:none">
<label for="input">
To:
</label>
<select class="participantSelect middlealign form-control" name="<API key>" style="display:none;max-width:125px">
<option value="">
</option>
<option selected="" value="<API key>@gmail.tmt">
Myself
</option>
</select>
<span>
Myself
</span>
</div>
<div class="col-sm-12">
<div class="panel panel-default panel-body mce-content-body content-editor" contenteditable="true" <API key>="true" data-length-text-id="responseLength-1-0" <API key>="0" id="responsetext-1-0" name="responsetext-1-0" spellcheck="false" style="position: relative;">
<p>
Good design
</p>
</div>
<input name="responsetext-1-0" type="hidden">
<div class="margin-top-7px text-color-gray font-weight-normal">
<div class="col-md-6 padding-0" style="display:none">
Recommended length for the answer:
<span id="<API key>">
0
</span>
words
</div>
<div class="pull-right">
Response length:
<span id="responseLength-1-0" style="color: rgb(128, 128, 128);">
2
</span>
words
</div>
</div>
<input name="responseid-1-0" type="hidden" value="${question.id}%<API key>@gmail.tmt%<API key>@gmail.tmt">
</div>
</div>
</div>
</div>
</div>
<br>
<br>
<input name="questiontype-2" type="hidden" value="NUMSCALE">
<input name="questionid-2" type="hidden" value="${question.id}">
<input name="<API key>" type="hidden" value="1">
<div class="form-horizontal">
<div class="panel panel-primary">
<div class="panel-heading">
Question 2:
<br>
<span class="text-preserve-space">
Rate your product.
</span>
</div>
<div class="panel-body">
<p class="text-muted">
Only the following persons can see your responses:
</p>
<ul class="text-muted">
<li class="unordered">
Instructors in this course can see your response, the name of the recipient, and your name.
</li>
<li class="unordered">
You can see your own feedback in the results page later on.
</li>
</ul>
<br>
<div class="form-group margin-0">
<div class="col-sm-2 form-inline mobile-align-left" style="display:none">
<label for="input">
To:
</label>
<select class="participantSelect middlealign form-control" name="<API key>" style="display:none;max-width:125px">
<option value="">
</option>
<option selected="" value="<API key>@gmail.tmt">
Myself
</option>
</select>
<span>
Myself
</span>
</div>
<div class="col-sm-12">
<div class="col-sm-3 mobile-no-padding">
<input class="numScaleAnswerBox form-control col-sm-2" max="5" min="1" name="responsetext-2-0" onchange="<API key>(2, 0)" step="0.5" type="number" value="4">
<input name="numscalemin-2-0" type="hidden" value="1">
<input name="numscalemax-2-0" type="hidden" value="5">
<input name="numscalestep-2-0" type="hidden" value="0.5">
</div>
<div class="text-muted form-control-static">
[Possible values: 1, 1.5, 2, ..., 4, 4.5, 5]
</div>
<input name="responseid-2-0" type="hidden" value="${question.id}%<API key>@gmail.tmt%<API key>@gmail.tmt">
</div>
</div>
</div>
</div>
</div>
<br>
<br>
<div class="bold align-center">
<input name="moderatedperson" type="hidden" value="<API key>@gmail.tmt">
<input name="sendsubmissionemail" type="checkbox">
Send me a confirmation email
<button class="btn btn-primary center-block margin-top-7px" data-original-title="You can save your responses at any time and come back later to continue." data-placement="top" data-toggle="tooltip" id="<API key>" title="" type="submit">
Submit Feedback
</button>
</div>
<br>
<br>
</form>
</div> |
/*$Id: NodeHookAction.java,v 1.1.4.2 2005/04/08 21:37:30 christianfoltin Exp $*/
package freemind.modes.actions;
import java.awt.event.ActionEvent;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import java.util.logging.Logger;
import javax.swing.Action;
import javax.swing.ImageIcon;
import javax.swing.JMenuItem;
import javax.xml.bind.JAXBException;
import freemind.controller.<API key>;
import freemind.controller.actions.ActionPair;
import freemind.controller.actions.ActorXml;
import freemind.controller.actions.FreemindAction;
import freemind.controller.actions.generated.instance.HookNodeAction;
import freemind.controller.actions.generated.instance.NodeListMember;
import freemind.controller.actions.generated.instance.NodeListMemberType;
import freemind.controller.actions.generated.instance.XmlAction;
import freemind.extensions.HookFactory;
import freemind.extensions.<API key>;
import freemind.extensions.NodeHook;
import freemind.extensions.PermanentNodeHook;
import freemind.modes.MindMapNode;
import freemind.modes.ModeController;
public class NodeHookAction extends FreemindAction implements ActorXml, <API key> {
String _hookName;
ModeController controller;
public ModeController getController() {
return controller;
}
private static Logger logger;
public NodeHookAction(String hookName, ModeController controller) {
//URGENT: hookName must be translated!!
super(hookName, (ImageIcon) null, null);
this._hookName = hookName;
this.controller = controller;
if(logger == null)
logger = controller.getFrame().getLogger(this.getClass().getName());
controller.getActionFactory().registerActor(this, getDoActionClass());
}
public void actionPerformed(ActionEvent arg0) {
// check, which method of invocation:
controller.getFrame().setWaitingCursor(true);
invoke(controller.getSelected(), controller.getSelecteds());
controller.getFrame().setWaitingCursor(false);
}
public void addHook(MindMapNode focussed, List selecteds, String hookName) {
HookNodeAction doAction = <API key>(focussed, selecteds, hookName);
XmlAction undoAction=null;
try {
// this is the non operation:
undoAction = controller.getActionXmlFactory()
.<API key>();
} catch (JAXBException e) {
e.printStackTrace();
}
if (<API key>(hookName).isPermanent()) {
// double application = remove.
undoAction = <API key>(focussed,
selecteds, hookName);
}
if (<API key>(hookName).isUndoable()) {
getController().getActionFactory().startTransaction((String) getValue(NAME));
getController().getActionFactory().executeAction(new ActionPair(doAction, undoAction));
getController().getActionFactory().endTransaction((String) getValue(NAME));
} else {
// direct invocation without undo and such stuff.
invoke(focussed, selecteds, hookName);
}
}
public void invoke(MindMapNode focussed, List selecteds) {
addHook(focussed, selecteds, _hookName);
}
private void invoke(MindMapNode focussed, List selecteds, String hookName) {
logger.finest("invoke(selecteds) called.");
<API key> instMethod = <API key>(hookName);
// get destination nodes
Collection destinationNodes = instMethod.getDestinationNodes(controller, focussed, selecteds);
MindMapNode adaptedFocussedNode = instMethod.getCenterNode(controller, focussed, selecteds);
// test if hook already present
if(instMethod.isAlreadyPresent(controller, hookName, adaptedFocussedNode, destinationNodes)){
// remove the hook:
for (Iterator i = destinationNodes.iterator(); i.hasNext();) {
MindMapNode <API key> = (MindMapNode) i.next();
// find the hook ini the current node, if present:
for (Iterator j = <API key>.getActivatedHooks().iterator(); j
.hasNext();) {
PermanentNodeHook hook = (PermanentNodeHook) j.next();
if(hook.getName().equals(hookName)) {
<API key>.removeHook(hook);
/* fc, 30.7.2004:
* we have to break. otherwise the collection is modified
* at two points (i.e., the collection is not valid anymore after removing
* one element).
* But this is no problem, as there exist only "once" plugins currently.
*/
break;
}
}
}
} else {
// add the hook
for (Iterator it = destinationNodes.iterator(); it.hasNext();) {
MindMapNode <API key> = (MindMapNode) it.next();
NodeHook hook = controller
.createNodeHook(hookName, <API key>, controller.getMap());
logger.finest("created hook "+hookName);
// call invoke.
<API key>.invokeHook(hook);
if (hook instanceof PermanentNodeHook) {
PermanentNodeHook permHook = (PermanentNodeHook) hook;
logger.finest("This is a permanent hook "+ hookName);
// the focussed receives the focus:
if (<API key> == adaptedFocussedNode) {
permHook.onReceiveFocusHook();
}
// using this method, the map is dirty now. This is important to
// guarantee, that the hooks are saved.
controller.nodeChanged(<API key>);
}
}
finishInvocation(focussed, selecteds, adaptedFocussedNode, destinationNodes);
}
}
/**
* @param focussed The real focussed node
* @param selecteds The list of selected nodes
* @param adaptedFocussedNode The calculated focussed node (if the hook specifies, that
* the hook should apply to root, then this is the root node).
* @param destinationNodes The calculated list of selected nodes (see last)
*/
private void finishInvocation(MindMapNode focussed, List selecteds,
MindMapNode adaptedFocussedNode, Collection destinationNodes) {
// select all destination nodes:
// fc, 25.8.2004: The following code snippet should be moved to a more general place.
if (focussed.getViewer() != null) {
getController().getView().<API key>(
focussed.getViewer());
getController().getView().scrollNodeToVisible(
focussed.getViewer());
for (Iterator i = selecteds.iterator(); i.hasNext();) {
MindMapNode node = (MindMapNode) i.next();
if(node.getViewer() != null) {
getController().getView().makeTheSelected(node.getViewer());
}
}
}
}
/**
* @return
*/
private <API key> <API key>(String hookName) {
HookFactory factory = getHookFactory();
// determine instanciation method
<API key> instMethod = factory.<API key>(hookName);
return instMethod;
}
/**
* @return
*/
private HookFactory getHookFactory() {
HookFactory factory = controller.getFrame().getHookFactory();
return factory;
}
/* (non-Javadoc)
* @see freemind.controller.<API key>#isEnabled(javax.swing.JMenuItem, javax.swing.Action)
*/
public boolean isEnabled(JMenuItem item, Action action) {
// test if plugin has its own method:
HookFactory factory = getHookFactory();
Object baseClass = factory.getPluginBaseClass(_hookName);
if(baseClass != null) {
if (baseClass instanceof <API key>) {
<API key> listener = (<API key>) baseClass;
return listener.isEnabled(item, this);
}
}
MindMapNode focussed = controller.getSelected();
List selecteds = controller.getSelecteds();
<API key> instMethod = <API key>(_hookName);
// get destination nodes
Collection destinationNodes = instMethod.getDestinationNodes(controller, focussed, selecteds);
MindMapNode adaptedFocussedNode = instMethod.getCenterNode(controller, focussed, selecteds);
// test if hook already present
boolean isActionSelected = instMethod.isAlreadyPresent(controller, _hookName, adaptedFocussedNode, destinationNodes);
setSelected(item, isActionSelected);
return true;
}
public HookNodeAction <API key>(MindMapNode focussed, List selecteds, String hookName) {
try {
HookNodeAction hookNodeAction = getController()
.getActionXmlFactory().<API key>();
hookNodeAction.setNode(focussed.getObjectId(getController()));
hookNodeAction.setHookName(hookName);
// selectedNodes list
for (Iterator i = selecteds.iterator(); i.hasNext();) {
MindMapNode node = (MindMapNode) i.next();
NodeListMember nodeListMember = getController()
.getActionXmlFactory().<API key>();
nodeListMember.setNode(node.getObjectId(getController()));
hookNodeAction.getNodeListMember().add(nodeListMember);
}
return hookNodeAction;
} catch (JAXBException e) {
e.printStackTrace();
return null;
}
}
public void act(XmlAction action) {
if (action instanceof HookNodeAction) {
HookNodeAction hookNodeAction = (HookNodeAction) action;
MindMapNode selected = getController().getNodeFromID(hookNodeAction.getNode());
Vector selecteds = new Vector();
for (Iterator i = hookNodeAction.getNodeListMember().iterator(); i.hasNext();) {
NodeListMemberType node = (NodeListMemberType) i.next();
selecteds.add(getController().getNodeFromID(node.getNode()));
}
invoke(selected, selecteds, hookNodeAction.getHookName());
}
}
public Class getDoActionClass() {
return HookNodeAction.class;
}
/**
* @return
*/
public String getHookName() {
return _hookName;
}
} |
package com.bioxx.tfc.Commands;
import net.minecraft.command.CommandBase;
import net.minecraft.command.ICommandSender;
import net.minecraft.command.<API key>;
import net.minecraft.entity.player.EntityPlayerMP;
import com.bioxx.tfc.Core.TFC_Climate;
public class GetBioTempCommand extends CommandBase{
@Override
public String getCommandName() {
return "gbt";
}
@Override
public void processCommand(ICommandSender sender, String[] params)
{
//MinecraftServer var3 = MinecraftServer.getServer();
EntityPlayerMP var4 = <API key>(sender);
float t = TFC_Climate.<API key>(var4.worldObj, (int)var4.posX, (int)var4.posY, (int)var4.posZ);
throw new <API key>("BioTemp: "+t);
}
@Override
public String getCommandUsage(ICommandSender icommandsender)
{
return "";
}
} |
// The LLVM Compiler Infrastructure
// This file is distributed under the University of Illinois Open Source
// This header defines the VersionTuple class, which represents a version in
// the form major[.minor[.subminor]].
#ifndef <API key>
#define <API key>
#include "clang/Basic/LLVM.h"
#include "llvm/ADT/Optional.h"
#include <string>
namespace clang {
\brief Represents a version number in the form major[.minor[.subminor]].
class VersionTuple {
unsigned Major;
unsigned Minor : 31;
unsigned Subminor : 31;
unsigned HasMinor : 1;
unsigned HasSubminor : 1;
public:
VersionTuple()
: Major(0), Minor(0), Subminor(0), HasMinor(false), HasSubminor(false) { }
explicit VersionTuple(unsigned Major)
: Major(Major), Minor(0), Subminor(0), HasMinor(false), HasSubminor(false)
{ }
explicit VersionTuple(unsigned Major, unsigned Minor)
: Major(Major), Minor(Minor), Subminor(0), HasMinor(true),
HasSubminor(false)
{ }
explicit VersionTuple(unsigned Major, unsigned Minor, unsigned Subminor)
: Major(Major), Minor(Minor), Subminor(Subminor), HasMinor(true),
HasSubminor(true)
{ }
\brief Determine whether this version information is empty
(e.g., all version components are zero).
bool empty() const { return Major == 0 && Minor == 0 && Subminor == 0; }
\brief Retrieve the major version number.
unsigned getMajor() const { return Major; }
\brief Retrieve the minor version number, if provided.
llvm::Optional<unsigned> getMinor() const {
if (!HasMinor)
return llvm::Optional<unsigned>();
return Minor;
}
\brief Retrieve the subminor version number, if provided.
llvm::Optional<unsigned> getSubminor() const {
if (!HasSubminor)
return llvm::Optional<unsigned>();
return Subminor;
}
\brief Determine if two version numbers are equivalent. If not
provided, minor and subminor version numbers are considered to be zero.
friend bool operator==(const VersionTuple& X, const VersionTuple &Y) {
return X.Major == Y.Major && X.Minor == Y.Minor && X.Subminor == Y.Subminor;
}
\brief Determine if two version numbers are not equivalent. If
not provided, minor and subminor version numbers are considered to be
zero.
friend bool operator!=(const VersionTuple &X, const VersionTuple &Y) {
return !(X == Y);
}
\brief Determine whether one version number precedes another. If not
provided, minor and subminor version numbers are considered to be zero.
friend bool operator<(const VersionTuple &X, const VersionTuple &Y) {
if (X.Major != Y.Major)
return X.Major < Y.Major;
if (X.Minor != Y.Minor)
return X.Minor < Y.Minor;
return X.Subminor < Y.Subminor;
}
\brief Determine whether one version number follows another. If not
provided, minor and subminor version numbers are considered to be zero.
friend bool operator>(const VersionTuple &X, const VersionTuple &Y) {
return Y < X;
}
\brief Determine whether one version number precedes or is
equivalent to another. If not provided, minor and subminor
version numbers are considered to be zero.
friend bool operator<=(const VersionTuple &X, const VersionTuple &Y) {
return !(Y < X);
}
\brief Determine whether one version number follows or is
equivalent to another. If not provided, minor and subminor
version numbers are considered to be zero.
friend bool operator>=(const VersionTuple &X, const VersionTuple &Y) {
return !(X < Y);
}
\brief Retrieve a string representation of the version number/
std::string getAsString() const;
};
\brief Print a version number.
raw_ostream& operator<<(raw_ostream &Out, const VersionTuple &V);
} // end namespace clang
#endif // <API key> |
# -*- coding: utf-8 -*-
# needed for Python 3 compatibility
from __future__ import absolute_import, division, print_function
import numpy as np
import quantities as pq
from neo.core.baseneo import BaseNeo, MergeError, merge_annotations
def <API key>(cls, times, signal, units=None, time_units=None, dtype=None,
copy=True, name=None, file_origin=None, description=None,
annotations=None):
'''
A function to map <API key>.__new__ to function that
does not do the unit checking. This is needed for pickle to work.
'''
return cls(times=times, signal=signal, units=units, time_units=time_units,
dtype=dtype, copy=copy, name=name, file_origin=file_origin,
description=description, **annotations)
class <API key>(BaseNeo, pq.Quantity):
'''
An array of one or more analog signals with samples taken at arbitrary time points.
A representation of one or more continuous, analog signals acquired at time
:attr:`t_start` with a varying sampling interval. Each channel is sampled
at the same time points.
*Usage*::
from neo.core import <API key>
from quantities import s, nA
irsig0 = <API key>([0.0, 1.23, 6.78], [1, 2, 3],
units='mV', time_units='ms')
irsig1 = <API key>([0.01, 0.03, 0.12]*s,
[[4, 5], [5, 4], [6, 3]]*nA)
*Required attributes/properties*:
:times: (quantity array 1D, numpy array 1D, or list)
The time of each data point. Must have the same size as :attr:`signal`.
:signal: (quantity array 2D, numpy array 2D, or list (data, channel))
The data itself.
:units: (quantity units)
Required if the signal is a list or NumPy array, not if it is
a :class:`Quantity`.
:time_units: (quantity units) Required if :attr:`times` is a list or
NumPy array, not if it is a :class:`Quantity`.
*Recommended attributes/properties*:.
:name: (str) A label for the dataset
:description: (str) Text description.
:file_origin: (str) Filesystem path or URL of the original data file.
*Optional attributes/properties*:
:dtype: (numpy dtype or str) Override the dtype of the signal array.
(times are always floats).
:copy: (bool) True by default.
Note: Any other additional arguments are assumed to be user-specific
metadata and stored in :attr:`annotations`.
*Properties available on this object*:
:sampling_intervals: (quantity array 1D) Interval between each adjacent
pair of samples.
(``times[1:] - times[:-1]``)
:duration: (quantity scalar) Signal duration, read-only.
(``times[-1] - times[0]``)
:t_start: (quantity scalar) Time when signal begins, read-only.
(``times[0]``)
:t_stop: (quantity scalar) Time when signal ends, read-only.
(``times[-1]``)
*Slicing*:
:class:`<API key>` objects can be sliced. When this
occurs, a new :class:`<API key>` (actually a view) is
returned, with the same metadata, except that :attr:`times` is also
sliced in the same way.
*Operations available on this object*:
== != + * /
'''
<API key> = ('Segment', 'ChannelIndex')
_quantity_attr = 'signal'
_necessary_attrs = (('times', pq.Quantity, 1),
('signal', pq.Quantity, 2))
def __new__(cls, times, signal, units=None, time_units=None, dtype=None,
copy=True, name=None, file_origin=None,
description=None,
**annotations):
'''
Construct a new :class:`<API key>` instance.
This is called whenever a new :class:`<API key>` is
created from the constructor, but not when slicing.
'''
if units is None:
if hasattr(signal, "units"):
units = signal.units
else:
raise ValueError("Units must be specified")
elif isinstance(signal, pq.Quantity):
# could improve this test, what if units is a string?
if units != signal.units:
signal = signal.rescale(units)
if time_units is None:
if hasattr(times, "units"):
time_units = times.units
else:
raise ValueError("Time units must be specified")
elif isinstance(times, pq.Quantity):
# could improve this test, what if units is a string?
if time_units != times.units:
times = times.rescale(time_units)
# should check time units have correct dimensions
obj = pq.Quantity.__new__(cls, signal, units=units,
dtype=dtype, copy=copy)
if obj.ndim == 1:
obj = obj.reshape(-1, 1)
if len(times) != obj.shape[0]:
raise ValueError("times array and signal array must "
"have same length")
obj.times = pq.Quantity(times, units=time_units,
dtype=float, copy=copy)
obj.segment = None
obj.channel_index = None
return obj
def __init__(self, times, signal, units=None, time_units=None, dtype=None,
copy=True, name=None, file_origin=None, description=None,
**annotations):
'''
Initializes a newly constructed :class:`<API key>`
instance.
'''
BaseNeo.__init__(self, name=name, file_origin=file_origin,
description=description, **annotations)
def __reduce__(self):
'''
Map the __new__ function onto <API key>, so that pickle
works
'''
return <API key>, (self.__class__,
self.times,
np.array(self),
self.units,
self.times.units,
self.dtype,
True,
self.name,
self.file_origin,
self.description,
self.annotations)
def __array_finalize__(self, obj):
'''
This is called every time a new :class:`<API key>` is
created.
It is the appropriate place to set default values for attributes
for :class:`<API key>` constructed by slicing or
viewing.
User-specified values are only relevant for construction from
constructor, and these are set in __new__. Then they are just
copied over here.
'''
super(<API key>, self).__array_finalize__(obj)
self.times = getattr(obj, 'times', None)
# The additional arguments
self.annotations = getattr(obj, 'annotations', None)
# Globally recommended attributes
self.name = getattr(obj, 'name', None)
self.file_origin = getattr(obj, 'file_origin', None)
self.description = getattr(obj, 'description', None)
def __repr__(self):
'''
Returns a string representing the :class:`<API key>`.
'''
return '<%s(%s at times %s)>' % (self.__class__.__name__,
super(<API key>,
self).__repr__(), self.times)
def __getslice__(self, i, j):
'''
Get a slice from :attr:`i` to :attr:`j`.
Doesn't get called in Python 3, :meth:`__getitem__` is called instead
'''
return self.__getitem__(slice(i, j))
def __getitem__(self, i):
'''
Get the item or slice :attr:`i`.
'''
obj = super(<API key>, self).__getitem__(i)
if isinstance(i, int): # a single point in time across all channels
obj = pq.Quantity(obj.magnitude, units=obj.units)
elif isinstance(i, tuple):
j, k = i
if isinstance(j, int): # a single point in time across some channels
obj = pq.Quantity(obj.magnitude, units=obj.units)
else:
if isinstance(j, slice):
obj.times = self.times.__getitem__(j)
elif isinstance(j, np.ndarray):
raise NotImplementedError("Arrays not yet supported")
else:
raise TypeError("%s not supported" % type(j))
if isinstance(k, int):
obj = obj.reshape(-1, 1)
elif isinstance(i, slice):
obj.times = self.times.__getitem__(i)
else:
raise IndexError("index should be an integer, tuple or slice")
return obj
@property
def duration(self):
'''
Signal duration.
(:attr:`times`[-1] - :attr:`times`[0])
'''
return self.times[-1] - self.times[0]
@property
def t_start(self):
'''
Time when signal begins.
(:attr:`times`[0])
'''
return self.times[0]
@property
def t_stop(self):
'''
Time when signal ends.
(:attr:`times`[-1])
'''
return self.times[-1]
def __eq__(self, other):
'''
Equality test (==)
'''
return (super(<API key>, self).__eq__(other).all() and
(self.times == other.times).all())
def __ne__(self, other):
'''
Non-equality test (!=)
'''
return not self.__eq__(other)
def _apply_operator(self, other, op, *args):
'''
Handle copying metadata to the new :class:`<API key>`
after a mathematical operation.
'''
self._check_consistency(other)
f = getattr(super(<API key>, self), op)
new_signal = f(other, *args)
new_signal.<API key>(self)
return new_signal
def _check_consistency(self, other):
'''
Check if the attributes of another :class:`<API key>`
are compatible with this one.
'''
# if not an array, then allow the calculation
if not hasattr(other, 'ndim'):
return
# if a scalar array, then allow the calculation
if not other.ndim:
return
# dimensionality should match
if self.ndim != other.ndim:
raise ValueError('Dimensionality does not match: %s vs %s' %
(self.ndim, other.ndim))
# if if the other array does not have a times property,
# then it should be okay to add it directly
if not hasattr(other, 'times'):
return
# if there is a times property, the times need to be the same
if not (self.times == other.times).all():
raise ValueError('Times do not match: %s vs %s' %
(self.times, other.times))
def <API key>(self, other):
'''
Copy the metadata from another :class:`<API key>`.
'''
for attr in ("times", "name", "file_origin",
"description", "annotations"):
setattr(self, attr, getattr(other, attr, None))
def __add__(self, other, *args):
'''
Addition (+)
'''
return self._apply_operator(other, "__add__", *args)
def __sub__(self, other, *args):
'''
Subtraction (-)
'''
return self._apply_operator(other, "__sub__", *args)
def __mul__(self, other, *args):
'''
Multiplication (*)
'''
return self._apply_operator(other, "__mul__", *args)
def __truediv__(self, other, *args):
'''
Float division (/)
'''
return self._apply_operator(other, "__truediv__", *args)
def __div__(self, other, *args):
'''
Integer division (//)
'''
return self._apply_operator(other, "__div__", *args)
__radd__ = __add__
__rmul__ = __sub__
def __rsub__(self, other, *args):
'''
Backwards subtraction (other-self)
'''
return self.__mul__(-1) + other
def _repr_pretty_(self, pp, cycle):
'''
Handle pretty-printing the :class:`<API key>`.
'''
pp.text("{cls} with {channels} channels of length {length}; "
"units {units}; datatype {dtype} ".format(
cls=self.__class__.__name__,
channels=self.shape[1],
length=self.shape[0],
units=self.units.dimensionality.string,
dtype=self.dtype))
if self.<API key>():
pp.breakable()
self._repr_pretty_attrs_(pp, cycle)
def _pp(line):
pp.breakable()
with pp.group(indent=1):
pp.text(line)
for line in ["sample times: {0}".format(self.times)]:
_pp(line)
@property
def sampling_intervals(self):
'''
Interval between each adjacent pair of samples.
(:attr:`times[1:]` - :attr:`times`[:-1])
'''
return self.times[1:] - self.times[:-1]
def mean(self, interpolation=None):
'''
Calculates the mean, optionally using interpolation between sampling
times.
If :attr:`interpolation` is None, we assume that values change
stepwise at sampling times.
'''
if interpolation is None:
return (self[:-1]*self.sampling_intervals.reshape(-1, 1)).sum()/self.duration
else:
raise NotImplementedError
def resample(self, at=None, interpolation=None):
'''
Resample the signal, returning either an :class:`AnalogSignal` object
or another :class:`<API key>` object.
Arguments:
:at: either a :class:`Quantity` array containing the times at
which samples should be created (times must be within the
signal duration, there is no extrapolation), a sampling rate
with dimensions (1/Time) or a sampling interval
with dimensions (Time).
:interpolation: one of: None, 'linear'
'''
# further interpolation methods could be added
raise NotImplementedError
def rescale(self, units):
'''
Return a copy of the :class:`<API key>` converted to the
specified units
'''
to_dims = pq.quantity.<API key>(units)
if self.dimensionality == to_dims:
to_u = self.units
signal = np.array(self)
else:
to_u = pq.Quantity(1.0, to_dims)
from_u = pq.Quantity(1.0, self.dimensionality)
try:
cf = pq.quantity.<API key>(from_u, to_u)
except AssertionError:
raise ValueError('Unable to convert between units of "%s" \
and "%s"' % (from_u._dimensionality,
to_u._dimensionality))
signal = cf * self.magnitude
new = self.__class__(times=self.times, signal=signal, units=to_u)
new.<API key>(self)
new.annotations.update(self.annotations)
return new
def merge(self, other):
'''
Merge another :class:`<API key>` with this one, and return the
merged signal.
The :class:`<API key>` objects are concatenated horizontally
(column-wise, :func:`np.hstack`).
If the attributes of the two :class:`<API key>` are not
compatible, a :class:`MergeError` is raised.
'''
if not np.array_equal(self.times, other.times):
raise MergeError("Cannot merge these two signals as the sample times differ.")
if self.segment != other.segment:
raise MergeError("Cannot merge these two signals as they belong to different segments.")
if hasattr(self, "lazy_shape"):
if hasattr(other, "lazy_shape"):
if self.lazy_shape[0] != other.lazy_shape[0]:
raise MergeError("Cannot merge signals of different length.")
merged_lazy_shape = (self.lazy_shape[0], self.lazy_shape[1] + other.lazy_shape[1])
else:
raise MergeError("Cannot merge a lazy object with a real object.")
if other.units != self.units:
other = other.rescale(self.units)
stack = np.hstack(map(np.array, (self, other)))
kwargs = {}
for name in ("name", "description", "file_origin"):
attr_self = getattr(self, name)
attr_other = getattr(other, name)
if attr_self == attr_other:
kwargs[name] = attr_self
else:
kwargs[name] = "merge(%s, %s)" % (attr_self, attr_other)
merged_annotations = merge_annotations(self.annotations,
other.annotations)
kwargs.update(merged_annotations)
signal = <API key>(self.times, stack, units=self.units,
dtype=self.dtype, copy=False,
**kwargs)
signal.segment = self.segment
if hasattr(self, "lazy_shape"):
signal.lazy_shape = merged_lazy_shape
return signal
def time_slice (self, t_start, t_stop):
'''
Creates a new :class:`<API key>` corresponding to the time slice of
the original :class:`<API key>` between times
`t_start` and `t_stop`. Either parameter can also be None
to use infinite endpoints for the time interval.
'''
_t_start = t_start
_t_stop = t_stop
if t_start is None:
_t_start = -np.inf
if t_stop is None:
_t_stop = np.inf
indices = (self.times >= _t_start) & (self.times <= _t_stop)
count = 0
id_start = None
id_stop = None
for i in indices :
if id_start == None :
if i == True :
id_start = count
else :
if i == False :
id_stop = count
break
count += 1
new_st = self[id_start:id_stop]
return new_st
def as_array(self, units=None):
"""
Return the signal as a plain NumPy array.
If `units` is specified, first rescale to those units.
"""
if units:
return self.rescale(units).magnitude
else:
return self.magnitude
def as_quantity(self):
"""
Return the signal as a quantities array.
"""
return self.view(pq.Quantity) |
using Newtonsoft.Json;
namespace Nez.<API key>
{
public class TexturePackerRegion
{
[JsonProperty( "filename" )]
public string filename;
[JsonProperty( "frame" )]
public <API key> frame;
[JsonProperty( "rotated" )]
public bool isRotated;
[JsonProperty( "trimmed" )]
public bool isTrimmed;
[JsonProperty( "spriteSourceSize" )]
public <API key> sourceRectangle;
[JsonProperty( "sourceSize" )]
public TexturePackerSize sourceSize;
[JsonProperty( "pivot" )]
public TexturePackerPoint pivotPoint;
public override string ToString()
{
return string.Format( "{0} {1}", filename, frame );
}
}
} |
package org.overture.interpreter.scheduler;
import java.io.Serializable;
abstract public class SchedulingPolicy implements Serializable
{
private static final long serialVersionUID = 1L;
abstract public boolean reschedule();
abstract public ISchedulableThread getThread();
abstract public long getTimeslice();
abstract public void register(ISchedulableThread thread, long priority);
abstract public void unregister(ISchedulableThread thread);
abstract public void reset();
abstract public void advance();
abstract public boolean hasActive();
abstract public boolean hasPriorities();
abstract public String getStatus();
abstract public long timeToNextAlarm();
public static SchedulingPolicy factory(String type)
{
if (type.equals("FP"))
{
return new FPPolicy();
}
return new FCFSPolicy(); // Default for everything!
}
} |
package com.jaspervanriet.huntingthatproduct.Entities;
import android.os.Parcel;
import android.os.Parcelable;
import com.google.gson.annotations.SerializedName;
import java.util.ArrayList;
import java.util.List;
public class Collection implements Parcelable {
private int id;
private String name;
private String title;
@SerializedName ("<API key>")
private String backgroundImageUrl;
@SerializedName ("collection_url")
private String collectionUrl;
private List<Product> posts;
@Override
public int describeContents () {
return 0;
}
@Override
public void writeToParcel (Parcel out, int flags) {
out.writeInt (id);
out.writeString (name);
out.writeString (title);
out.writeString (backgroundImageUrl);
out.writeString (collectionUrl);
out.writeList (posts);
}
public static final Creator<Collection> CREATOR = new Parcelable
.Creator<Collection> () {
public Collection createFromParcel (Parcel in) {
return new Collection (in);
}
public Collection[] newArray (int size) {
return new Collection[size];
}
};
private Collection (Parcel in) {
this.id = in.readInt ();
this.name = in.readString ();
this.title = in.readString ();
this.backgroundImageUrl = in.readString ();
this.collectionUrl = in.readString ();
posts = new ArrayList<> ();
in.readList (posts, getClass ().getClassLoader ());
}
public int getId () {
return id;
}
public void setId (int id) {
this.id = id;
}
public String getName () {
return name;
}
public void setName (String name) {
this.name = name;
}
public String getTitle () {
return title;
}
public void setTitle (String title) {
this.title = title;
}
public String <API key> () {
return backgroundImageUrl;
}
public void <API key> (String backgroundImageUrl) {
this.backgroundImageUrl = backgroundImageUrl;
}
public String getCollectionUrl () {
return collectionUrl;
}
public void setCollectionUrl (String collectionUrl) {
this.collectionUrl = collectionUrl;
}
public List<Product> getPosts () {
return posts;
}
public void setPosts (List<Product> posts) {
this.posts = posts;
}
public static Creator<Collection> getCREATOR () {
return CREATOR;
}
} |
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "argp.h"
/* If set by the user program to a non-zero value, then a default option
--version is added (unless the ARGP_NO_HELP flag is used), which calls
this function with a stream to print the version to and a pointer to the
current parsing state, and then exits (unless the ARGP_NO_EXIT flag is
used). This variable takes precedent over <API key>. */
void (*<API key>) (FILE *stream, struct argp_state *state) = NULL; |
<center>
<p>
<?php if(file_exists("setlang.php")){?>
<a href=setlang.php?lang=ko></a>
<a href=setlang.php?lang=cn></a>
<a href=setlang.php?lang=fa>فارسی</a>
<a href=setlang.php?lang=en>English</a>
<a href=setlang.php?lang=th>ไทย</a> <br>
<?php }?>
Anything about the Problems, Please Contact Admin:<a href="mailto:<?php echo $OJ_ADMIN?>">admin</a>
<script type="text/javascript" charset="utf-8">
(function(){
var _w = 86 , _h = 50;
var param = {
url:location.href,
type:'6',
count:'1',
appkey:'', /**appkey,()*/
title:'', /**(title)*/
pic:'',
ralateUid:'', /**UID@()*/
language:'zh_cn', /**zh_cn|zh_tw()*/
rnd:new Date().valueOf()
}
var temp = [];
for( var p in param ){
temp.push(p + '=' + encodeURIComponent( param[p] || '' ) )
}
document.write('<iframe allowTransparency="true" frameborder="0" scrolling="no" src="http://hits.sinajs.cn/A1/weiboshare.html?' + temp.join('&') + '" width="'+ _w+'" height="'+_h+'"></iframe>')
})()
</script>
<br>
All Copyright Reserved 2010-2015 <a href='<?php echo $OJ_HOME?>'><?php echo $OJ_NAME?></a> TEAM<br>
<a href=gpl-2.0.txt><span class=green>GPL2.0</span></a> 2003-2012 <a href='http://code.google.com/p/hustoj/'>HUSTOJ Project</a> TEAM<br>
<?php if ($OJ_SAE) {
echo "<a href=http:
}
?>
</p>
</center> |
<?php
// This is a SPIP language file -- Ceci est un fichier langue de SPIP
// ** ne pas modifier le fichier **
if (!defined('_ECRIRE_INC_VERSION')) return;
$GLOBALS[$GLOBALS['idx_lang']] = array(
'accueil_site' => 'Prima pagină', # MODIF
'article' => 'Articol',
'articles' => 'Articole',
'articles_auteur' => 'Articole de acelaşi autor',
'articles_populaires' => 'Cele mai populare articole',
'articles_rubrique' => 'Articolele acestei rubrici',
'aucun_article' => 'Nu există nici un articol la această adresă',
'aucun_auteur' => 'Nu există nici un autor la această adresă',
'aucun_site' => 'Nu există nici un site la această adresă',
'aucune_breve' => 'Nu există nici o ştire la această adresă',
'aucune_rubrique' => 'Nu există nici o rubrică la această adresă',
'auteur' => 'Autor',
'autres' => 'Altele',
'autres_breves' => 'Alte ştiri',
'<API key>' => 'Alte grupuri de cuvinte-cheie',
'autres_sites' => 'Alte site-uri',
'bonjour' => 'Bună ziua',
'commenter_site' => 'Comentaţi acest site',
'contact' => 'Contact', # NEW
'<API key>' => 'Imposibil de copiat documentul',
'date' => 'Data',
'dernier_ajout' => 'Ultima adăugare',
'dernieres_breves' => 'Ultimele ştiri',
'derniers_articles' => 'Ultimele articole',
'<API key>' => 'Ultimele comentarii',
'<API key>' => 'Ultimele mesaje publicate în forum-uri',
'edition_mode_texte' => 'Editare în mod text a',
'en_reponse' => 'Răspuns la :',
'en_resume' => 'Pe scurt',
'envoyer_message' => 'Trimiteţi un mesaj',
'espace_prive' => 'Secţiunea protejată',
'formats_acceptes' => 'Formate acceptate : @formats@.',
'hierarchie_site' => 'Ierarhia site-ului',
'jours' => 'zile',
'lien_connecter' => 'Conectare',
'meme_auteur' => 'De acelaşi autor',
'meme_rubrique' => 'În aceaşi rubrică',
'memes_auteurs' => 'De aceaşi autori',
'message' => 'Mesaj',
'messages_forum' => 'Mesajele forum-ului', # MODIF
'messages_recents' => 'Cele mai recente mesaje de forum',
'mots_clef' => 'Cuvânt-cheie',
'mots_clefs' => 'Cuvinte-cheie',
'<API key>' => 'Cuvinte-cheie în acelaşi grup',
'navigation' => 'Navigare',
'nom' => 'Nume',
'nouveautes' => 'Noutăţi',
'nouveautes_web' => 'Noutăţi pe Web',
'nouveaux_articles' => 'Articole noi',
'nouvelles_breves' => 'Ştiri noi',
'page_precedente' => 'pagina anterioară',
'page_suivante' => 'pagina următoare',
'par_auteur' => 'de ',
'participer_site' => 'Puteţi deveni o parte activă a acestui site şi puteţi să vă scrieţi propriile articole înregistrându-vă cu ajutorul formularului de mai jos. Veţi primi în scurt timp un email conţinând un cod de acces la secţiunea protejată a acestui site.',
'plan_site' => 'Harta site-ului',
'popularite' => 'Popularitate',
'poster_message' => 'Trimiteţi un mesaj',
'proposer_site' => 'Puteţi propune un site de adăugat în această rubrică :',
'repondre_article' => 'Răspundeţi la acest articol',
'repondre_breve' => 'Răspundeţi la acestă ştire',
'resultats_recherche' => 'Rezultatele căutarii',
'retour_debut_forums' => 'Înapoi la începutul forum-urilor',
'rubrique' => 'Rubrică',
'rubriques' => 'Rubrici',
'signatures_petition' => 'Semnături',
'<API key>' => 'Site realizat cu SPIP',
'sites_web' => 'Site-uri Web',
'sous_rubriques' => 'Sub-rubrici',
'spam' => 'Spam',
'suite' => 'continuă',
'sur_web' => 'Pe Web',
'syndiquer_rubrique' => 'Sindicalizaţi această rubrică',
'syndiquer_site' => 'Sindicalizaţi întregul site',
'<API key>' => 'Iată scrisoarea de informaţii a site-ului',
'<API key>' => 'Această scrisoare conţine lista noutatilor publicate de la',
'ver_imprimer' => 'Versiunea imprimabilă',
'voir_en_ligne' => 'Vedeţi în direct',
'voir_squelette' => 'vedeţi scheletul acestei pagini'
);
?> |
{namespace neos=Neos\Neos\ViewHelpers}
<f:layout name="BackendSubModule" />
<f:section name="subtitle">
</f:section>
<f:section name="content">
<f:if condition="{siteChanges}">
<f:then>
<f:form action="<API key>">
<f:form.hidden name="selectedWorkspace" value="{selectedWorkspace}"/>
<legend>{neos:backend.translate(id: 'workspaces.unpublishedChanges', source: 'Modules', package: 'Neos.Neos', arguments: {0: <API key>})}</legend>
<br />
<div class="neos-row-fluid">
<table class="neos-table">
<thead>
<tr>
<th class="check neos-priority1">
<label for="check-all" class="neos-checkbox">
<input type="checkbox" id="check-all" /><span></span>
</label>
</th>
<th></th>
<th class="neos-action"></th>
</tr>
</thead>
<tbody>
<f:for each="{siteChanges}" as="site">
<f:for each="{site.documents}" key="documentPath" as="document">
<tr class="neos-document" data-nodepath="{document.documentNode.path}" data-ismoved="{f:if(condition: document.isMoved, then: 'true', else: 'false')}" data-isnew="{f:if(condition: document.isNew, then: 'true', else: 'false')}">
<f:if condition="{document.changes -> f:count()} > 1">
<f:then>
<td class="check neos-priority1">
<label for="check-document-{document.documentNode.identifier}" class="neos-checkbox"><f:form.checkbox id="check-document-{document.documentNode.identifier}" class="neos-check-document" value="{document.documentNode.identifier}"/><span></span></label>
</td>
<td class="neos-priority1 path-caption">
</f:then>
<f:else>
<td colspan="2" class="neos-priority1 path-caption">
</f:else>
</f:if>
<div class="neos-row-fluid">
<div class="neos-span2">
{neos:backend.translate(id: 'pathCaption', source: 'Main', package: 'Neos.Neos')}:
<f:render partial="Module/Shared/DocumentBreadcrumb" arguments="{node: document.documentNode, showIcon: true}"></f:render>
</div>
<div class="neos-span2 neos-pull-right neos-aRight">
<f:if condition="{document.documentNode.removed}">
<f:else>
<neos:link.node node="{document.documentNode}" absolute="1" target="neosPreview" class="neos-button" title="{neos:backend.translate(id: 'workspaces.openPageInWorkspace', source: 'Modules', package: 'Neos.Neos', value: 'Open page in \"{0}\" workspace', arguments: {0: <API key>})}" <API key>="{data-neos-toggle: 'tooltip'}"><i class="fas <API key> icon-white"></i></neos:link.node><button form="postHelper" formaction="{f:uri.action(action: 'rebaseAndRedirect', arguments: {targetNode: document.documentNode, targetWorkspace: selectedWorkspace})}" type="submit" class="neos-button" title="{neos:backend.translate(id: 'edit', source: 'Main', package: 'Neos.Neos', value: 'Edit')}" data-neos-toggle="tooltip"><i class="fas fa-pencil-alt icon-white"></i></button>
</f:else>
</f:if>
</div>
</div>
</td>
<td class="neos-action neos-folder">
<i class="fold-toggle fas fa-chevron-up icon-white" data-toggle="fold-{document.documentNode.identifier}"></i>
</td>
</tr>
<f:for each="{document.changes}" key="relativePath" as="change">
<tr class="neos-change fold-{document.documentNode.identifier} document-{document.documentNode.identifier}" data-nodepath="{change.node.path}" data-ismoved="{f:if(condition: change.isMoved, then: 'true', else: 'false')}" data-isnew="{f:if(condition: change.isNew, then: 'true', else: 'false')}">
<td class="check neos-priority1">
<label for="{change.node.identifier}" class="neos-checkbox"><f:form.checkbox name="nodes[]" value="{change.node.contextPath}" id="{change.node.identifier}" /><span></span></label>
</td>
<td id="change-{change.node.identifier}" {f:render(partial: 'Module/Management/Workspaces/<API key>', arguments: {change: change})} data-neos-toggle="tooltip" data-placement="left" data-container="body">
<f:render partial="Module/Management/Workspaces/ContentChangeDiff" arguments="{change: change, contentDimensions: contentDimensions}"/>
</td>
<td class="neos-action">
<f:if condition="{<API key>}">
<button form="postHelper" formaction="{f:uri.action(action: 'publishNode', arguments: {node: change.node.contextPath, selectedWorkspace: selectedWorkspace})}" type="submit" class="neos-button neos-button-success neos-pull-right" title="{neos:backend.translate(id: 'publish', source: 'Main', package: 'Neos.Neos')}" data-neos-toggle="tooltip">
<i class="fas fa-check icon-white"></i>
</button>
</f:if>
<button form="postHelper" formaction="{f:uri.action(action: 'discardNode', arguments: {node: change.node.contextPath, selectedWorkspace: selectedWorkspace})}" type="submit" class="neos-button neos-button-danger neos-pull-right" title="{neos:backend.translate(id: 'discard', source: 'Main', package: 'Neos.Neos')}" data-neos-toggle="tooltip" data-placement="bottom">
<i class="fas fa-trash-alt icon-white"></i>
</button>
</td>
</tr>
</f:for>
</f:for>
</f:for>
</tbody>
</table>
</div>
<f:render section="actions" arguments="{_all}" />
</f:form>
<div class="neos-hide" id="discard">
<div class="neos-modal-centered">
<div class="neos-modal-content">
<div class="neos-modal-header">
<button type="button" class="neos-close neos-button" data-dismiss="modal"></button>
<div class="neos-header">{neos:backend.translate(id: 'workspaces.<API key>', arguments: {0: <API key>}, source: 'Modules', package: 'Neos.Neos')}</div>
</div>
<div class="neos-modal-footer">
<a href="#" class="neos-button" data-dismiss="modal">{neos:backend.translate(id: 'cancel', source: 'Main', package: 'Neos.Neos')}</a>
<button form="postHelper" formaction="{f:uri.action(action: 'discardWorkspace', arguments: {workspace: selectedWorkspace})}" type="submit" class="neos-button neos-button-danger">
<i class="fas fa-trash-alt icon-white"></i>
{neos:backend.translate(id: 'workspaces.discardAllChanges', source: 'Modules', package: 'Neos.Neos')}
</button>
</div>
</div>
</div>
<div class="neos-modal-backdrop neos-in"></div>
</div>
<f:form action="index" id="postHelper" method="post"></f:form>
<script>
window.addEventListener('DOMContentLoaded', (event) => {
jQuery(function($) {
jQuery('#check-all').change(function() {
var value = false;
if (jQuery(this).is(':checked')) {
value = true;
jQuery('.batch-action').removeClass('neos-hidden').removeClass('neos-disabled').removeAttr('disabled');
} else {
jQuery('.batch-action').addClass('neos-hidden').addClass('neos-disabled').attr('disabled', 'disabled');
}
jQuery('tbody input[type="checkbox"]').prop('checked', value);
});
jQuery('.neos-check-document').change(function() {
var documentIdentifier = jQuery(this).val();
var checked = jQuery(this).prop('checked');
jQuery(this).closest('table').find('tr.neos-change.document-' + documentIdentifier + ' td.check input').prop('checked', checked);
});
jQuery('tbody input[type="checkbox"]').change(function() {
if (jQuery(this).closest('tr').data('ismoved') === true || jQuery(this).closest('tr').data('isnew') === true) {
var currentNodePath = jQuery(this).closest('tr').attr('data-nodepath') + '/';
var checked = jQuery(this).prop('checked');
function nodePathStartsWith(nodePath) {
return function(index, element) {
return nodePath.indexOf(jQuery(element).data('nodepath')) === 0;
}
}
var <API key> = jQuery(this).closest('table').find('.neos-document[data-ismoved="true"], .neos-document[data-isnew="true"]').filter(nodePathStartsWith(currentNodePath));
jQuery(<API key>).each(function(index, movedParentDocument) {
jQuery('tr[data-nodepath^="' + jQuery(movedParentDocument).data('nodepath') + '"] td.check input').prop('checked', checked);
});
}
if (jQuery('tbody input[type="checkbox"]:checked').length > 0) {
jQuery('.batch-action').removeClass('neos-hidden').removeClass('neos-disabled').removeAttr('disabled')
} else {
jQuery('.batch-action').addClass('neos-hidden').addClass('neos-disabled').attr('disabled', 'disabled');
}
});
jQuery('.fold-toggle').click(function() {
jQuery(this).toggleClass('fas fa-chevron-down fas fa-chevron-up');
jQuery('tr.' + jQuery(this).data('toggle')).toggle();
});
});
});
</script>
</f:then>
<f:else>
<legend>{neos:backend.translate(id: 'workspaces.unpublishedChanges', source: 'Modules', package: 'Neos.Neos', arguments: {0: <API key>})}</legend>
<p>{neos:backend.translate(id: 'workspaces.<API key>', source: 'Modules', package: 'Neos.Neos')}</p>
<div class="neos-footer">
<div class="pull-left">
<f:link.action action="index" class="neos-button">{neos:backend.translate(id: 'back', source: 'Main', package: 'Neos.Neos')}</f:link.action>
</div>
</div>
</f:else>
</f:if>
</f:section>
<f:section name="actions">
<div class="neos-footer">
<div class="neos-pull-left">
<f:link.action action="index" class="neos-button">{neos:backend.translate(id: 'back', source: 'Main', package: 'Neos.Neos')}</f:link.action>
</div>
<div class="neos-pull-right">
<f:if condition="{<API key>}">
<f:then>
<button type="submit" name="moduleArguments[action]" value="publish" class="neos-button neos-hidden neos-disabled batch-action" disabled="disabled">{neos:backend.translate(id: 'workspaces.<API key>', source: 'Modules', package: 'Neos.Neos')}</button>
<button type="submit" name="moduleArguments[action]" value="discard" class="neos-button neos-hidden neos-disabled batch-action" disabled="disabled">{neos:backend.translate(id: 'workspaces.<API key>', source: 'Modules', package: 'Neos.Neos')}</button>
<button class="neos-button neos-button-danger" data-toggle="modal" href="#discard">{neos:backend.translate(id: 'workspaces.discardAllChanges', source: 'Modules', package: 'Neos.Neos')}</button>
<button form="postHelper" formaction="{f:uri.action(action: 'publishWorkspace', arguments: {workspace: selectedWorkspace})}" type="submit" class="neos-button neos-button-primary">{neos:backend.translate(id: 'workspaces.publishAllChangesTo', source: 'Modules', package: 'Neos.Neos', arguments: {0: baseWorkspaceLabel})}</button>
</f:then>
<f:else>
<button type="submit" name="moduleArguments[action]" value="publish" class="neos-button neos-hidden neos-disabled batch-action" disabled="disabled">{neos:backend.translate(id: 'workspaces.<API key>', source: 'Modules', package: 'Neos.Neos')}</button>
<button type="submit" name="moduleArguments[action]" value="discard" class="neos-button neos-hidden neos-disabled batch-action" disabled="disabled">{neos:backend.translate(id: 'workspaces.<API key>', source: 'Modules', package: 'Neos.Neos')}</button>
<button class="neos-button neos-button-danger" data-toggle="modal" href="#discard">{neos:backend.translate(id: 'workspaces.discardAllChanges', source: 'Modules', package: 'Neos.Neos')}</button>
</f:else>
</f:if>
</div>
</div>
</f:section> |
using System.Reflection;
using System.Runtime.CompilerServices;
[assembly: AssemblyDescription("GitExtensions common")]
[assembly: InternalsVisibleTo("GitExtUtils.Tests")]
[assembly: InternalsVisibleTo("GitUI.Tests")]
[assembly: InternalsVisibleTo("GitExtensions")]
[assembly: InternalsVisibleTo("BugReporter")]
[assembly: InternalsVisibleTo("CommonTestUtils")]
[assembly: InternalsVisibleTo("TranslationApp")] |
GO.base.SavedExportDialog = Ext.extend(GO.dialog.TabbedFormDialog , {
jsonPost: true,
className : null,
initComponent : function(){
Ext.apply(this, {
title:GO.lang.savedExport,
goDialogId:'saved-export-dialog',
formControllerUrl: 'core/export',
height:400,
width:500,
enableOkButton : true,
enableApplyButton : false,
enableCloseButton : true
});
GO.base.SavedExportDialog.superclass.initComponent.call(this);
},
buildForm : function () {
// this.columnsPanel= new GO.grid.MultiSelectGrid({
// title: GO.lang.columns,
// extraColumns : [{
// header: GO.lang.strLabel,
// dataIndex: "label",
// id: "label",
// width: 250
// region:'center',
// loadMask:true,
// allowNoSelection : true,
// store: new Ext.data.JsonStore({fields: ['name','label']})
this.columnsPanel = new GO.base.ColumnSelectPanel({
region:'center'
});
this.viewCombo = new Ext.form.ComboBox({
fieldLabel : GO.lang.strType,
hiddenName: 'savedExport.view',
name: 'savedExport.view',
mode: 'local',
editable:false,
triggerAction:'all',
lazyRender:true,
width: 120,
value:"Csv",
store: new Ext.data.JsonStore({fields: ['view']}),
valueField: 'view',
displayField: 'view'
});
this.nameField = new Ext.form.TextField({
name: 'savedExport.name',
width:300,
anchor: '100%',
maxLength: 100,
allowBlank:false,
fieldLabel: GO.lang.strName
});
this.exportOrientation = new Ext.form.ComboBox({
fieldLabel : GO.lang.exportOrientation,
hiddenName: 'savedExport.orientation',
name: 'savedExport.orientation',
mode: 'local',
editable:false,
triggerAction:'all',
lazyRender:true,
width: 120,
value:"V",
store: new Ext.data.SimpleStore({
fields: [
'id',
'label'
],
data: [['H', GO.lang.landscape], ['V', GO.lang.portrait]]
}),
valueField: 'id',
displayField: 'label'
});
this.useDbColumnNames = new Ext.ux.form.XCheckbox({
fieldLabel : GO.lang.exportHumanHeaders,
name : 'savedExport.use_db_column_names'
});
this.includeColumnNames = new Ext.ux.form.XCheckbox({
fieldLabel : GO.lang.includeColumnNames,
name : 'savedExport.<API key>'
});
this.hiddenColumns = new Ext.form.Hidden({
name : 'savedExport.export_columns'
});
this.propertiesPanel = new Ext.Panel({
title:GO.lang.strProperties,
cls:'go-form-panel',
layout:'form',
labelWidth:160,
items:[
this.nameField,
this.viewCombo,
this.exportOrientation,
this.includeColumnNames,
this.useDbColumnNames,
this.hiddenColumns
]
});
this.addPanel(this.propertiesPanel);
this.addPanel(this.columnsPanel);
},
beforeSubmit : function(params){
var selected = this.columnsPanel.getSelected();
this.hiddenColumns.setValue(selected.toString());
},
afterLoad : function(remoteModelId, config, action){
// console.log(action);
this.viewCombo.store.loadData(action.result.supportedViews);
if(action.result.data.savedExport.attributes.view)
this.viewCombo.setValue(action.result.data.savedExport.attributes.view);
if(action.result.data.savedExport.attributes.<API key>)
this.includeColumnNames.setValue(action.result.data.savedExport.attributes.<API key>);
if(action.result.data.savedExport.attributes.use_db_column_names)
this.useDbColumnNames.setValue(action.result.data.savedExport.attributes.use_db_column_names);
this.columnsPanel.reset();
this.columnsPanel.loadData(action.result.columns);
if(action.result.data.savedExport.attributes.export_columns)
this.columnsPanel.setSelected(action.result.data.savedExport.attributes.export_columns,true);
},
setClass : function(className){
this.className = className;
this.loadParams = {className : this.className};
this.formPanel.form.baseParams['savedExport.class_name'] = this.className;
},
getSubmitParams : function(){
return {className : this.className};
},
checkOrientation : function(selectedRadio){
if(!selectedRadio.orientation)
this.exportOrientation.hide();
else
this.exportOrientation.show();
this.syncShadow();
}
}); |
<!DOCTYPE HTML PUBLIC "-
<!--NewPage
<HTML>
<HEAD>
<TITLE>
Uses of Class org.apache.poi.ss.formula.eval.UnaryPlusEval (POI API Documentation)
</TITLE>
<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../../../../../stylesheet.css" TITLE="Style">
<SCRIPT type="text/javascript">
function windowTitle()
{
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Class org.apache.poi.ss.formula.eval.UnaryPlusEval (POI API Documentation)";
}
}
</SCRIPT>
<NOSCRIPT>
</NOSCRIPT>
</HEAD>
<BODY BGCOLOR="white" onload="windowTitle();">
<HR>
<A NAME="navbar_top"></A>
<A HREF="#skip-navbar_top" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_top_firstrow"></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
<TR ALIGN="center" VALIGN="top">
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../../../overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../package-summary.html"><FONT CLASS="NavBarFont1"><B>Package</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../../../org/apache/poi/ss/formula/eval/UnaryPlusEval.html" title="class in org.apache.poi.ss.formula.eval"><FONT CLASS="NavBarFont1"><B>Class</B></FONT></A> </TD>
<TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> <FONT CLASS="NavBarFont1Rev"><B>Use</B></FONT> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../package-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../../../deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../../../index-all.html"><FONT CLASS="NavBarFont1"><B>Index</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../../../help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A> </TD>
</TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
</EM>
</TD>
</TR>
<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
PREV
NEXT</FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
<A HREF="../../../../../../../index.html?org/apache/poi/ss/formula/eval//<API key>.html" target="_top"><B>FRAMES</B></A>
<A HREF="UnaryPlusEval.html" target="_top"><B>NO FRAMES</B></A>
<SCRIPT type="text/javascript">
<!
if(window==top) {
document.writeln('<A HREF="../../../../../../../allclasses-noframe.html"><B>All Classes</B></A>');
}
</SCRIPT>
<NOSCRIPT>
<A HREF="../../../../../../../allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>
</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_top"></A>
<HR>
<CENTER>
<H2>
<B>Uses of Class<br>org.apache.poi.ss.formula.eval.UnaryPlusEval</B></H2>
</CENTER>
No usage of org.apache.poi.ss.formula.eval.UnaryPlusEval
<P>
<HR>
<A NAME="navbar_bottom"></A>
<A HREF="#skip-navbar_bottom" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="<API key>"></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
<TR ALIGN="center" VALIGN="top">
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../../../overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../package-summary.html"><FONT CLASS="NavBarFont1"><B>Package</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../../../org/apache/poi/ss/formula/eval/UnaryPlusEval.html" title="class in org.apache.poi.ss.formula.eval"><FONT CLASS="NavBarFont1"><B>Class</B></FONT></A> </TD>
<TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> <FONT CLASS="NavBarFont1Rev"><B>Use</B></FONT> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../package-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../../../deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../../../index-all.html"><FONT CLASS="NavBarFont1"><B>Index</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../../../../../help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A> </TD>
</TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
</EM>
</TD>
</TR>
<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
PREV
NEXT</FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
<A HREF="../../../../../../../index.html?org/apache/poi/ss/formula/eval//<API key>.html" target="_top"><B>FRAMES</B></A>
<A HREF="UnaryPlusEval.html" target="_top"><B>NO FRAMES</B></A>
<SCRIPT type="text/javascript">
<!
if(window==top) {
document.writeln('<A HREF="../../../../../../../allclasses-noframe.html"><B>All Classes</B></A>');
}
</SCRIPT>
<NOSCRIPT>
<A HREF="../../../../../../../allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>
</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_bottom"></A>
<HR>
<i>Copyright 2017 The Apache Software Foundation or
its licensors, as applicable.</i>
</BODY>
</HTML> |
#ifndef _PELE_OPTIMIZER_H__
#define _PELE_OPTIMIZER_H__
#include "base_potential.h"
#include "array.h"
#include <vector>
#include <math.h>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <memory>
namespace pele{
/**
* this defines the basic interface for optimizers. All pele optimizers
* should derive from this class.
*/
class Optimizer {
public:
/**
* virtual destructor
*/
virtual ~Optimizer() {}
virtual void one_iteration() = 0;
/**
* Run the optimization algorithm until the stop criterion is satisfied or
* until the maximum number of iterations is reached
*/
virtual void run() = 0;
/**
* Run the optimization algorithm for niter iterations or until the
* stop criterion is satisfied
*/
virtual void run(int const niter) = 0;
/**
* accessors
*/
inline virtual Array<double> get_x() const = 0;
inline virtual Array<double> get_g() const = 0;
inline virtual double get_f() const = 0;
inline virtual double get_rms() const = 0;
inline virtual int get_nfev() const = 0;
inline virtual int get_niter() const = 0;
inline virtual bool success() = 0;
};
/**
* This defines the basic interface for optimizers. All pele optimizers
* should derive from this class.
*/
class GradientOptimizer : public Optimizer {
protected :
// input parameters
/**
* A pointer to the object that computes the function and gradient
*/
std::shared_ptr<pele::BasePotential> potential_;
double tol_; /**< The tolerance for the rms gradient */
double maxstep_; /**< The maximum step size */
int maxiter_; /**< The maximum number of iterations */
int iprint_; /**< how often to print status information */
int verbosity_; /**< How much information to print */
int iter_number_; /**< The current iteration number */
int nfev_; /**< The number of function evaluations */
// variables representing the state of the system
Array<double> x_; /**< The current coordinates */
double f_; /**< The current function value */
Array<double> g_; /**< The current gradient */
double rms_; /**< The root mean square of the gradient */
/**
* This flag keeps track of whether the function and gradient have been
* initialized. This allows the initial function and gradient to be computed
* outside of the constructor and also allows the function and gradient to
* be passed rather than computed. The downside is that it complicates the
* logic because this flag must be checked at all places where the gradient,
* function value, or rms can be first accessed.
*/
bool func_initialized_;
public :
GradientOptimizer(std::shared_ptr<pele::BasePotential> potential,
const pele::Array<double> x0, double tol=1e-4)
: potential_(potential),
tol_(tol),
maxstep_(0.1),
maxiter_(1000),
iprint_(-1),
verbosity_(0),
iter_number_(0),
nfev_(0),
x_(x0.copy()),
f_(0.),
g_(x0.size()),
rms_(1e10),
func_initialized_(false)
{}
virtual ~GradientOptimizer() {}
/**
* Do one iteration iteration of the optimization algorithm
*/
virtual void one_iteration() = 0;
/**
* Run the optimization algorithm until the stop criterion is satisfied or
* until the maximum number of iterations is reached
*/
void run(int const niter)
{
if (! func_initialized_){
// note: this needs to be both here and in one_iteration
<API key>();
}
// iterate until the stop criterion is satisfied or maximum number of
// iterations is reached
for (int i = 0; i < niter; ++i) {
if (<API key>()) {
break;
}
one_iteration();
}
}
/**
* Run the optimzation algorithm for niter iterations or until the
* stop criterion is satisfied
*/
void run()
{
run(maxiter_ - iter_number_);
}
/**
* Set the initial func and gradient. This can be used
* to avoid one potential call
*/
virtual void set_func_gradient(double f, Array<double> grad)
{
if (grad.size() != g_.size()){
throw std::invalid_argument("the gradient has the wrong size");
}
if (iter_number_ > 0){
std::cout << "warning: setting f and grad after the first iteration. this is dangerous.\n";
}
// copy the function and gradient
f_ = f;
g_.assign(grad);
rms_ = norm(g_) / sqrt(g_.size());
func_initialized_ = true;
}
inline virtual void reset(pele::Array<double> &x0)
{
throw std::runtime_error("GradientOptimizer::reset must be overloaded");
}
// functions for setting the parameters
inline void set_tol(double tol) { tol_ = tol; }
inline void set_maxstep(double maxstep) { maxstep_ = maxstep; }
inline void set_max_iter(int max_iter) { maxiter_ = max_iter; }
inline void set_iprint(int iprint) { iprint_ = iprint; }
inline void set_verbosity(int verbosity) { verbosity_ = verbosity; }
// functions for accessing the status of the optimizer
inline Array<double> get_x() const { return x_.copy(); } //debug
inline Array<double> get_g() const { return g_.copy(); }
inline double get_f() const { return f_; }
inline double get_rms() const { return rms_; }
inline int get_nfev() const { return nfev_; }
inline int get_niter() const { return iter_number_; }
inline int get_maxiter() const { return maxiter_; }
inline double get_maxstep() { return maxstep_; }
inline double get_tol() const {return tol_;}
inline bool success() { return <API key>(); }
/**
* Return true if the termination condition is satisfied, false otherwise
*/
virtual bool <API key>()
{
if (! func_initialized_) <API key>();
return rms_ <= tol_;
}
protected :
/**
* Compute the func and gradient of the objective function
*/
void <API key>(Array<double> x, double & func,
Array<double> gradient)
{
nfev_ += 1;
// pass the arrays to the potential
func = potential_->get_energy_gradient(x, gradient);
}
/**
* compute the initial func and gradient
*/
virtual void <API key>()
{
// compute the func and gradient at the current locations
// and store them
<API key>(x_, f_, g_);
rms_ = norm(g_) / sqrt(x_.size());
func_initialized_ = true;
}
};
}
#endif |
/**
* Required to undo YUI resets that override input size, margin, etc.
*/
input[type=text],input[type=password],textarea{width:auto;}
input[type=checkbox],input[type=radio]{margin-right: 7px;}
/* Fix for YUI overriding styles */
strong{font-style:inherit;}em{font-weight:inherit;}
/**
* General
*/
th,
td,
a img {border-width:0;}
acronym,
abbr {cursor: help;}
.dir-ltr,
.mdl-left,
.dir-rtl .mdl-right {text-align: left;}
.dir-rtl,
.mdl-right,
.dir-rtl .mdl-left {text-align: right;}
#add,
#remove,
.centerpara,
.mdl-align {text-align: center;}
a.dimmed,
a.dimmed:link,
a.dimmed:visited,
a.dimmed_text,
a.dimmed_text:link,
a.dimmed_text:visited,
.dimmed_text,
.dimmed_text a,
.dimmed_text a:link,
.dimmed_text a:visited,
.usersuspended,
.usersuspended a,
.usersuspended a:link,
.usersuspended a:visited,
.dimmed_category,
.dimmed_category a,
.dimmed_category a:link,
.dimmed_category a:visited {
color: #AAA;
}
.activity.label .dimmed_text {
opacity: 0.5;
-ms-filter:"progid:DXImageTransform.Microsoft.Alpha(Opacity=50)";
filter: alpha(opacity=50);
}
.unlist,
.unlist li,
.inline-list,
.inline-list li,
.block .list,
.block .list li,
.sitetopic .section li.activity,
.course-content .section li.activity,
.sitetopic .section li.movehere,
.course-content .section li.movehere {
list-style: none;
margin: 0;
padding: 0;
}
.course-content .current {background:#E3E3E3;}
.inline,
.inline-list li {display: inline;}
.notifytiny {font-size:0.7em;}
.notifytiny li,
.notifytiny td {font-size:100%;}
.red,
.notifyproblem {color:#660000;}
.green,
.notifysuccess {color:#006600;}
.reportlink {text-align:right;}
a.autolink.glossary:hover {cursor: help;}
/* Block which is hidden if javascript enabled, prevents flickering, visible when JS from footer used! */
.<API key> {white-space: nowrap;}
.<API key> img {vertical-align: middle;}
.jsenabled .hiddenifjs {display: none;}
.visibleifjs {display: none;}
.jsenabled .visibleifjs {display: inline;}
.jsenabled .collapsibleregion {overflow:hidden;}
.jsenabled .collapsed .<API key> {visibility: hidden;}
.yui-overlay .yui-widget-bd {background-color:#FFEE69;border:1px solid #A6982B;border-top-color: #D4C237;color:#000000;left:0;padding:2px 5px;position:relative;top:0;z-index:1;}
.clearer {background:transparent;border-width:0;clear:both;display:block;height:1px;margin:0;padding:0;}
.clearfix:after {clear: both;content: ".";display: block;height: 0;min-width: 0;visibility: hidden;}
.bold,
.warning,
.errorbox .title,
.pagingbar .title,
.pagingbar .thispage,
#site-news-forum h2,
#<API key> h2,
#<API key> h2,
#<API key> h2 {font-weight: bold;}
img.resize {height: 1em;width: 1em;}
.block img.resize,
.breadcrumb img.resize {height: 0.9em;width: 0.8em;}
/* Icon styles */
img.icon {height:16px;vertical-align:text-bottom;width:16px;padding-right: 6px;}
.dir-rtl img.icon {padding-left: 6px; padding-right: 0; }
img.iconsmall {height:12px;margin-right:3px; margin-left: 3px;vertical-align:middle;width:12px;}
img.iconhelp, .helplink img {height:16px; padding-left:3px;vertical-align:text-bottom;width:16px;}
.dir-rtl img.iconhelp, .dir-rtl .helplink img {padding-right: 3px; padding-left: 0; }
img.iconlarge {height: 24px; width: 24px; vertical-align:middle;}
img.iconsort { vertical-align: text-bottom; padding-left: .3em; margin-bottom: .15em;}
.dir-rtl img.iconsort { padding-right: .3em; padding-left: 0;}
img.icontoggle {height:17px;vertical-align:middle;width:50px;}
img.iconkbhelp {height:17px;width:49px;}
img.icon-pre, .dir-rtl img.icon-post { padding-right: 3px; padding-left: 0; }
img.icon-post, .dir-rtl img.icon-pre { padding-left: 3px; padding-right: 0; }
.generalbox {border:1px solid;}
.boxaligncenter {margin-left:auto;margin-right:auto;}
.boxalignright {margin-left:auto;margin-right:0;}
.boxalignleft {margin-left:0;margin-right:auto;}
.boxwidthnarrow {width: 30%;}
.boxwidthnormal {width: 50%;}
.boxwidthwide {width: 80%;}
.buttons .singlebutton,
.buttons .singlebutton form,
.buttons .singlebutton div {display: inline;}
.buttons .singlebutton input {margin:20px 5px;}
.headermain {font-weight:bold;}
#maincontent {display: block;height: 1px;overflow: hidden;}
img.uihint {cursor: help;}
#addmembersform table {margin-left: auto;margin-right: auto;}
.formtable tbody th,
.generaltable th.header {vertical-align: top;}
.cell {vertical-align: top;}
img.emoticon {vertical-align: middle;width: 15px;height: 15px;}
form.popupform,
form.popupform div {display: inline;}
.arrow_button input {overflow:hidden;}
.action-icon img.smallicon { vertical-align: text-bottom; margin-left: .45em;}
.dir-rtl .action-icon img.smallicon { margin-right: .45em; margin-left: 0;}
h1 img.icon,
h1 img.iconhelp,
h2 img.icon,
h2 img.iconhelp,
h3 img.icon,
h3 img.iconhelp,
h4 img.icon,
h4 img.iconhelp,
h5 img.icon,
h5 img.iconhelp,
h6 img.icon,
h6 img.iconhelp {
vertical-align: middle;
padding: 4px;
}
/** The 1-pixel padding is there to avoid phantom scroll bars on OS X (FF, Safari and Chrome)**/
.no-overflow {overflow:auto;padding-bottom:1px;}
.pagelayout-report .no-overflow {overflow:visible;}
.no-overflow > .generaltable {margin-bottom:0;}
.ie6 .no-overflow {width:100%;}
/** IE6 float + background bug solution **/
.ie6 li.section {line-height:1.2em;width:100%;}
/**
* Accessibility features
*/
/*Accessibility: text 'seen' by screen readers but not visual users. */
.accesshide {position:absolute;left:-10000px;font-weight:normal;font-size:1em;}
.dir-rtl .accesshide {top:-30000px;left:auto;}
span.hide,
div.hide {display:none;}
.invisiblefieldset {display:inline;border-width:0;padding:0;margin:0;}
/*Accessibility: Skip block link, for keyboard-only users. */
a.skip-block,
a.skip {position: absolute;top: -1000em;font-size: 0.85em;text-decoration:none;}
a.skip-block:focus,
a.skip-block:active,
a.skip:focus,
a.skip:active {position: static;display: block;}
.skip-block-to {display: block;height: 1px;overflow: hidden;}
/* Accessibility: only certain fonts support Unicode chars like ► in IE6 */
.arrow,
.arrow_button input {font-family: Arial,Helvetica,Courier,sans-serif;}
/**
* Header
*/
.headermain {float:left;margin:15px;font-size:2.3em;}
.headermenu {float:right;margin:10px;font-size:0.8em;text-align:right;}
#course-header {clear:both;}
/**
* Navbar
*/
.navbar {clear:both;overflow:hidden;}
.ie6 .navbar {overflow:hidden;height:100%;}
.breadcrumb {float:left;}
.navbutton {text-align:right;}
.breadcrumb ul {padding:0;margin:0;text-indent:0;list-style:none;}
.navbutton {float: right;}
.navbutton .singlebutton {margin-left: 4px}
.breadcrumb li,
.navbutton div,
.navbutton form {display:inline;}
/**
* Footer
*/
#page-footer {text-align:center;font-size:0.9em;}
#page-footer .homelink {margin: 1em 0;}
#page-footer .homelink a {padding-left:1em;padding-right:1em;}
#page-footer .logininfo,
#page-footer .sitelink,
#page-footer .helplink {margin:0px 10px;}
#page-footer .performanceinfo {text-align:center;margin:10px 20%;}
#page-footer .performanceinfo span {display:block;}
#page-footer .validators {margin-top:40px;padding-top:5px;border-top: 1px dotted gray;}
#page-footer .validators ul {margin:0px;padding:0px;list-style-type:none;}
#page-footer .validators ul li {display:inline;margin-right:10px;margin-left:10px;}
#page-footer .performanceinfo .cachesused {margin-top:1em;}
#page-footer .performanceinfo .cachesused .cache-stats-heading {font-weight:bold;display:block;}
#page-footer .performanceinfo .cachesused .<API key> {margin:0.3em;padding:0px;border:1px solid #999;display:inline-block;vertical-align:top;min-height:4em;color:#000;background-color:#eee;}
#page-footer .performanceinfo .cachesused .<API key> span {padding-left:0.5em;padding-right:0.5em;display:block;}
#page-footer .performanceinfo .cachesused .<API key> .<API key> {background-color:#eee;}
#page-footer .performanceinfo .cachesused .cache-store-stats {text-indent: 1em;}
#page-footer .performanceinfo .cachesused .cache-store-stats.nohits {background-color:#ffd3d9;}
#page-footer .performanceinfo .cachesused .cache-store-stats.lowhits {background-color:#f3f2aa;}
#page-footer .performanceinfo .cachesused .cache-store-stats.hihits {background-color:#e7f1c3;}
#page-footer .performanceinfo .cachesused .cache-total-stats {display:block;font-weight:bold;margin-top:0.3em;}
#course-footer {clear:both;}
/**
* Tabs
*/
.tabtree {position:relative;margin-bottom:3.5em;}
.tabtree li {display:inline;}
.tabtree ul {margin:5px;}
.tabtree ul li.here ul {position:absolute;top:100%;width:100%;}
.tabtree ul li.here .empty {display:none;}
/**
* Mforms
*/
.mform fieldset {border:1px solid;}
.mform fieldset fieldset {border-width:0;}
.mform fieldset legend {font-weight:bold;margin-left:0.5em;padding: 0 0.35em;}
.mform fieldset div {margin:10px;margin-top:0;}
.mform fieldset div div {margin:0;}
.mform fieldset .advancedbutton {text-align:right;}
.mform fieldset.hidden {border-width:0;}
.mform fieldset.group {margin-bottom: 0}
.mform fieldset.error {border: 1px solid #A00;}
.collapsible-actions {display: none;}
.jsenabled .collapsible-actions {text-align: right; display: block;}
.dir-rtl .collapsible-actions {text-align: left;}
.collapseexpand {background: url([[pix:t/collapsed]]) left center no-repeat; padding-left: 18px;}
.dir-rtl .collapseexpand {background-image: url([[pix:t/collapsed_rtl]]); background-position: right center; padding-left: 0; padding-right: 18px;}
.collapse-all,
.dir-rtl .collapse-all {background-image: url([[pix:t/expanded]]);}
.mform fieldset legend {padding: 0 0.35em;}
.mform fieldset.collapsible legend a.fheader {padding-left: 18px; background: url([[pix:t/expanded]]) left center no-repeat;}
.mform fieldset.collapsed legend a.fheader {background-image: url([[pix:t/collapsed]]);}
.jsenabled .mform fieldset.collapsed {border-width: 1px 0 0 1px; padding: 0; border-color: transparent;}
.jsenabled .mform fieldset.collapsed div.fcontainer {display: none;}
.mform .fitem {width:100%;overflow:hidden;margin-top:5px;margin-bottom:1px;clear:right;}
.jsenabled .mform .<API key> .advanced {display: none;}
.mform .<API key> .advanced.show {display: block;}
.mform .fitem .fitemtitle {width:15%;text-align:right;float:left;}
.dir-rtl .mform .fitem .fitemtitle {text-align:left;}
.mform .fitem .fitemtitle div {display: inline;}
.mform .fitem .felement {border-width: 0;width:80%;margin-left:16%;}
.mform .fitem fieldset.felement {margin-left:15%;padding-left:1%;margin-bottom:0}
#adminsettings span.error,
.mform .error,
.mform .required {color:#A00;}
#adminsettings span.error,
.mform span.error {display: inline-block;padding: 4px;margin-bottom: 4px;background-color: #F2DEDE;border: 1px solid #EED3D7;}
.mform .required .fgroup span label {color:#000;}
.mform .fdescription.required {color:#A00;text-align:right;}
.dir-rtl .mform .fdescription.required {text-align:left;}
.mform .fpassword .unmask {display:inline;margin-left:0.5em;}
.mform .ftextarea #id_alltext {width: 100%;}
.mform ul.file-list {padding:0;margin:0;list-style:none;}
.mform label { display: inline-block; }
.mform .iconhelp { margin-left: 4px; }
.dir-rtl .mform .iconhelp { margin-right: 4px; }
.mform label .req,
.mform label .adv {cursor: help;}
.mform .fcheckbox input {margin-left: 0;}
.mform .fcheckbox label,
.mform .fduration label,
.mform .fitem fieldset.fgroup label,
.mform .fradio label,
.mform fieldset.fdate_selector label,
.mform fieldset.fdate_time_selector label { display: inline; float: none; margin-left: .3em; vertical-align: text-bottom;}
.dir-rtl .mform .fcheckbox label,
.dir-rtl .mform .fduration label,
.dir-rtl .mform .fitem fieldset.fgroup label,
.dir-rtl .mform .fradio label,
.dir-rtl .mform fieldset.fdate_selector label,
.dir-rtl .mform fieldset.fdate_time_selector label {margin-right: .3em; margin-left: 0;}
.mform .ftags label.accesshide {display: block;position: static;}
.mform .ftags select {margin-bottom: 0.7em;min-width: 22em;}
.mform .moreless-toggler {background: url([[pix:t/more]]) left center no-repeat; padding-left: 16px;}
.dir-rtl .moreless-toggler {padding-left: 0; padding-right: 16px; background-position: right center; }
.mform .moreless-less {background-image: url([[pix:t/less]]);}
.mform .helplink img { margin: 0 0 0 .45em; padding: 0;}
.dir-rtl .mform .helplink img { margin: 0 .45em 0 0; padding: 0;}
.mform legend .helplink img { margin-right: .2em; }
.dir-rtl .mform legend .helplink img { margin: 0 .45em 0 .2em; }
.urlselect label,
.singleselect label { margin-right: .3em; }
.dir-rtl .urlselect label,
.dir-rtl .singleselect label { margin-left: .3em; margin-right: 0; }
.dir-rtl .mform fieldset legend {margin-right:0.5em; margin-left: 0;}
.dir-rtl .mform fieldset.collapsible legend a.fheader {background-position: right center; padding-right: 18px; padding-left: 0;}
.dir-rtl .mform fieldset.collapsed legend a.fheader {background-image: url([[pix:t/collapsed_rtl]]); }
.dir-rtl.jsenabled .mform fieldset.collapsed {border-width: 1px 1px 0 0; }
.dir-rtl .mform .fitem fieldset.felement {padding-right: 1%;margin-right: 15%;}
.mform .btn-cancel, .mform .btn-cancel:active, .mform .btn-cancel[disabled] { background-color: transparent; background-image: none; box-shadow: none; -moz-box-shadow: none; -webkit-box-shadow: none; -o-box-shadow: none; -ms-box-shadow: none; margin-left: .5em;}
.mform .btn-cancel { border-color: transparent; border-radius: 0 0 0 0; -moz-border-radius: 0 0 0 0; -<API key>: 0 0 0 0; -o-border-radius: 0 0 0 0; -ms-border-radius: 0 0 0 0; color: #0088CC; cursor: pointer; }
.mform .btn-cancel:hover, .mform .btn-cancel:focus { background-color: transparent; color: #005580; text-decoration: underline; }
.mform .btn-cancel[disabled]:hover, .mform .btn-cancel[disabled]:focus { color: #333333; text-decoration: none; }
input#id_externalurl {direction:ltr;}
#<API key> {display:inline;}
/**
* Show the labels above text editors and file managers except on wide screens.
*/
#region-main .mform:not(.unresponsive) .fitem .fitemtitle label {
font-weight: bold;
}
@media (max-width: 1199px) {
#region-main .mform:not(.unresponsive) .fitem .fitemtitle {
display: block;
margin-top: 4px;
margin-bottom: 4px;
text-align: left;
width: 100%;
}
#region-main .mform:not(.unresponsive) .femptylabel .fitemtitle {
display: inline-block;
width: auto;
margin-right: 8px;
}
.dir-rtl #region-main .mform:not(.unresponsive) .femptylabel .fitemtitle {
margin-right: 0px;
margin-left: 8px;
}
.dir-rtl #region-main .mform:not(.unresponsive) .fitem .fitemtitle {
text-align: right;
}
#region-main .mform:not(.unresponsive) .fitem .felement {
margin-left: 0;
width: 100%;
float: left;
margin-bottom: 6px;
padding-left: 0;
padding-right: 0;
}
#region-main .mform:not(.unresponsive) .fitem .fstatic:empty {
display: none;
}
#region-main .mform:not(.unresponsive) .femptylabel .felement {
display: inline-block;
margin-top: 4px;
width: auto;
}
.dir-rtl #region-main .mform:not(.unresponsive) .fitem .felement {
margin-right: 0;
float: right;
padding-right: 0;
padding-left: 0;
}
#region-main .mform:not(.unresponsive) .fitem_fcheckbox .fitemtitle,
#region-main .mform:not(.unresponsive) .fitem_fcheckbox .felement {
display: inline-block;
width: auto;
}
.dir-rtl #region-main .mform:not(.unresponsive) .fitem_fcheckbox .felement {
float: right;
}
#region-main .mform:not(.unresponsive) .fitem_fcheckbox .felement {
padding: 6px;
}
}
/**
* phpinfo styles
*/
.phpinfo .center {text-align: center;}
.phpinfo .center table {margin-left: auto;margin-right: auto;text-align: left;border-collapse: collapse;}
.phpinfo .center th {text-align: center;}
.phpinfo .e,
.phpinfo .v,
.phpinfo .h {border: 1px solid #000000;font-size: 0.8em;vertical-align: baseline;color: #000000;background-color: #cccccc;}
.phpinfo .e {background-color: #ccccff;font-weight: bold;}
.phpinfo .h {background-color: #9999cc;font-weight: bold;}
/**
* Blogs
*/
.addbloglink {text-align: center;}
.blog_entry .audience {text-align: right;padding-right: 4px;}
.blog_entry .tags {margin-top: 15px;}
.blog_entry .tags .action-icon img.smallicon { height: 16px; width: 16px; }
.blog_entry .content {margin-left: 43px;}
/**
* Group
*/
#page-group-index #groupeditform {text-align: center;}
#doc-contents h1 {margin: 1em 0 0 0;}
#doc-contents ul {margin: 0;padding: 0;width: 90%;}
#doc-contents ul li {list-style-type: none;}
.<API key> td {vertical-align: top;}
.<API key> #existingcell,
.<API key> #potentialcell {width: 42%;}
.<API key> #buttonscell {width: 16%;}
.<API key> #buttonscell input {width: 80%;}
.<API key> #buttonscell p.arrow_button input {width: auto;min-width: 80%;margin: 0 auto;}
.<API key> #<API key>,
.<API key> #addselect_wrapper {width: 100%;}
.<API key> #<API key> label,
.<API key> #addselect_wrapper label {font-weight: normal;}
.dir-rtl .<API key> p {text-align: right;}
#group-usersummary {width: 14em;}
.groupselector {margin-top: 3px;margin-bottom: 3px;display: inline-block;}
/**
* Login
*/
.loginbox {margin:15px;overflow:visible;}
.loginbox.twocolumns {margin:15px;}
.loginbox h2,
.loginbox .subcontent {margin:5px;padding:10px;text-align:center;}
.loginbox .loginpanel .desc {margin:0;padding:0;margin-bottom:5px;margin-top:15px;}
.loginbox .signuppanel .subcontent {text-align:left;}
.dir-rtl .loginbox .signuppanel .subcontent {text-align: right;}
.loginbox .loginsub {margin-left:0;margin-right:0;}
.loginbox .guestsub,
.loginbox .forgotsub,
.loginbox .potentialidps {margin:5px 12%;}
.loginbox .potentialidps .potentialidplist {margin-left:40%;}
.loginbox .potentialidps .potentialidplist div {text-align:left;}
.loginbox .loginform {margin-top:1em;text-align:left;}
.loginbox .loginform .form-label {float:left;text-align:right;width:49%;white-space:nowrap;}
.loginbox .loginform .form-input {float:right;width:50%;}
.dir-rtl .loginbox .loginform .form-input {margin-right: 1%;}
.loginbox .loginform .form-input input {width: 6em;}
.loginbox .signupform {margin-top:1em;text-align:center;}
.loginbox.twocolumns .loginpanel {float:left;width:49.5%;border-right: 1px solid;margin-bottom:-2000px;padding-bottom:2000px;}
.loginbox.twocolumns .signuppanel {float:right;width:50%;margin-bottom:-2000px;padding-bottom:2000px;}
.loginbox .potentialidp .smallicon { vertical-align: text-bottom; margin: 0 .3em; }
.dir-rtl .loginbox.twocolumns .loginpanel, .dir-rtl.loginbox.twocolumns .signuppanel {float:right;}
/**
* Notes
*/
.notepost {margin-bottom: 1em;}
.notepost .userpicture {float: left;margin-right: 5px;}
.notepost .content,
.notepost .footer {clear: both;}
.notesgroup {margin-left:20px;}
/**
* My Moodle
*/
.path-my .coursebox .overview {margin: 15px 30px 10px 30px;}
.path-my .coursebox .info {float: none; margin: 0;}
/**
* Logs
*/
.logtable th {text-align:left;}
/**
* Modules
*/
.mod_introbox {border:1px solid;padding:10px;}
table.mod_index {width:100%;}
/**
* Comments
*/
.comment-ctrl {font-size: 12px;display: none;margin:0;padding:0;}
.comment-ctrl h5 {margin:0;padding: 5px;}
.comment-area {max-width: 400px;padding: 5px;}
.comment-area textarea {width:100%;overflow:auto;}
.comment-area textarea.fullwidth {-webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box;}
.comment-area .fd {text-align:right;}
.comment-meta span {color:gray;}
.comment-link img { vertical-align: text-bottom; }
.comment-list {font-size: 11px;overflow:auto;list-style:none;padding:0;margin:0;}
.comment-list li {margin: 2px;list-style:none;margin-bottom:5px;clear:both;padding: .3em;position: relative;}
.comment-list li.first {display:none}
.comment-paging{text-align:center;}
.comment-paging .pageno{padding:2px;}
.comment-paging .curpage{border:1px solid #CCC;}
.comment-message .picture {width: 20px;float:left;}
.dir-rtl .comment-message .picture {float:right;}
.comment-message .text {margin:0;padding:0;}
.comment-message .text p {padding:0;margin:0 18px 0 0;}
.comment-delete {position: absolute; top: 0; right: 0;margin: .3em;}
.dir-rtl .comment-delete {position: absolute; left: 0; right: auto;margin: .3em;}
.<API key> {background: #eee; padding: 2px; width: 5em;text-align:center;}
.comment-container {float:left;margin: 4px;}
.<API key>{display:none}
.comment-link {display:none}
.jsenabled .comment-link {display:block}
.jsenabled .showcommentsnonjs{display:none}
.jsenabled .<API key>{display:inline}
/**
* Completion progress report
*/
.completion-expired {background:#FFDDDD;}
.completion-expected {font-size:0.75em;}
.<API key>,
.<API key> {font-size:0.75em;vertical-align:bottom;}
.<API key> {text-align:right;}
.completion-expired .completion-expected {font-weight:bold;}
/**
* Tags
*/
#<API key> .<API key> {position: relative;width: 600px;margin: 20px auto;}
#<API key> .coursetag_edit_row {clear:both;}
#<API key> .coursetag_edit_row .coursetag_edit_left {float:left;width:50%;text-align:right;}
#<API key> .coursetag_edit_row .<API key> {margin-left:50%;}
#<API key> .<API key> {display: none;}
#<API key> .<API key> {font-size: 120%;}
#<API key> .<API key> {font-size: 80%;}
#<API key> .coursetag_more_link {font-size: 80%;}
#tag-description,
#tag-blogs {width:100%;}
#tag-management-box {margin-bottom:10px;line-height:20px;}
#tag-user-table {padding:3px;clear: both;width:100%;}
#tag-user-table:after {content:".";display:block;clear:both;visibility:hidden;height:0;overflow:hidden;}
img.user-image {height:100px;width:100px;}
#small-tag-cloud-box {width:300px;margin:0 auto;}
#big-tag-cloud-box {width:600px;margin:0 auto;float:none;}
ul#tag-cloud-list {list-style:none;padding:5px;margin:0;}
ul#tag-cloud-list li {margin:0;display:inline;list-style-type:none;}
#tag-search-box {text-align:center;margin:10px auto;}
#<API key> {padding:0;width:100%;}
#tag-search-results {padding:0;margin: 15px 20% 0 20%;float:left;width:60%;display:block;}
#tag-search-results li {width:30%;float:left;padding-left:1%;text-align:left;line-height:20px;padding-right:1%;list-style:none;}
span.flagged-tag,
span.flagged-tag a {color:#FF0000;}
table#tag-management-list {text-align:left;width:100%;}
table#tag-management-list td,
table#tag-management-list th {vertical-align: middle;text-align: left;padding: 4px;}
.tag-management-form {text-align:center;}
#<API key> {margin-left:auto;margin-right:auto;min-height:4.6em;width:100%;}
#<API key> {position:relative;display:block;width:60%;margin-left:auto;margin-right:auto;}
#<API key> .yui-ac-content {position:absolute;width:420px;left:20%;border:1px solid #404040;background:#fff;overflow:hidden;z-index:9050;}
#<API key> .ysearchquery {position:absolute;right:10px;color:#808080;z-index:10;}
#<API key> .yui-ac-shadow {position:absolute;margin:.3em;width:100%;background:#a0a0a0;z-index:9049;}
#<API key> ul {padding:0;width:100%;margin:0;list-style-type:none;}
#<API key> li {padding:0 5px;cursor:default;white-space:nowrap;}
#<API key> li.yui-ac-highlight{background:#FFFFCC;}
h2.tag-heading,
div#tag-description,
div#tag-blogs,
body.tag .managelink {padding: 5px;}
.tag_cloud .s20 {font-size: 1.5em;font-weight: bold;}
.tag_cloud .s19 {font-size: 1.5em;}
.tag_cloud .s18 {font-size: 1.4em;font-weight: bold;}
.tag_cloud .s17 {font-size: 1.4em;}
.tag_cloud .s16 {font-size: 1.3em;font-weight: bold;}
.tag_cloud .s15 {font-size: 1.3em;}
.tag_cloud .s14 {font-size: 1.2em;font-weight: bold;}
.tag_cloud .s13 {font-size: 1.2em;}
.tag_cloud .s12,
.tag_cloud .s11 {font-size: 1.1em;font-weight: bold;}
.tag_cloud .s10,
.tag_cloud .s9 {font-size: 1.1em;}
.tag_cloud .s8,
.tag_cloud .s7 {font-size: 1em;font-weight: bold;}
.tag_cloud .s6,
.tag_cloud .s5 {font-size: 1em;}
.tag_cloud .s4,
.tag_cloud .s3 {font-size: 0.9em;font-weight: bold;}
.tag_cloud .s2,
.tag_cloud .s1 {font-size: 0.9em;}
.tag_cloud .s0 {font-size: 0.8em;}
/*
* Backup and Restore CSS
*/
.path-backup .mform .grouped_settings.section_level {clear:both;}
.path-backup .mform .grouped_settings {clear:both;overflow:hidden;}
.path-backup .mform .grouped_settings .fitem .fitemtitle {width:40%;padding-right:10px;}
.path-backup.dir-rtl .mform .grouped_settings .fitem .fitemtitle {width: 60%;}
.path-backup .mform .grouped_settings .fitem .felement {width:50%;}
.path-backup .mform .grouped_settings .fitem.backup_selector .felement {width:100%;}
.path-backup.dir-rtl .mform .grouped_settings .fitem .felement {width: 99%;}
.path-backup .mform .grouped_settings.section_level .include_setting {width:50%;margin:0;float:left;clear:left;font-weight:bold;}
.path-backup.dir-rtl .mform .grouped_settings.section_level .include_setting {float: right; clear: right;}
.path-backup .mform .grouped_settings.section_level .normal_setting {width:50%;margin:0;margin-left:50%;}
.path-backup.dir-rtl .mform .grouped_settings.section_level .normal_setting {margin:0;}
.path-backup .mform .grouped_settings.activity_level .include_setting label {font-weight:normal;}
.path-backup.dir-rtl .mform .grouped_settings.activity_level .include_setting label img {float:right;}
.path-backup .mform .fitem fieldset.felement {margin-left:0;width:auto;padding-left:0;}
.path-backup .notification.<API key> {text-align:center;color:#A00;font-weight:bold;}
.path-backup .backup_progress {text-align:center;}
.path-backup .backup_progress span.backup_stage {color:#999;}
.path-backup .backup_progress .backup_stage.<API key> {font-weight:bold;color:inherit;}
.path-backup .backup_progress .backup_stage.backup_stage_next {}
.path-backup .backup_progress span.backup_stage.<API key> {color:inherit;}
#page-backup-restore .filealiasesfailures {background-color:#ffd3d9}
#page-backup-restore .filealiasesfailures .aliaseslist {width:90%;margin:0.8em auto;background-color:white;border:1px dotted #666;}
.path-backup .fitemtitle .iconlarge.icon-post { padding-left: 6px; }
.path-backup.dir-rtl .fitemtitle .iconlarge.icon-post { padding-right: 6px; padding-right: 0; }
.path-backup .fitem .smallicon { vertical-align: text-bottom; }
.path-backup .wibbler { width: 500px; margin: 0 auto 10px; border-bottom: 1px solid black; border-right: 1px solid black; border-left: 1px solid black; position: relative; min-height: 4px;}
.path-backup .wibbler .wibble { position: absolute; left: 0; right: 0; top: 0; height: 4px; }
.path-backup .wibbler .state0 { background: #eee; }
.path-backup .wibbler .state1 { background: #ddd; }
.path-backup .wibbler .state2 { background: #ccc; }
.path-backup .wibbler .state3 { background: #bbb; }
.path-backup .wibbler .state4 { background: #aaa; }
.path-backup .wibbler .state5 { background: #999; }
.path-backup .wibbler .state6 { background: #888; }
.path-backup .wibbler .state7 { background: #777; }
.path-backup .wibbler .state8 { background: #666; }
.path-backup .wibbler .state9 { background: #555; }
.path-backup .wibbler .state10 { background: #444; }
.path-backup .wibbler .state11 { background: #333; }
.path-backup .wibbler .state12 { background: #222; }
.path-backup .backup_log { margin-top: 2em; }
.path-backup .backup_log h2 { font-size: 1em; }
.path-backup .backup_log_contents { border: 1px solid #ddd; padding: 10px; height: 300px; overflow-y: scroll; }
/*
* CSS for availability options on module and section. This is taken from the
* Bootstrap version and tweaked so it works on base.
*/
#<API key> .label {
background: #999;
padding: 2px 4px;
border-radius: 4px;
font-size: 0.8em;
font-weight: bold;
color: #fff;
}
#<API key> .label-warning {
background: #f89406;
position:relative;
top: -1px;
}
#<API key> .label:empty {
display: none;
}
#<API key> *[aria-hidden=true] {
display: none;
}
x#<API key> select,
x#<API key> input[type=text] {
position:relative;
top: 4px;
}
#<API key> label {
display: inline;
}
#<API key> .availability-group {
margin-right: 8px;
}
.dir-rtl #<API key> .availability-group {
margin-right: 0;
margin-left: 8px;
}
#<API key> .availability-item,
#<API key> .availability-header {
margin-bottom: 6px;
}
#<API key> .availability-none {
margin-left: 20px;
margin-bottom: 4px;
}
.dir-rtl #<API key> .availability-none {
margin-right: 20px;
margin-left: 0;
}
#<API key> .<API key> {
padding: 4px 0px 4px 4px;
background: none repeat scroll 0% 0% #eee;
border: 1px solid #ddd;
border-radius: 4px;
display: inline-block;
margin-right: 8px;
}
.dir-rtl #<API key> .<API key> {
padding-right: 4px;
padding-left: 0px;
margin-right: 0;
margin-left: 8px;
}
#<API key> .availability-eye,
#<API key> .availability-delete {
margin-right: 8px;
}
.dir-rtl #<API key> .availability-eye,
.dir-rtl #<API key> .availability-delete {
margin-left: 8px;
margin-right: 0;
}
#<API key> .availability-eye[aria-hidden=true] {
display: inline;
visibility: hidden;
}
#<API key> .availability-list > .availability-eye img {
vertical-align: top;
margin-top: 12px;
}
#<API key> .availability-button {
margin-left: 15px;
}
.dir-rtl #<API key> .availability-button {
margin-right: 15px;
margin-left: 0;
}
#<API key> .<API key> > .availability-inner {
display: inline-block;
background: #eee;
border: 1px solid #ddd;
border-radius: 4px;
padding: 6px;
margin-bottom: 6px;
}
#<API key> .<API key> .<API key> > .availability-inner {
background: white;
}
#<API key> .<API key> {
margin-left: 20px;
margin-bottom: 6px;
}
.dir-rtl #<API key> .<API key> {
margin-right: 20px;
margin-left: 0;
}
.mform .error .availability-field {
color: black;
}
.<API key>.<API key> .moodle-dialogue .moodle-dialogue-bd {
padding-left: 0;
padding-right: 0;
padding-bottom: 2px;
}
.<API key> ul {
display: block;
margin: 0;
}
.<API key> li {
display: block;
list-style-type: none;
padding: 0 0 4px;
clear: both;
border-bottom: 1px solid #eee;
margin-bottom: 4px;
}
.<API key> ul button {
float: left;
margin-left: 1em;
min-width: 140px;
margin-top: 4px;
}
.dir-rtl .<API key> ul button {
float: right;
margin-right: 1em;
margin-left: 0;
}
.<API key> label {
margin-left: 170px;
margin-right: 1em;
margin-bottom: 0;
display: block;
line-height: 1.5;
}
.dir-rtl .<API key> label {
margin-right: 170px;
margin-left: 1em;
}
.<API key> .<API key> button {
margin-left: 1em;
margin-right: 1em;
margin-top: 4px;
}
/**
* Web Service
*/
#<API key> td {text-align: left;border: 0px solid black;}
/**
* Custom menu
*/
#custommenu {clear:both;}
#custommenu .yui3-menu .yui3-menu {z-index:500;}
#custommenu .<API key>.javascript-disabled .yui3-menu-content,
#custommenu .<API key>.javascript-disabled .yui3-menu-content .ul {border:1px solid #000;}
#custommenu .<API key>.javascript-disabled ul {margin:0;padding:0;}
#custommenu .<API key>.javascript-disabled li {margin:0;padding:0;list-style:none;width:auto;position:relative;}
#custommenu .<API key>.javascript-disabled .yui3-menu .yui3-menu-label {padding-right:20px;}
#custommenu .<API key>.javascript-disabled>.yui3-menu-content>ul>li {float:left;}
#custommenu .<API key>.javascript-disabled li a {padding:0 10px;}
#custommenu .<API key>.javascript-disabled .yui3-menu {position:absolute;top:-10000px;left:-10000px;visibility:hidden;white-space: nowrap;max-width: 250px;background-color:#FFF;}
#custommenu .<API key>.javascript-disabled li:hover>.yui3-menu {top:100%;left:0;visibility: visible;z-index:10;}
#custommenu .<API key>.javascript-disabled li:hover .yui3-menu .yui3-menu {top:0;left:100%;min-width:200px;}
#custommenu .<API key>.javascript-disabled>.yui3-menu-content>ul:after {content:"";display:block;clear:both;line-height:0;font-size:0;visibility:hidden;}
#custommenu .<API key>.javascript-disabled .yui3-menu-content {font-size:93%;line-height:2;padding:0;}
#custommenu .<API key>.javascript-disabled .yui3-menu-content .yui3-menu-content {font-size:100%;}
/**
* Fix for broken YUI images in the menunav component
*/
#custommenu .yui3-menu-label,
#custommenu .<API key> {cursor:pointer;}
#custommenu .<API key> {background-color:#B3D4FF;}
#custommenu .<API key>,
#custommenu .<API key> .<API key>,
#custommenu .<API key> .yui3-menu-label,
#custommenu .<API key> .yui3-menu-content {background-image:none;background-position:right center;background-repeat:no-repeat;}
#custommenu .yui3-menu-label,
#custommenu .yui3-menu .yui3-menu .yui3-menu-label {background-image:url([[pix:theme|<API key>]]); padding-right: 20px;}
#custommenu .yui3-menu .yui3-menu .<API key> {background-image:url([[pix:theme|<API key>]]);}
/**
* Smart Select Element
*/
.smartselect {position:absolute;}
.smartselect .smartselect_mask {background-color:#fff;}
.smartselect ul {padding: 0;margin: 0;}
.smartselect ul li {list-style: none;}
.smartselect .smartselect_menu {margin-right:5px;}
.safari .smartselect .smartselect_menu {margin-left:2px;}
.smartselect .smartselect_menu,
.smartselect .smartselect_submenu {border:1px solid #000;background-color:#FFF;display: none;}
.smartselect .smartselect_menu.visible,
.smartselect .smartselect_submenu.visible {display:block;}
.smartselect .<API key> ul li {position:relative;padding:2px 5px;}
.smartselect .<API key> ul li a {color:#333;text-decoration:none;}
.smartselect .<API key> ul li a.selectable {color:inherit;}
.smartselect .<API key> {background-image:url([[pix:moodle|t/collapsed]]);background-repeat: no-repeat;background-position:100%;}
/** Spanning mode */
.smartselect.spanningmenu .smartselect_submenu {position:absolute;top:-1px;left:100%;}
.smartselect.spanningmenu .smartselect_submenu a {white-space: nowrap;padding-right:16px;}
.smartselect.spanningmenu .<API key> ul li a.selectable:hover {text-decoration:underline;}
/** Compact mode */
.smartselect.compactmenu .smartselect_submenu {position:relative;margin:2px -3px; margin-left: 10px;display:none;border-width:0;z-index: 1010;}
.smartselect.compactmenu .smartselect_submenu.visible {display:block;}
.smartselect.compactmenu .smartselect_menu {z-index: 1000;overflow:hidden;}
.smartselect.compactmenu .smartselect_submenu .smartselect_submenu {z-index: 1020;}
.smartselect.compactmenu .<API key>:hover > .<API key> {font-weight:bold;}
/**
* Registration
*/
#<API key> .<API key> {width: 300px;}
/**
* Enrol
*/
.userenrolment {width:100%;border-collapse: collapse;}
.userenrolment tr {vertical-align:top;}
.userenrolment td {height:41px;padding:3px;}
.userenrolment td > * {margin:3px;}
.userenrolment .subfield {margin-right:5px;}
.userenrolment .col_userdetails .subfield_picture {float:left;}
.userenrolment .col_lastseen {width:150px;}
.userenrolment .col_role {width:262px;}
.userenrolment .col_role .roles,
.userenrolment .col_group .groups {margin-right:30px;}
.userenrolment .col_role .role,
.userenrolment .col_group .group {float:left;white-space:nowrap;margin-right:6px;}
.userenrolment .col_role .role a,
.userenrolment .col_group .group a {margin-left:3px;cursor:pointer;}
.userenrolment .col_role .addrole,
.userenrolment .col_group .addgroup {float:right;}
.userenrolment .col_role .addrole a img,
.userenrolment .col_group .addgroup a img {vertical-align:bottom;}
.userenrolment .hasAllRoles .col_role .addrole {display:none;}
.dir-rtl .userenrolment .col_role .role {float:right;}
.userenrolment .col_enrol .enrolment {float:left;}
.userenrolment .col_enrol .enrolment a {float:right;margin-left:3px;}
#page-enrol-users .enrol_user_buttons {float:right;}
#page-enrol-users .enrol_user_buttons .singlebutton {margin-top: 2px; line-height: 2;}
#page-enrol-users .enrol_user_buttons .enrolusersbutton {margin-left:1em;display:inline;}
#page-enrol-users .enrol_user_buttons .enrolusersbutton div,
#page-enrol-users .enrol_user_buttons .enrolusersbutton form {display:inline;}
#page-enrol-users .enrol_user_buttons .enrolusersbutton input {padding-left:6px;padding-right:6px;}
#page-enrol-users.dir-rtl .col_userdetails .subfield_picture {float: right;}
#page-enrol-users #filterform div,
#page-enrol-users #filterform fieldset {display:inline;float:none;clear:none;width:auto;margin:0;line-height:2;}
#page-enrol-users #filterform .fitem {white-space:nowrap;}
#page-enrol-users #filterform fieldset > div {display:block;float:left;background:#f2f2f2;padding:2px;}
#page-enrol-users #filterform select,
#page-enrol-users #filterform .ftext input {width:8em;}
#page-enrol-users #filterform #fitem_id_role,
#page-enrol-users #filterform #fitem_id_ifilter,
#page-enrol-users #filterform #fgroup_id_buttons {margin-left:0.5em;}
#page-enrol-users .paging { clear: right; }
/**
* Overide for RTL layout
**/
.dir-rtl .headermain {float:right;}
.dir-rtl .headermenu {float:left;}
.dir-rtl .breadcrumb {float:right;}
.dir-rtl .navbutton {float: left;}
.dir-rtl .navbutton .singlebutton {margin-right: 4px}
.dir-rtl .breadcrumb ul li { float: right; margin-left: 5px;}
.dir-rtl .mform .fitem .fitemtitle {float:right;}
.dir-rtl .loginbox .loginform .form-label {float:right;text-align:left;}
.dir-rtl .loginbox .loginform .form-input {text-align: right;}
.dir-rtl .yui3-menu-hidden {left: 0px;}
#<API key>.dir-rtl #rolesform .felement {margin-right: 180px;}
#page-message-edit.dir-rtl table.generaltable th.c0 {text-align: right;}
/**
* Backup
*/
.backup-restore .backup-section {clear:both;border:1px solid #ddd;background-color:#f6f6f6;margin-bottom:1em;}
.backup-restore .backup-section > h2.header {padding:5px 6px;margin:0;border-bottom:1px solid #ddd;}
.backup-restore .backup-section .noticebox {margin:1em auto;width:60%;text-align:center;}
.backup-restore .backup-section .backup-sub-section {margin:0 25px;background-color:#f9f9f9;border:1px solid #f3f3f3;margin-bottom:1em;}
.backup-restore .backup-section .backup-sub-section h3 {text-align:right;border-bottom:1px solid #DDD;padding:5px 86% 5px 6px;margin:0;background-color:#e9e9e9;}
.backup-restore .backup-section.settings-section .detail-pair {margin:0;padding:0;width:50%;display:inline-block;}
.backup-restore .backup-section.settings-section .detail-pair .detail-pair-label {width:65%;}
.backup-restore .backup-section.settings-section .detail-pair .detail-pair-value {width:25%;}
.backup-restore .activitytable {width:60%;min-width:500px;}
.backup-restore .activitytable .modulename {width:100px;}
.backup-restore .activitytable .moduleincluded {width:50px;}
.backup-restore .activitytable .userinfoincluded {width:50px;}
.backup-restore .detail-pair {}
.backup-restore .detail-pair-label {display:inline-block;width:25%;padding:8px;margin:0;text-align:right;font-weight:bold;color:#444;vertical-align:top;}
.backup-restore .detail-pair-value {display:inline-block;width:65%;padding:8px;margin:0;}
.backup-restore .detail-pair-value > .sub-detail {display:block;color:#1580B6;margin-left:2em;font-size:90%;font-style: italic;}
.backup-restore > .singlebutton {text-align:right;}
.path-backup .mform .fgroup .proceedbutton {float:right;margin-right:1%;}
.<API key> .rcs-results {width:70%;min-width:400px;border:1px solid #ddd;margin:5px 0;}
.<API key> .rcs-results table {width:100%;margin:0;border-width:0;}
.<API key> .rcs-results table .no-overflow {max-width:600px;}
.<API key> .rcs-results .paging {text-align:left;margin:0;background-color:#eee;padding:3px;}
.<API key> .rcs-results {width:70%;min-width:400px;border:1px solid #ddd;margin:5px 0;}
.<API key> .rcs-results table {width:100%;margin:0;border-width:0;}
.<API key> .rcs-results table .no-overflow {max-width:600px;}
.<API key> .rcs-results .paging {text-align:left;margin:0;background-color:#eee;padding:3px;}
.corelightbox {background-color:#CCC;position:absolute;top:0;left:0;width:100%;height:100%;text-align:center;}
.corelightbox img {position:fixed;top:50%; left: 50%;}
.mod-indent {display:table-cell;}
.label .mod-indent {float:left; padding-top:20px}
.mod-indent-1 {width:30px;}
.mod-indent-2 {width:60px;}
.mod-indent-3 {width:90px;}
.mod-indent-4 {width:120px;}
.mod-indent-5 {width:150px;}
.mod-indent-6 {width:180px;}
.mod-indent-7 {width:210px;}
.mod-indent-8 {width:240px;}
.mod-indent-9 {width:270px;}
.mod-indent-10 {width:300px;}
.mod-indent-11 {width:330px;}
.mod-indent-12 {width:360px;}
.mod-indent-13 {width:390px;}
.mod-indent-14 {width:420px;}
.mod-indent-15 {width:450px;}
.mod-indent-16,
.mod-indent-huge {width:480px;}
.dir-rtl .mform .fitem .felement {margin-right: 16%;margin-left:auto;text-align: right;}
.dir-rtl .mform .fitem .felement input[name=email],
.dir-rtl .mform .fitem .felement input[name=email2],
.dir-rtl .mform .fitem .felement input[name=url],
.dir-rtl .mform .fitem .felement input[name=idnumber],
.dir-rtl .mform .fitem .felement input[name=phone1],
.dir-rtl .mform .fitem .felement input[name=phone2] {text-align: left; direction: ltr;}
/* Audio player size in 'block' mode (can only change width, height is hardcoded in JS) */
.resourcecontent .mediaplugin_mp3 object {height:25px; width: 600px}
.resourcecontent audio.<API key> {width: 600px}
/** Large resource images should avoid hidden overflow **/
.resourceimage {max-width: 100%;}
/* Audio player size in 'inline' mode (can only change width, as above) */
.mediaplugin_mp3 object {height:15px;width:300px}
audio.<API key> {width: 300px}
/* TinyMCE moodle media preview frame should not have padding */
.core_media_preview.pagelayout-embedded #content {padding:0;}
.core_media_preview.pagelayout-embedded #maincontent {height:0;}
.core_media_preview.pagelayout-embedded .mediaplugin {margin:0;}
sub {vertical-align: sub;}
sup {vertical-align: super;}
/** Fix YUI 2 Treeview for Right to left languages **/
.dir-rtl .ygtvtn,
.dir-rtl .ygtvtm,
.dir-rtl .ygtvtmh,
.dir-rtl .ygtvtmhh,
.dir-rtl .ygtvtp,
.dir-rtl .ygtvtph,
.dir-rtl .ygtvtphh,
.dir-rtl .ygtvln,
.dir-rtl .ygtvlm,
.dir-rtl .ygtvlmh,
.dir-rtl .ygtvlmhh,
.dir-rtl .ygtvlp,
.dir-rtl .ygtvlph,
.dir-rtl .ygtvlphh,
.dir-rtl .ygtvdepthcell,
.dir-rtl .ygtvok,
.dir-rtl .ygtvok:hover,
.dir-rtl .ygtvcancel,
.dir-rtl .ygtvcancel:hover {width:18px; height:22px; background-image:url([[pix:theme|<API key>]]); background-repeat: no-repeat; cursor:pointer;}
.dir-rtl .ygtvtn {background-position: 0 -5600px;}
.dir-rtl .ygtvtm {background-position: 0 -4000px;}
.dir-rtl .ygtvtmh,
.dir-rtl .ygtvtmhh {background-position: 0 -4800px;}
.dir-rtl .ygtvtp {background-position: 0 -6400px;}
.dir-rtl .ygtvtph,
.dir-rtl .ygtvtphh {background-position: 0 -7200px;}
.dir-rtl .ygtvln {background-position: 0 -1600px;}
.dir-rtl .ygtvlm {background-position: 0 0;}
.dir-rtl .ygtvlmh,
.dir-rtl .ygtvlmhh {background-position: 0 -800px;}
.dir-rtl .ygtvlp {background-position: 0 -2400px;}
.dir-rtl .ygtvlph,
.dir-rtl .ygtvlphh {background-position: 0 -3200px}
.dir-rtl .ygtvdepthcell {background-position: 0 -8000px;}
.dir-rtl .ygtvok {background-position: 0 -8800px;}
.dir-rtl .ygtvok:hover {background-position: 0 -8844px;}
.dir-rtl .ygtvcancel {background-position: 0 -8822px;}
.dir-rtl .ygtvcancel:hover {background-position: 0 -8866px;}
.dir-rtl.yui-skin-sam .yui-panel .hd {text-align:left;}
.dir-rtl .yui-skin-sam .yui-layout .yui-layout-unit div.yui-layout-bd {text-align:right;}
/** Fix TinyMCE editor right to left **/
.dir-rtl .clearlooks2.ie9 .mceAlert .mceMiddle span,.dir-rtl .clearlooks2 .mceConfirm .mceMiddle span {top: 44px;}
.dir-rtl .o2k7Skin table,
.dir-rtl .o2k7Skin tbody,
.dir-rtl .o2k7Skin a,
.dir-rtl .o2k7Skin img,
.dir-rtl .o2k7Skin tr,
.dir-rtl .o2k7Skin div,
.dir-rtl .o2k7Skin td,
.dir-rtl .o2k7Skin iframe,
.dir-rtl .o2k7Skin span,
.dir-rtl .o2k7Skin *,
.dir-rtl .o2k7Skin .mceText,
.dir-rtl .o2k7Skin .mceListBox .mceText {text-align:right;}
.path-rating .ratingtable {width:100%;margin-bottom:1em;}
.path-rating .ratingtable th.rating {width:100%;}
.path-rating .ratingtable td.rating,
.path-rating .ratingtable td.time {white-space:nowrap; text-align:center;}
/* Fix for ordered and unordered list in course topic summary & course weekly summary */
.course-content ul.weeks .content .summary ul,
.course-content ul.topics .content .summary ul {list-style: disc outside none;}
.course-content ul.weeks .content .summary ol,
.course-content ul.topics .content .summary ol {list-style: decimal outside none;}
.dir-rtl #adminsettings #id_s__pathtodu,
.dir-rtl #adminsettings #id_s__aspellpath,
.dir-rtl #adminsettings #id_s__pathtodot,
.dir-rtl #adminsettings #id_s__supportemail,
.dir-rtl #adminsettings #id_s__supportpage,
.dir-rtl #adminsettings #id_s__sessioncookie,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #id_s__proxyhost,
.dir-rtl #adminsettings #id_s__proxyuser,
.dir-rtl #adminsettings #id_s__proxypassword,
.dir-rtl #adminsettings #id_s__proxybypass,
.dir-rtl #adminsettings #id_s__jabberhost,
.dir-rtl #adminsettings #id_s__jabberserver,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #id_s__docroot,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #id_s__blockedip,
.dir-rtl #adminsettings #id_s__pathtoclam,
.dir-rtl #adminsettings #id_s__quarantinedir,
.dir-rtl #adminsettings #id_s__sitepolicy,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #id_s__allowedip,
.dir-rtl #adminsettings #id_s__blockedip,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #admin-emoticons .form-text,
.dir-rtl #adminsettings #admin-role_mapping input[type=text],
.dir-rtl #adminsettings #<API key>,
.dir-rtl #adminsettings #<API key>,
#<API key>.dir-rtl input[type=text],
#<API key>.dir-rtl input[type=text],
#page-admin-auth-db.dir-rtl input[type=text] {direction: ltr;}
#<API key>.dir-rtl .informationbox {direction: ltr;text-align: left;}
#<API key>.dir-rtl .error input#id_name {margin-right: 170px;}
.initialbar a {padding-right: 2px;}
/* Moodle Dialogue Settings (<API key>) */
.<API key> .<API key> {
background-color:#AAA;
}
.<API key> .moodle-dialogue {
outline: #000 dotted 0;
}
.<API key> .hidden,
.<API key> .<API key> {display:none;}
.<API key> .moodle-dialogue {
padding: 0;
margin: 0;
background: none;
border: none;
/* Override the z-index set incorrectly by the YUI dialogue */
z-index: 600;
}
.no-scrolling { overflow: hidden; }
.<API key> .<API key> {
left: 0px;
top: 0px;
right: 0px;
bottom: -50px;
position: fixed;
}
.<API key> .<API key> .<API key> {
overflow: auto;
}
.<API key> .<API key> .closebutton {
width: 28px;
height: 16px;
background-size: 100%;
}
.<API key> .<API key> {
margin-top:-3px;
margin-left:-3px;
background-color: #FFFFFF;
border: 1px solid #CCCCCC;
border-radius: 10px;
box-shadow: 5px 5px 20px 0px #666666;
-webkit-box-shadow: 5px 5px 20px 0px #666666;
-moz-box-shadow: 5px 5px 20px 0px #666666;
overflow: hidden;
}
.<API key> .<API key> .moodle-dialogue-hd,
.<API key> .<API key> .moodle-dialogue-hd.yui3-widget-hd {
margin:0;
padding:5px;
font-size:12px;
font-weight: normal;
letter-spacing: 1px;
color:#333333;
text-align: center;
text-shadow: 1px 1px 1px #FFFFFF;
border-radius: 10px 10px 0px 0px;
border-bottom: 1px solid #BBBBBB;
background-color: #CCCCCC;
-ms-filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#FFFFFF', endColorstr='#CCCCCC')!important;
-ms-filter: dropshadow(color=#FFFFFF, offx=1, offy=1);
background-image: -<API key>(top, #FFFFFF, #CCCCCC); /* For Chrome and Safari */
background-image: -moz-linear-gradient(top, #FFFFFF, #CCCCCC); /* For old Fx (3.6 to 15) */
background-image: -ms-linear-gradient(top, #FFFFFF, #CCCCCC); /* For pre-releases of IE 10*/
background-image: -o-linear-gradient(top, #FFFFFF, #CCCCCC); /* For old Opera (11.1 to 12.0) */
background-image: linear-gradient(to bottom, #FFFFFF, #CCCCCC); /* Standard syntax; must be last */
}
.<API key> .<API key> .moodle-dialogue-hd h1 {
margin:0;
padding:0;
display:inline;
font-size: 100%;
font-weight: bold;
}
.<API key> .<API key> .moodle-dialogue-hd .yui3-widget-buttons {
padding: 5px;
}
.<API key> .closebutton {
width:25px;
height:15px;
float:right;
vertical-align:middle;
display:inline-block;
cursor:pointer;
padding:0px;
background-image:url([[pix:theme|sprite]]);
background-repeat:no-repeat;
border-style:none;
}
.dir-rtl .<API key> .<API key> .moodle-dialogue-hd .yui3-widget-buttons {
left: 0px;
right: auto;
}
.<API key> .moodle-dialogue .moodle-dialogue-bd {
padding: 1em;
line-height: 2em;
color: #555;
font-size: 12px;
}
.<API key> .<API key> .<API key> {
padding:0px;
background:#FFF;
}
.<API key> .<API key> .moodle-dialogue-hd {
padding: 10px;
font-size: 16px;
}
.<API key> .<API key> .<API key> {
overflow: auto;
position: absolute;
top: 0px;
bottom: 50px;
left: 0px;
right: 0px;
margin: 0px;
border: 0px;
}
.<API key> .<API key> .moodle-dialogue-hd,
.<API key> .<API key> .<API key> {
border-radius: 0px;
}
.<API key> .<API key> {text-align:center;}
.<API key> .<API key> input {text-align:center;}
.<API key> .<API key> {text-align:center}
.<API key> .<API key> label {font-weight:bold;}
.<API key> .param-stacktrace label {
background-color:#EEE;
border:1px solid #ccc;
border-bottom-width:0;
}
.<API key> .param-stacktrace pre {
border:1px solid #ccc;
background-color:#fff;
}
.<API key> .param-stacktrace .stacktrace-file {
color:navy;
font-size:80%;
}
.<API key> .param-stacktrace .stacktrace-line {
color:#AA0000;
font-size:80%;
}
.<API key> .param-stacktrace .stacktrace-call {
color:#333;
font-size:90%;
border-bottom:1px solid #eee;
}
.<API key> .moodle-dialogue .<API key> .moodle-dialogue-ft {
padding:0px;
margin: 0.7em 1em;
text-align: right;
background-color: #FFF;
font-size: 12px;
}
.<API key> .<API key> {margin:0.5em 1em;}
.<API key> .<API key> input {min-width:80px}
.<API key> .<API key> {margin:1em;}
.<API key> .<API key> {margin-bottom:0.5em;}
.<API key> .<API key> label {width:150px;}
.<API key> .param-stacktrace label {
display:block;
margin:0;
padding:4px 1em;
}
.<API key> .param-stacktrace pre {
display:block;
height:200px;
overflow:auto;
}
.<API key> .param-stacktrace .stacktrace-file {
display:inline-block;
margin:4px 0;
}
.<API key> .param-stacktrace .stacktrace-line {
display:inline-block;
width:50px;
margin:4px 1em;
}
.<API key> .param-stacktrace .stacktrace-call {
padding-left:25px;
margin-bottom:4px;
padding-bottom:4px;
}
.moodle-dialogue .moodle-dialogue-bd .content-lightbox {
opacity: .75;
width: 100%;
height: 100%;
top: 0;
left: 0;
background-color: white;
text-align: center;
padding: 10% 0;
}
/* Apply a default max-height on tooltip text */
.moodle-dialogue .tooltiptext {
max-height: 300px;
}
.<API key> .moodle-dialogue.<API key> {
z-index: 3001;
}
.<API key> .moodle-dialogue.<API key> .moodle-dialogue-bd {
overflow: auto;
}
/* Question Bank - Question Chooser "Close" button */
#page-question-edit.dir-rtl a.container-close {right:auto;left:6px;}
/**
* Chooser Dialogues (<API key>)
*
* This CSS belong to the chooser dialogue which should work both with, and
* without javascript enabled
*/
/* Hide the dialog and it's title */
.chooserdialoguebody,
.choosertitle {
display:none;
}
.moodle-dialogue.chooserdialogue .<API key> .moodle-dialogue-ft {
margin: 0;
}
.chooserdialogue .<API key> .moodle-dialogue-bd {
padding: 0px;
background: #F2F2F2;
<API key>: 10px;
<API key>: 10px;
}
/* Center the submit buttons within the area */
.choosercontainer #chooseform .submitbuttons {
padding: 0.7em 0;
text-align: center;
}
.choosercontainer #chooseform .submitbuttons input {
min-width: 100px;
margin: 0px 0.5em;
}
/* Various settings for the options area */
.choosercontainer #chooseform .options {
position: relative;
border-bottom: 1px solid #BBBBBB;
}
/* Only set these options if we're showing the js container */
.jschooser .choosercontainer #chooseform .alloptions {
overflow-x: hidden;
overflow-y: auto;
max-width: 20.3em;
box-shadow: inset 0px 0px 30px 0px #CCCCCC;
-webkit-box-shadow: inset 0px 0px 30px 0px #CCCCCC;
-moz-box-shadow: inset 0px 0px 30px 0px #CCCCCC;
}
.dir-rtl.jschooser .choosercontainer #chooseform .alloptions {
max-width: 18.3em;
}
/* Settings for option rows and option subtypes */
.choosercontainer #chooseform .moduletypetitle,
.choosercontainer #chooseform .option,
.choosercontainer #chooseform .nonoption {
margin-bottom: 0;
padding: 0 1.6em 0 1.6em;
}
.choosercontainer #chooseform .moduletypetitle {
text-transform: uppercase;
padding-top: 1.2em;
padding-bottom: 0.4em;
}
.choosercontainer #chooseform .option .typename,
.choosercontainer #chooseform .option span.modicon img.icon,
.choosercontainer #chooseform .nonoption .typename,
.choosercontainer #chooseform .nonoption span.modicon img.icon {
padding: 0 0 0 0.5em;
}
.dir-rtl .choosercontainer #chooseform .option .typename,
.dir-rtl .choosercontainer #chooseform .option span.modicon img.icon,
.dir-rtl .choosercontainer #chooseform .nonoption .typename,
.dir-rtl .choosercontainer #chooseform .nonoption span.modicon img.icon {
padding: 0 0.5em 0 0;
}
.<API key> .choosercontainer #chooseform .option span.modicon img.icon,
.<API key> .choosercontainer #chooseform .nonoption span.modicon img.icon {
height: 24px; width: 24px;
}
.choosercontainer #chooseform .option input[type=radio],
.choosercontainer #chooseform .option span.typename,
.choosercontainer #chooseform .option span.modicon {
vertical-align: middle;
}
.choosercontainer #chooseform .option label {
display: block;
padding: 0.3em 0 0.1em 0;
border-bottom: 1px solid #FFFFFF;
}
.choosercontainer #chooseform .nonoption {
padding-left: 2.7em;
padding-top: 0.3em;
padding-bottom: 0.1em;
}
.dir-rtl .choosercontainer #chooseform .nonoption {
padding-right: 2.7em;
padding-left: 0;
}
.choosercontainer #chooseform .subtype {
margin-bottom: 0;
padding: 0 1.6em 0 3.2em;
}
.dir-rtl .choosercontainer #chooseform .subtype {
padding: 0 3.2em 0 1.6em;
}
.choosercontainer #chooseform .subtype .typename {
margin: 0 0 0 0.2em;
}
.dir-rtl .choosercontainer #chooseform .subtype .typename {
margin: 0 0.2em 0 0;
}
/* The instruction/help area */
.jschooser .choosercontainer #chooseform .instruction,
.jschooser .choosercontainer #chooseform .typesummary {
display: none;
position: absolute;
top: 0px;
right: 0px;
bottom: 0px;
left: 20.3em;
margin: 0;
padding: 1.6em;
background-color: #FFFFFF;
overflow-x: hidden;
overflow-y: auto;
line-height: 2em;
}
.dir-rtl.jschooser .choosercontainer #chooseform .instruction,
.dir-rtl.jschooser .choosercontainer #chooseform .typesummary {
left: 0px;
right: 18.5em;
border-right: 1px solid grey;
}
/* Selected option settings */
.jschooser .choosercontainer #chooseform .instruction,
.choosercontainer #chooseform .selected .typesummary {
display: block;
}
.choosercontainer #chooseform .selected {
background-color: #FFFFFF;
box-shadow: 0px 0px 10px 0px #CCCCCC;
-webkit-box-shadow: 0px 0px 10px 0px #CCCCCC;
-moz-box-shadow: 0px 0px 10px 0px #CCCCCC;
}
.<API key> img.smallicon { padding-right: 3px; }
.dir-rtl .<API key> img.smallicon { padding-left: 3px; padding-right: 0;}
/* Install Process' text fields Forms, should always be justified to the left */
form#installform #id_wwwroot,form#installform #id_dirroot ,form#installform #id_dataroot,
form#installform #id_dbhost, form#installform #id_dbname, form#installform #id_dbuser,
form#installform #id_dbpass, form#installform #id_prefix
{direction: ltr;}
html[dir=rtl] .breadcrumb,
html[dir=rtl] .headermain,
html[dir=rtl] #page-header,
html[dir=rtl] #page-content {float: right;}
html[dir=rtl] .formrow label.formlabel { float:right; }
html[dir=rtl] .configphp {direction:ltr;text-align:left;}
table.flexible > tbody > tr:nth-of-type(odd), table.generaltable > tbody > tr:nth-of-type(odd) {background-color: #F0F0F0;}
table.flexible > tbody > tr:nth-of-type(even), table.generaltable > tbody > tr:nth-of-type(even) {background-color: #FAFAFA;}
table.flexible .emptyrow {display: none;}
/* Form element: listing */
.formlistingradio {padding-bottom: 25px; padding-right: 10px;}
.<API key> {float: left;}
.formlistingmain {min-height: 225px;}
.<API key> {}
.formlisting {
position: relative;
margin: 15px 0;
padding: 1px 19px 14px;
background-color: white;
border: 1px solid #DDD;
-<API key>: 4px;
-moz-border-radius: 4px;
border-radius: 4px;
}
.formlistingmore {
position: absolute;
cursor: pointer;
bottom: -1px;
right: -1px;
padding: 3px 7px;
font-size: 12px;
font-weight: bold;
background-color: whiteSmoke;
border: 1px solid #DDD;
color: #9DA0A4;
-<API key>: 4px 0 4px 0;
-moz-border-radius: 4px 0 4px 0;
border-radius: 4px 0 4px 0;
}
.formlistingall {
margin: 15px 0;
padding: 0px 0px 0px;
-<API key>: 4px;
-moz-border-radius: 4px;
border-radius: 4px;
}
.formlistingrow {
cursor: pointer;
border-bottom: 1px solid;
border-color: #E1E1E8;
border-left: 1px solid #E1E1E8;
border-right: 1px solid #E1E1E8;
background-color: #F7F7F9;
-<API key>: 0px 0px 4px 4px;
-moz-border-radius: 0px 0px 4px 4px;
padding: 6px;
top: 50%;
left: 50%;
min-height: 34px;
float:left;
width: 150px;
}
body.jsenabled .formlistingradio {
display: none;
}
body.jsenabled .formlisting {
display: block;
}
/**
* Badges styles
*/
#page-badges-view .collection { width: 90%; margin: 1em auto; }
#page-badges-index .collection { width: 85%; margin: 1em auto; }
table.collection th { font-size: inherit !important; border-width: 1px; border-style: solid; border-color: #CCCCCC; vertical-align: middle; padding-left: 5px; padding-right: 5px; vertical-align: top; text-align: center !important; }
table.collection td { border-width: 1px; border-style: solid; border-color: #CCCCCC; vertical-align: middle; padding-left: 5px; padding-right: 5px; vertical-align: top; }
table.collection > tbody > tr:nth-of-type(even) { background-color: #FFFFFF; }
table.collection > tbody > tr:nth-of-type(odd) { background-color: #F6F6F6; }
table.collection ul { margin: 0.5em 0.5em 0.5em 2em; }
.dir-rtl table.collection ul { margin: 0.5em 2em 0.5em 0.5em; }
#page-badges-view table.collection .badgeimage,
#page-badges-index table.collection .status { width: 15%; text-align: center; vertical-align: middle; }
#page-badges-view table.collection .awards,
#page-badges-index table.collection .awards { width: 10%; text-align: center; vertical-align: middle; }
#page-badges-view table.collection .description { width: 25%; text-align: left; }
#page-badges-view.dir-rtl table.collection .description { width: 25%; text-align: right; }
table.collection .name { text-align: left; vertical-align: middle; }
.dir-rtl table.collection .name { text-align: right; vertical-align: middle; }
#page-badges-view table.collection .criteria { width: 35%; text-align: left; vertical-align: top; }
#page-badges-view.dir-rtl table.collection .criteria { text-align: right; }
#page-badges-index table.collection .criteria { width: 40%; text-align: left; vertical-align: top; }
#page-badges-index.dir-rtl table.collection .criteria { text-align: right; }
#page-badges-index table.collection .actions { width: 11em; text-align: center; vertical-align: middle; }
a.criteria-action { padding: 0px 3px; float: right; }
.dir-rtl a.criteria-action { float: left; }
table.issuedbadgebox { width: 750px; background-color: white; }
table.badgeissuedimage { width: 150px; text-align: center; }
table.badgeissuedinfo { width: 600px; }
table.badgeissuedinfo .bvalue { text-align: left; vertical-align: middle; }
.dir-rtl table.badgeissuedinfo .bvalue { text-align: right; }
table.badgeissuedinfo .bfield { width: 125px; text-align: left; font-style: italic; }
.dir-rtl table.badgeissuedinfo .bfield { text-align: right; }
ul.badges { margin: 0; list-style: none; }
.badges li { position: relative; display: inline-block; padding-bottom: 2em; text-align: center; vertical-align: top; width: 150px; }
.badges li .badge-name { display: block; padding: 5px; }
.badges li > img { position: absolute; }
.badges li .badge-image { width: 90px; height: 90px; left: 10px; top: 0px; z-index: 1; }
.dir-rtl .badges li .badge-image { right: 10px; }
.badges li .badge-actions { position: relative; }
div.badge { position: relative; display: block; }
div.badge .expireimage { width: 100px; height: 100px; left: 20px; top: 0px; }
.expireimage { width: 90px; height: 90px; left: 30px; top: 0px; position: absolute; z-index:10; filter: alpha(opacity = 85); -moz-opacity: 0.85; -khtml-opacity: 0.85; opacity: 0.85;}
.badge-profile { vertical-align: top; }
.connected { color: #006600; }
.notconnected { color: #660000; }
#page-badges-award .recipienttable { background-color: #EEEEEE; border: 1px solid #BBBBBB; width: 100%; vertical-align: top; }
#page-badges-award .recipienttable tr td { vertical-align: top; }
#page-badges-award .recipienttable tr td.actions { width: 16%; padding-top: 3em; }
#page-badges-award .recipienttable tr td.actions .actionbutton { margin: 0.3em 0; padding: 0.5em 0; width: 100%; }
#page-badges-award .recipienttable tr td.existing,
#page-badges-award .recipienttable tr td.potential { width: 42%; }
.statustable { margin-bottom: 0px; }
.statusbox { border-color: #BBBBBB; }
.statusbox.active { background-color: #D9F991; }
.statusbox.inactive { background-color: #FFEBA8; }
.activatebadge { margin: 0px; text-align: left; vertical-align: middle; }
.dir-rtl .activatebadge { text-align: right; }
.addcourse { float: right; }
.dir-rtl .addcourse { float: left; }
img#persona_signin { cursor: pointer; }
/**
* The date selector popup.
*/
div#<API key> {
z-index: 3100; /* Set higher than the z-index of the filemanager - see MDL-39047. */
}
.path-mod-lesson .centerpadded { padding: 5px; text-align: center; }
/** Action menu component styles **/
.moodle-actionmenu,
.moodle-actionmenu > ul,
.moodle-actionmenu > ul > li {display: inline-block;}
.moodle-actionmenu ul {padding: 0;margin: 0;list-style-type: none;}
#page .moodle-actionmenu a.hidden {display: none;}
.moodle-actionmenu .toggle-display,
.moodle-actionmenu .menu-action-text {display: none;}
.jsenabled .block .editing_move {display: none;}
.jsenabled .moodle-actionmenu[data-enhance] {display: block;}
.jsenabled .moodle-actionmenu[data-enhance] .menu {display: none;}
.jsenabled .moodle-actionmenu[data-enhance] .toggle-display {display: inline;opacity: 0.5;filter: alpha(opacity=50);}
.jsenabled .moodle-actionmenu[data-enhance] .toggle-display.textmenu {
display: block;
margin-left: 4px;
padding-left: 4px;
padding-right: 4px;
}
.jsenabled.dir-rtl .moodle-actionmenu[data-enhance] .toggle-display.textmenu {
margin-right: 4px;
margin-left: initial;
}
.jsenabled .moodle-actionmenu[data-enhance] .toggle-display.textmenu .iconsmall {
margin: 8px 4px 0px 2px;
}
.jsenabled .moodle-actionmenu[data-enhance] .toggle-display.textmenu .caret {
margin-top: 4px;
margin-left: 2px;
}
.jsenabled.dir-rtl .moodle-actionmenu[data-enhance] .toggle-display.textmenu .caret {
margin-right: 2px;
margin-left: initial;
}
.jsenabled .moodle-actionmenu[data-enhanced] .toggle-display {opacity: 1;filter: alpha(opacity=100);}
.jsenabled .moodle-actionmenu[data-enhanced] .menu-action-text {
display: inline;
}
.moodle-actionmenu[data-enhanced].show {position: relative;}
.moodle-actionmenu[data-enhanced].show .menu {position: absolute;text-align:left;z-index: 1000;display: block;background-color: #fff;border: 1px solid #ccc;-<API key>: 5px;-moz-border-radius: 5px;border-radius: 5px;-webkit-box-shadow: 5px 5px 20px 0 #666666;-moz-box-shadow: 5px 5px 20px 0 #666666;box-shadow: 5px 5px 20px 0 #666666;}
.moodle-actionmenu[data-enhanced].show .menu a {
display: block;
padding: 2px 1em 2px 28px;
color: #333333;
}
.moodle-actionmenu[data-enhanced].show .menu a > img {
margin: 4px 4px 4px -24px;
padding: 4px;
width: 12px;
height: 12px;
}
.moodle-actionmenu[data-enhanced].show .menu a > img,
.moodle-actionmenu[data-enhanced].show .menu a > span {
display: inline-block;
vertical-align: middle;
}
.moodle-actionmenu[data-enhanced].show .menu a:hover {color: #ffffff;background-color: #0088cc;}
.moodle-actionmenu[data-enhanced].show .menu a:first-child {-<API key>: 4px;<API key>: 4px;-<API key>: 4px;<API key>: 4px;-<API key>: 4px;-<API key>: 4px;}
.moodle-actionmenu[data-enhanced].show .menu a:last-child {-<API key>: 4px;<API key>: 4px;-<API key>: 4px;<API key>: 4px;-<API key>: 4px;-<API key>: 4px;}
.moodle-actionmenu[data-enhanced].show .menu a.hidden {display: none;}
.moodle-actionmenu[data-enhanced].show .menu img {vertical-align: middle;}
.moodle-actionmenu[data-enhanced].show .menu > li {display: block;}
.block .moodle-actionmenu {text-align: right;}
.dir-rtl .block .moodle-actionmenu {text-align: right;}
.dir-rtl .moodle-actionmenu[data-enhanced].show .menu a { display: block; padding: 2px 28px 2px 1em; }
.dir-rtl .moodle-actionmenu[data-enhanced].show .menu {text-align: right;right: auto;left: 0;}
.dir-rtl .moodle-actionmenu[data-enhanced].show .menu .iconsmall,
.dir-rtl .moodle-actionmenu[data-enhanced].show .menu .smallicon { margin-right: -24px; margin-left: 4px; }
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-tl-bl {top: 100%;left: 0;margin-top: 4px;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-tr-bl {top: 100%;right: 100%;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-bl-bl {bottom: 100%;left: 0;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-br-bl {right: 100%;bottom: 100%;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-tl-br {top: 100%;left: 100%;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-tr-br {top: 100%;right: 0;margin-top: 4px;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-bl-br {bottom: 100%;left: 100%;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-br-br {right: 0;bottom: 100%;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-tl-tl {top: 0;left: 0;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-tr-tl {top: 0;right: 100%;margin-right: 4px;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-bl-tl {bottom: 100%;left: 0;margin-bottom: 4px;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-br-tl {right: 100%;bottom: 100%;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-tl-tr {top: 0;left: 100%;margin-left: 4px;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-tr-tr {top: 0;right: 0;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-bl-tr {bottom: 100%;left: 100%;}
.jsenabled .moodle-actionmenu[data-enhanced] .menu.align-br-tr {right: 0;bottom: 100%;margin-bottom: 4px;}
.moodle-actionmenu > ul > li[role="menuitem"] {
display: none;
}
.jsenabled .moodle-actionmenu[data-enhance="<API key>"] > ul > li[role="menuitem"] {
display: inline-block;
}
.dir-rtl .menu.align-tl-bl {right: 0;left: auto;}
.dir-rtl .menu.align-tr-bl {right: auto;left: 100%;}
.dir-rtl .menu.align-bl-bl {right: 0;left: auto;}
.dir-rtl .menu.align-br-bl {right: auto;left: 100%;}
.dir-rtl .menu.align-tl-br {right: 100%;left: auto;}
.dir-rtl .menu.align-tr-br {right: auto;left: 0;}
.dir-rtl .menu.align-bl-br {right: 100%;left: auto;}
.dir-rtl .menu.align-br-br {right: auto;left: 0;}
.dir-rtl .menu.align-tl-tl {right: 0;left: auto;}
.dir-rtl .menu.align-tr-tl {right: auto;left: 100%;}
.dir-rtl .menu.align-bl-tl {right: 0;left: auto;}
.dir-rtl .menu.align-br-tl {right: auto;left: 100%;}
.dir-rtl .menu.align-tl-tr {right: 100%;left: auto;}
.dir-rtl .menu.align-tr-tr {right: auto;left: 0;}
.dir-rtl .menu.align-bl-tr {right: 100%;left: auto;}
.dir-rtl .menu.align-br-tr {right: auto;left: 0;}
ul.<API key> li { list-style-type: none; }
.<API key> .<API key> img { width: 12px; height: 12px; }
.block .header h2,
.course-content h3,
.<API key> h2,
.<API key> h3,
.<API key> h4,
.<API key> h5,
.<API key> h6,
.<API key> h3,
.<API key> h4,
.<API key> h5,
.<API key> h6 {
text-align: inherit;
}
a.disabled:hover,
a.disabled {
text-decoration: none;
cursor: default;
font-style: italic;
color: #808080;
}
.caret {
display: inline-block;
width: 0;
height: 0;
vertical-align: top;
border-top: 4px solid #777;
border-right: 4px solid transparent;
border-left: 4px solid transparent;
content: "";
}
a:focus .caret,
a:hover .caret {
border-top-color: #555;
}
/**
* Bootstrap 2.3.2 progress bar css.
* Required for none bootstrap theme.
*/
@-webkit-keyframes <API key> {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
}
}
@-moz-keyframes <API key> {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
}
}
@-ms-keyframes <API key> {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
}
}
@-o-keyframes <API key> {
from {
background-position: 0 0;
}
to {
background-position: 40px 0;
}
}
@keyframes <API key> {
from {
background-position: 40px 0;
}
to {
background-position: 0 0;
}
}
.progress {
height: 20px;
margin-bottom: 20px;
overflow: hidden;
background-color: #f7f7f7;
background-image: -moz-linear-gradient(top, #f5f5f5, #f9f9f9);
background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#f5f5f5), to(#f9f9f9));
background-image: -<API key>(top, #f5f5f5, #f9f9f9);
background-image: -o-linear-gradient(top, #f5f5f5, #f9f9f9);
background-image: linear-gradient(to bottom, #f5f5f5, #f9f9f9);
background-repeat: repeat-x;
-<API key>: 4px;
-moz-border-radius: 4px;
border-radius: 4px;
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#fff9f9f9', GradientType=0);
-webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
-moz-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
}
.progress .bar {
float: left;
width: 0;
height: 100%;
font-size: 12px;
color: #ffffff;
text-align: center;
text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
background-color: #0e90d2;
background-image: -moz-linear-gradient(top, #149bdf, #0480be);
background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#149bdf), to(#0480be));
background-image: -<API key>(top, #149bdf, #0480be);
background-image: -o-linear-gradient(top, #149bdf, #0480be);
background-image: linear-gradient(to bottom, #149bdf, #0480be);
background-repeat: repeat-x;
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff149bdf', endColorstr='#ff0480be', GradientType=0);
-webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
-moz-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
-webkit-transition: width 0.6s ease;
-moz-transition: width 0.6s ease;
-o-transition: width 0.6s ease;
transition: width 0.6s ease;
}
.progress .bar + .bar {
-webkit-box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
-moz-box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.15), inset 0 -1px 0 rgba(0, 0, 0, 0.15);
}
.progress-striped .bar {
background-color: #149bdf;
background-image: -webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));
background-image: -<API key>(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
background-image: -moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
background-image: -o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
background-image: linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);
-<API key>: 40px 40px;
-moz-background-size: 40px 40px;
-o-background-size: 40px 40px;
background-size: 40px 40px;
}
.progress.active .bar {
-webkit-animation: <API key> 2s linear infinite;
-moz-animation: <API key> 2s linear infinite;
-ms-animation: <API key> 2s linear infinite;
-o-animation: <API key> 2s linear infinite;
animation: <API key> 2s linear infinite;
}
body.lockscroll {
height: 100%;
overflow: hidden;
}
/* Dropdown Menu styling */
.dropdown-menu {
background-color: #fff;
border: 1px solid #ccc;
border: 1px solid rgba(0, 0, 0, 0.2);
position: absolute;
top: 100%;
left: 0;
z-index: 1000;
display: none;
float: left;
min-width: 160px;
padding: 5px 0;
margin: 2px 0 0;
list-style: none;
*border-right-width: 2px;
*border-bottom-width: 2px;
-<API key>: 6px;
-moz-border-radius: 6px;
border-radius: 6px;
-webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
-moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
-<API key>: padding-box;
-moz-background-clip: padding;
background-clip: padding-box;
}
.dropdown-menu > li > a {
display: block;
padding: 3px 20px;
clear: both;
font-weight: normal;
line-height: 20px;
white-space: nowrap;
}
.dropdown-menu > li > a:hover,
.dropdown-menu > li > a:focus {
text-decoration: none;
background-repeat: repeat-x;
}
.dropdown-menu > .active > a,
.dropdown-menu > .active > a:hover,
.dropdown-menu > .active > a:focus {
text-decoration: none;
outline: 0;
}
.dropdown-menu > .disabled > a:hover,
.dropdown-menu > .disabled > a:focus {
text-decoration: none;
background-color: transparent;
background-image: none;
filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
cursor: default;
}
.open {
*z-index: 1000;
}
.open > .dropdown-menu {
display: block;
}
.editor_atto_menu .<API key> {
padding: 0;
border: inherit;
}
.well {
min-height: 20px;
padding: 19px;
background-color: #f5f5f5;
border: 1px solid #e3e3e3;
border-radius: 4px;
box-shadow: inset 0 1px 1px rgba(0,0,0,0.05);
}
.well-small {
padding: 9px;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.