static void PrintHeader(const Proto* f)
{
printf("\n%s <%s:%d> (%d instruction%s, %d bytes at %p)\n",
IsMain(f)?"main":"function",Source(f),f->lineDefined,
S(f->sizecode),f->sizecode*Sizeof(Instruction),VOID(f));
printf("%d%s param%s, %d stack%s, %d upvalue%s, ",
f->numparams,f->is_vararg?"+":"",SS(f->numparams),S(f->maxstacksize),
S(f->nups));
printf("%d local%s, %d constant%s, %d function%s\n",
S(f->sizelocvars),S(f->sizek),S(f->sizep));
}
CString GetError(_com_error &e)
{
CString MsgBug;
_bstr_t Source(e.Source());
_bstr_t Description(e.Description());
MsgBug.Format( "Ups!!! \nSource = %s\nDescription= %s\n",(LPCSTR)Source, (LPCSTR)Description );
#ifdef _DEBUG
AfxMessageBox( MsgBug, MB_OK | MB_ICONERROR );
#endif
return MsgBug;
}
void Nym::DisplayStatistics(String& strOutput) const
{
sLock lock(shared_lock_);
strOutput.Concatenate("Source for ID:\n%s\n", Source().asString()->Get());
strOutput.Concatenate("Description: %s\n\n", m_strDescription->Get());
strOutput.Concatenate("%s", "\n");
strOutput.Concatenate("==> Name: %s\n", Alias().c_str());
strOutput.Concatenate(" Version: %s\n", m_strVersion->Get());
auto theStringID = String::Factory(ID());
strOutput.Concatenate("Nym ID: %s\n", theStringID->Get());
}
status_t
AVFormatReader::Sniff(int32* _streamCount)
{
TRACE("AVFormatReader::Sniff\n");
BPositionIO* source = dynamic_cast<BPositionIO*>(Source());
if (source == NULL) {
TRACE(" not a BPositionIO, but we need it to be one.\n");
return B_NOT_SUPPORTED;
}
Stream* stream = new(std::nothrow) Stream(source,
&fSourceLock);
if (stream == NULL) {
ERROR("AVFormatReader::Sniff() - failed to allocate Stream\n");
return B_NO_MEMORY;
}
ObjectDeleter<Stream> streamDeleter(stream);
status_t ret = stream->Open();
if (ret != B_OK) {
TRACE(" failed to detect stream: %s\n", strerror(ret));
return ret;
}
delete[] fStreams;
fStreams = NULL;
int32 streamCount = stream->CountStreams();
if (streamCount == 0) {
TRACE(" failed to detect any streams: %s\n", strerror(ret));
return B_ERROR;
}
fStreams = new(std::nothrow) Stream*[streamCount];
if (fStreams == NULL) {
ERROR("AVFormatReader::Sniff() - failed to allocate streams\n");
return B_NO_MEMORY;
}
memset(fStreams, 0, sizeof(Stream*) * streamCount);
fStreams[0] = stream;
streamDeleter.Detach();
#ifdef TRACE_AVFORMAT_READER
dump_format(const_cast<AVFormatContext*>(stream->Context()), 0, "", 0);
#endif
if (_streamCount != NULL)
*_streamCount = streamCount;
return B_OK;
}
status_t
AVFormatReader::AllocateCookie(int32 streamIndex, void** _cookie)
{
TRACE("AVFormatReader::AllocateCookie(%ld)\n", streamIndex);
BAutolock _(fSourceLock);
if (fStreams == NULL)
return B_NO_INIT;
if (streamIndex < 0 || streamIndex >= fStreams[0]->CountStreams())
return B_BAD_INDEX;
if (_cookie == NULL)
return B_BAD_VALUE;
Stream* cookie = fStreams[streamIndex];
if (cookie == NULL) {
// Allocate the cookie
BPositionIO* source = dynamic_cast<BPositionIO*>(Source());
if (source == NULL) {
TRACE(" not a BPositionIO, but we need it to be one.\n");
return B_NOT_SUPPORTED;
}
cookie = new(std::nothrow) Stream(source, &fSourceLock);
if (cookie == NULL) {
ERROR("AVFormatReader::Sniff() - failed to allocate "
"Stream\n");
return B_NO_MEMORY;
}
status_t ret = cookie->Open();
if (ret != B_OK) {
TRACE(" stream failed to open: %s\n", strerror(ret));
delete cookie;
return ret;
}
}
status_t ret = cookie->Init(streamIndex);
if (ret != B_OK) {
TRACE(" stream failed to initialize: %s\n", strerror(ret));
// NOTE: Never delete the first stream!
if (streamIndex != 0)
delete cookie;
return ret;
}
fStreams[streamIndex] = cookie;
*_cookie = cookie;
return B_OK;
}
/*
* srcHook - run a specified source hook
*/
static vi_rc srcHook( hooktype num, vi_rc lastrc )
{
vars *v;
srcline sline;
vi_rc rc;
if( hookRun & num ) {
return( lastrc );
}
/*
* check script type
*/
v = GetHookVar( num );
/*
* run script, if we have one
*/
if( v != NULL ) {
if( num == SRC_HOOK_COMMAND ) {
VarAddGlobalStr( "Com", CommandBuffer );
}
// if( num == SRC_HOOK_MODIFIED ) {
// lastrc = LastEvent;
// }
/*
* set up for and run script
*/
hookRun |= num;
LastRetCode = lastrc;
rc = Source( v->value, srcHookData, &sline );
/*
* if we had a command hook, look for replacement variable
*/
if( num == SRC_HOOK_COMMAND ) {
v = VarFind( "Com", NULL );
if( v != NULL ) {
strcpy( CommandBuffer, v->value );
}
}
/*
* we are done now, reset and go back
*/
LastRetCode = ERR_NO_ERR;
hookRun &= ~num;
DCUpdateAll();
return( rc );
}
return( lastrc );
} /* srcHook */
const Source Skin::source(std::string ParamName) const
{
for(uint i=0; i< this->NrSources(); i++) {
const Source& src = this->source(i);
std::string Name =
src.technique_common().accessor().param(0).name();
if(Name == ParamName) return src;
}
return Source();
}
void ShadowView::ConstrainCamera()
{
if( mPointLight && mShadowPlane )
{
// Constrain camera to look directly at center of shadow plane. (mPointLight position
// is under control of application, can't use transform inheritance)
Constraint cameraOrientationConstraint =
Constraint::New<Quaternion> ( Actor::ROTATION,
Source( mShadowPlane, Actor::WORLD_POSITION ),
Source( mPointLight, Actor::WORLD_POSITION ),
Source( mShadowPlane, Actor::WORLD_ROTATION ),
&LookAt );
mCameraActor.ApplyConstraint( cameraOrientationConstraint );
Constraint pointLightPositionConstraint = Constraint::New<Vector3>( Actor::POSITION, Source( mPointLight, Actor::WORLD_POSITION ), EqualToConstraint() );
mCameraActor.ApplyConstraint( pointLightPositionConstraint );
}
}
void CObjectImageArray::GenerateGlowImage (int iRotation) const
// GenerateGlowImage
//
// Generates a mask that looks like a glow. The mask is 0 for all image pixels
// and for all pixels where there is no glow (thus we can optimize painting
// of the glow by ignoring 0 values)
{
ASSERT(iRotation >= 0 && iRotation < m_iRotationCount);
// Source
if (m_pImage == NULL)
return;
CG16bitImage &Source(*m_pImage->GetImage());
// Allocate the array of images (if not already allocated)
if (m_pGlowImages == NULL)
m_pGlowImages = new CG16bitImage[m_iRotationCount];
// If the image for this rotation has already been initialized, then
// we're done
if (!m_pGlowImages[iRotation].IsEmpty())
return;
// Otherwise we need to create the glow mask. The glow image is larger
// than the object image (by GLOW_SIZE)
int cxSrcWidth = RectWidth(m_rcImage);
int cySrcHeight = RectHeight(m_rcImage);
int cxGlowWidth = cxSrcWidth + 2 * GLOW_SIZE;
int cyGlowHeight = cySrcHeight + 2 * GLOW_SIZE;
if (m_pGlowImages[iRotation].Create(cxGlowWidth, cyGlowHeight, 8) != NOERROR)
{
m_pGlowImages[iRotation].DiscardSurface();
kernelDebugLogMessage("Unable to create image");
return;
}
RECT rcSrc;
rcSrc.left = ComputeSourceX(0);
rcSrc.top = m_rcImage.top + (iRotation * cySrcHeight);
rcSrc.right = rcSrc.left + cxSrcWidth;
rcSrc.bottom = rcSrc.top + cySrcHeight;
m_pGlowImages[iRotation].DrawGlowImage(0, 0, Source, rcSrc.left,
rcSrc.top, rcSrc.right, rcSrc.bottom, 4);
}
// -----------------------------------------------------------------------------
// CMceSrvStream::IsEqual
// -----------------------------------------------------------------------------
//
TBool CMceSrvStream::IsEqual( const CMceSrvStream& aStream ) const
{
TBool equal = EFalse;
if ( &aStream )
{
equal = Codec().Id() == aStream.Codec().Id() &&
Source().Data().Id() == aStream.Source().Data().Id() &&
Sink().Data().Id() == aStream.Sink().Data().Id();
}
return equal;
}
int alternate_import_constructor_test(Epetra_Comm& Comm) {
int rv=0;
int nodes_per_proc=10;
int numprocs = Comm.NumProc();
int mypid = Comm.MyPID();
// Only run if we have multiple procs & MPI
if(numprocs==0) return 0;
#ifndef HAVE_MPI
return 0;
#endif
// Build Map 1 - linear
Epetra_Map Map1((long long)-1,nodes_per_proc,(long long)0,Comm);
// Build Map 2 - mod striped
std::vector<long long> MyGIDs(nodes_per_proc);
for(int i=0; i<nodes_per_proc; i++)
MyGIDs[i] = (mypid*nodes_per_proc + i) % numprocs;
Epetra_Map Map2((long long)-1,nodes_per_proc,&MyGIDs[0],(long long)0,Comm);
// For testing
Epetra_LongLongVector Source(Map1), Target(Map2);
// Build Import 1 - normal
Epetra_Import Import1(Map2,Map1);
rv = rv|| test_import_gid("Alt test: 2 map constructor",Source,Target, Import1);
// Build Import 2 - no-comm constructor
int Nremote=Import1.NumRemoteIDs();
const int * RemoteLIDs = Import1.RemoteLIDs();
std::vector<int> RemotePIDs(Nremote+1); // I hate you, stl vector....
std::vector<int> AllPIDs;
Epetra_Util::GetPids(Import1,AllPIDs,true);
for(int i=0; i<Nremote; i++) {
RemotePIDs[i]=AllPIDs[RemoteLIDs[i]];
}
Epetra_Import Import2(Import1.TargetMap(),Import1.SourceMap(),Nremote,&RemotePIDs[0],Import1.NumExportIDs(),Import1.ExportLIDs(),Import1.ExportPIDs());
rv = rv || test_import_gid("Alt test: no comm constructor",Source,Target,Import2);
// Build Import 3 - Remotes only
Epetra_Import Import3(Import1.TargetMap(),Import1.SourceMap(),Nremote,&RemotePIDs[0]);
rv = rv || test_import_gid("Alt test: remote only constructor",Source,Target, Import3);
return rv;
}
/** This is the place where speech, poses, and \@emits by thing should be
* heard. For things and players, it's the loc; for rooms, it's the room
* itself; for exits, it's the source.
*/
dbref
speech_loc(dbref thing)
{
if (!RealGoodObject(thing))
return NOTHING;
switch (Typeof(thing)) {
case TYPE_ROOM:
return thing;
case TYPE_EXIT:
return Source(thing);
default:
return Location(thing);
}
}
int NetworkConstraints::getNetworkConstraints(string resFile)
{
try
{
sae::io::MappedGraph* g = sae::io::MappedGraph::Open(graphFile.c_str());
for (auto e = g->Edges(); e->Alive(); e->Next())
{
EData ed = sae::serialization::convert_from_string<EData>(e->Data());
ed.value = 0;
for(auto es = e->Source()->OutEdges(); es->Alive(); es->Next())
{
for(auto ee = es->Target()->OutEdges(); ee->Alive(); ee->Next())
{
if (ee->Target()->GlobalId() == e->Target()->GlobalId())
{
ed.value += sae::serialization::convert_from_string<EData>(es->Data()).attribute[0] *
sae::serialization::convert_from_string<EData>(ee->Data()).attribute[0];
break;
}
}
}
e->Data() = sae::serialization::convert_to_string<EData>(ed);
}
ofstream outfile(resFile);
for (auto v = g->Vertices(); v->Alive(); v->Next())
{
double value = 0;
VData vd = sae::serialization::convert_from_string<VData>(v->Data());
for(auto e = v->OutEdges(); e->Alive(); e->Next())
{
value += sae::serialization::convert_from_string<EData>(e->Data()).value;
}
if(v->OutEdgeCount() > 0)
{
outfile << vd.name << "\t" << value / v->OutEdgeCount() <<"\n";
}
else
{
outfile << vd.name << "\t" << 0 <<"\n";
}
}
cout<<"compute Network Constraints done."<<endl;
}
catch(...)
{
cout << "Network Constraints parameter error" << endl;
return -1;
}
return 0;
}
void ShadowView::SetShadowPlane(Actor shadowPlane)
{
mShadowPlaneBg = shadowPlane;
mShadowPlane = ImageActor::New();
mShadowPlane.SetParentOrigin(ParentOrigin::CENTER);
mShadowPlane.SetAnchorPoint(AnchorPoint::CENTER);
mShadowPlane.SetImage(mOutputImage);
mShadowPlane.SetShaderEffect(mShadowRenderShader);
// Rather than parent the shadow plane drawable and have constraints to move it to the same
// position, instead parent the shadow plane drawable on the shadow plane passed in.
mShadowPlaneBg.Add(mShadowPlane);
mShadowPlane.SetParentOrigin(ParentOrigin::CENTER);
mShadowPlane.SetZ(1.0f);
ConstrainCamera();
mShadowPlane.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, Source( mShadowPlaneBg, Actor::SIZE ), EqualToConstraint() ) );
mBlurRootActor.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, Source( mShadowPlane, Actor::SIZE ), EqualToConstraint() ) );
}
status_t
TAPEReader::Sniff(int32* oStreamCount)
{
Unset();
// prepare about file
mSrcPIO = dynamic_cast<BPositionIO*>(Source());
if (mSrcPIO == NULL)
return B_ERROR;
BMediaIO* mediaIO = dynamic_cast<BMediaIO*>(Source());
if (mediaIO != NULL) {
int32 flags = 0;
mediaIO->GetFlags(&flags);
// This plugin doesn't support streamed data.
// The APEHeader::FindDescriptor function always
// analyze the whole file to find the APE_DESCRIPTOR.
if ((flags & B_MEDIA_STREAMING) == true)
return B_ERROR;
}
int nFunctionRetVal = ERROR_SUCCESS;
mPositionBridgeIO.SetPositionIO(mSrcPIO);
mDecomp = CreateIAPEDecompressEx(&mPositionBridgeIO, &nFunctionRetVal);
if (mDecomp == NULL || nFunctionRetVal != ERROR_SUCCESS)
return B_ERROR;
// prepare about data
mDataSize = static_cast<int64>(mDecomp->GetInfo(APE_DECOMPRESS_TOTAL_BLOCKS))
*mDecomp->GetInfo(APE_INFO_BLOCK_ALIGN);
mDecodedData = new char [max_c(BUFFER_SIZE*mDecomp->GetInfo(APE_INFO_CHANNELS),
BLOCK_COUNT*mDecomp->GetInfo(APE_INFO_BLOCK_ALIGN))];
mLoadAPECheck = B_OK;
*oStreamCount = 1;
return B_OK;
}
// public Fuse.Drawing.Polygon get_Output() [instance] :185
::g::Fuse::Drawing::Polygon* Stroke::Output()
{
uStackFrame __("Fuse.Entities.Processing.Stroke", "get_Output()");
::g::Fuse::Drawing::Polygon* ret2;
::g::Fuse::Drawing::Polygon* ret3;
if (_output != NULL)
return _output;
if ((_source == NULL) || ((::g::Fuse::IOutput::get_Output_ex(uInterface(uPtr(_source), ::TYPES[2/*Fuse.IOutput<Fuse.Drawing.Polygon>*/]), &ret2), ret2) == NULL))
return NULL;
_output = uPtr((::g::Fuse::IOutput::get_Output_ex(uInterface(uPtr(Source()), ::TYPES[2/*Fuse.IOutput<Fuse.Drawing.Polygon>*/]), &ret3), ret3))->Stroke(::g::Uno::Math::Max1(0.1f, Width()), Offset(), StartCap(), EndCap());
return _output;
}
MotionStretchEffect MotionStretchEffect::Apply( Actor handle )
{
MotionStretchEffect newEffect = New();
handle.SetShaderEffect( newEffect );
Property::Index uModelProperty = newEffect.GetPropertyIndex( MOTION_STRETCH_MODELVIEW_LASTFRAME );
Constraint constraint = Constraint::New<Matrix>( uModelProperty,
Source( handle, Actor::WORLD_MATRIX ),
EqualToConstraint() );
// and set up constraint.
newEffect.ApplyConstraint(constraint);
return newEffect;
}
void QCAD::PoissonResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid::FunctionSpaceTools FST;
// Scale gradient into a flux, reusing same memory
FST::scalarMultiplyDataData<ScalarT> (PhiFlux, Permittivity, PhiGrad);
FST::integrate<ScalarT>(PhiResidual, PhiFlux, wGradBF, Intrepid::COMP_CPP, false); // "false" overwrites
if (haveSource) {
for (int i=0; i<Source.dimension(0); i++)
for (int j=0; j<Source.dimension(1); j++)
Source(i,j) *= -1.0;
FST::integrate<ScalarT>(PhiResidual, Source, wBF, Intrepid::COMP_CPP, true); // "true" sums into
}
}
Source::Source(LanguagePool *languagePool, const path &sourceFilePath) throw(LanguageException, SourceException)
{
//variable
Language *sourceLanguage = nullptr;
//vérification de l'existence du fichier
if (!exists(sourceFilePath))
{
throw SourceException(tr("Le fichier source \"%0\" n'existe pas.", sourceFilePath.native()));
}
//récupération du langage en fonction de l'extension de la source
sourceLanguage = languagePool->getLanguageWithExtension(sourceFilePath.extension().native());
//parsage de la source
Source(sourceLanguage, sourceFilePath);
}
std::unique_ptr<ZipFileCollection> ZipFileCollection::create(const StringPiece& path,
std::string* outError) {
constexpr static const int32_t kEmptyArchive = -6;
std::unique_ptr<ZipFileCollection> collection = std::unique_ptr<ZipFileCollection>(
new ZipFileCollection());
int32_t result = OpenArchive(path.data(), &collection->mHandle);
if (result != 0) {
// If a zip is empty, result will be an error code. This is fine and we should
// return an empty ZipFileCollection.
if (result == kEmptyArchive) {
return collection;
}
if (outError) *outError = ErrorCodeString(result);
return {};
}
void* cookie = nullptr;
result = StartIteration(collection->mHandle, &cookie, nullptr, nullptr);
if (result != 0) {
if (outError) *outError = ErrorCodeString(result);
return {};
}
using IterationEnder = std::unique_ptr<void, decltype(EndIteration)*>;
IterationEnder iterationEnder(cookie, EndIteration);
ZipString zipEntryName;
ZipEntry zipData;
while ((result = Next(cookie, &zipData, &zipEntryName)) == 0) {
std::string zipEntryPath = std::string(reinterpret_cast<const char*>(zipEntryName.name),
zipEntryName.name_length);
std::string nestedPath = path.toString() + "@" + zipEntryPath;
collection->mFiles[zipEntryPath] = util::make_unique<ZipFile>(collection->mHandle,
zipData,
Source(nestedPath));
}
if (result != -1) {
if (outError) *outError = ErrorCodeString(result);
return {};
}
return collection;
}
bool CObjectImageArray::PointInImage (int x, int y, int iTick, int iRotation) const
// PointInImage
//
// Returns TRUE if the given point is inside the masked part of the image
// x, y is relative to the center of the image (GDI directions)
{
if (m_pImage)
{
CG16bitImage &Source(*m_pImage->GetImage());
// Compute the position of the frame
int cxWidth = RectWidth(m_rcImage);
int cyHeight = RectHeight(m_rcImage);
int xSrc = ComputeSourceX(iTick);
int ySrc = m_rcImage.top + (iRotation * cyHeight);
// Adjust the point so that it is relative to the
// frame origin (upper left)
x = xSrc + x + (cxWidth / 2);
y = ySrc + y + (cyHeight / 2);
// Adjust for rotation
if (m_pRotationOffset)
{
x -= m_pRotationOffset[iRotation % m_iRotationCount].x;
y += m_pRotationOffset[iRotation % m_iRotationCount].y;
}
// Check bounds
if (x < xSrc || y < ySrc || x >= (xSrc + cxWidth) || y >= (ySrc + cyHeight))
return false;
// Check to see if the point is inside or outside the mask
return (CGImage::AlphaColor(Source.GetPixel(x, y)) != 0);
}
else
return false;
}
void VideoInput::Open(
const std::string& input_uri,
const std::string& output_uri
)
{
str_uri_input = input_uri;
uri_input = ParseUri(input_uri);
uri_output = ParseUri(output_uri);
if (uri_output.scheme == "file") {
// Default to pango output
uri_output.scheme = "pango";
}
// Start off playing from video_src
video_src = OpenVideo(input_uri);
Source();
}
void CObjectImageArray::CopyImage (CG16bitImage &Dest, int x, int y, int iFrame, int iRotation) const
// CopyImage
//
// Copies entire image to the destination
{
if (m_pImage)
{
CG16bitImage &Source(*m_pImage->GetImage());
int xSrc = m_rcImage.left + (iFrame * RectWidth(m_rcImage));
int ySrc = m_rcImage.top + (iRotation * RectHeight(m_rcImage));
Dest.Blt(x, y, Source, xSrc, ySrc, xSrc + RectWidth(m_rcImage),
ySrc + RectHeight(m_rcImage), false);
}
}
long FileVarsParse(Scanner_p in, FileVars_p vars)
{
char* name;
StrTree_p cell, test;
long res = 0;
DStr_p value = DStrAlloc();
assert(!PStackEmpty(vars->names));
assert(strcmp(PStackTopP(vars->names), DStrView(Source(in))) == 0);
while(!TestInpTok(in, NoToken))
{
CheckInpTok(in, Identifier);
name = DStrCopy(AktToken(in)->literal);
cell = StrTreeFind(&(vars->vars), name);
if(cell)
{
FREE(cell->val1.p_val);
}
else
{
cell = StrTreeCellAllocEmpty();
cell->key = name;
cell->val2.p_val = PStackTopP(vars->names);
test = StrTreeInsert(&(vars->vars), cell);
assert(test == NULL);
}
NextToken(in);
AcceptInpTok(in, EqualSign);
DStrReset(value);
while(!TestInpTok(in, Semicolon))
{
DStrAppendDStr(value, AktToken(in)->literal);
NextToken(in);
}
AcceptInpTok(in, Semicolon);
cell->val1.p_val = DStrCopy(value);
res++;
}
DStrFree(value);
return res;
}
// Any Transact-SQL statement can be followed by ; and GO, any combination of them or nothing at all
void SqlParser::SqlServerDelimiter()
{
if(Source(SQL_SQL_SERVER, SQL_SYBASE) == false || Target(SQL_SQL_SERVER, SQL_SYBASE) == true)
return;
Token *last = GetLastToken();
// Optional ; can go before GO
Token *semi = GetNextCharToken(';', L';');
// Optional GO to terminate the batch
Token *go = GetNextWordToken("GO", L"GO", 2);
// No ; delimiter
if(semi == NULL)
AppendNoFormat(last, ";", L";", 1);
Token::Remove(go);
}
TEST_F(TableMergerTest, MergeFile) {
ResourceTable finalTable;
TableMergerOptions options;
options.autoAddOverlay = false;
TableMerger merger(mContext.get(), &finalTable, options);
ResourceFile fileDesc;
fileDesc.config = test::parseConfigOrDie("hdpi-v4");
fileDesc.name = test::parseNameOrDie(u"@layout/main");
fileDesc.source = Source("res/layout-hdpi/main.xml");
test::TestFile testFile("path/to/res/layout-hdpi/main.xml.flat");
ASSERT_TRUE(merger.mergeFile(fileDesc, &testFile));
FileReference* file = test::getValueForConfig<FileReference>(&finalTable,
u"@com.app.a:layout/main",
test::parseConfigOrDie("hdpi-v4"));
ASSERT_NE(nullptr, file);
EXPECT_EQ(std::u16string(u"res/layout-hdpi-v4/main.xml"), *file->path);
}
void NSNeutronEqResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid::FunctionSpaceTools FST;
FST::scalarMultiplyDataData<ScalarT> (flux, NeutronDiff, NGrad);
FST::integrate<ScalarT>(NResidual, flux, wGradBF, Intrepid::COMP_CPP, false); // "false" overwrites
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
abscoeff(cell,qp) =
(Absorp(cell,qp) - nu(cell,qp)*Fission(cell,qp)) * Neutron(cell,qp);
if (haveNeutSource) abscoeff(cell,qp) -= Source(cell,qp);
}
}
FST::integrate<ScalarT>(NResidual, abscoeff, wBF, Intrepid::COMP_CPP, true); // "true" sums into
}
// because the debugger can be attached at any time, and also because other
// methods will be called on this debugger for sources that have already been
// detached, we make fake entries for unknown source entries as they are
// encountered, and we retain old sourceID entries until they are replaced
// by new data. fake entries are handled by the Source constructor.
void DebuggerShell::sourceParsed(ExecState* execState,
SourceProvider* sourceProvider,
int errorLineNumber,
const WTF::String& errorMessage) {
intptr_t sourceID = sourceProvider->asID();
Source source = Source(fromWTFString(sourceProvider->url()));
source.parseID = nextParseID_++;
source_map_[sourceID] = source;
// The URL map is used in setting breakpoints.
// Therefore, it's okay if we overwrite one entry with another.
// This might happen if we parse both http://a.tld/foo.js and http://b.tld/foo.js ,
// both of which would clobber the spot occupied by the filename foo.js .
// This means if you want to break on one or the other, you'll have to
// specify the full URL. The convenient mapping for filename won't be useful.
// But for the common case, filename is very very useful.
url_map_[source.url] = sourceID;
url_map_[source.filename] = sourceID;
parse_id_map_[source.parseID] = sourceID;
if (errorLineNumber >= 0) {
WTF::CString error = errorMessage.ascii();
WTF::CString f = WTF::String::format("Parse failed in %s on line %d: %s",
source.url.c_str(), errorLineNumber, error.data()).ascii();
dumpToTTY(f);
} else {
if (tracing_ || dumping_source_) {
WTF::CString f = WTF::String::format("Parsed %s", source.url.c_str()).ascii();
dumpToTTY(f);
}
if (dumping_source_) {
// NOTE: We only dump first 100 bytes of source. The point is to know
// more or less what's in it, not to see all 2MB of JavaScript.
// It's really most useful for seeing the source of evals full of JSON.
WTF::CString code = sourceProvider->source().ascii();
WTF::CString code_clipped(code.data(), code.length() > 100 ? 100 : code.length());
WTF::CString f = WTF::String::format("Source of %s[%d]: %s", source.url.c_str(), source.parseID, code_clipped.data()).ascii();
dumpToTTY(f);
}
}
}
void NSThermalEqResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid2::FunctionSpaceTools FST;
FST::scalarMultiplyDataData<ScalarT> (flux, ThermalCond, TGrad);
FST::integrate<ScalarT>(TResidual, flux, wGradBF, Intrepid2::COMP_CPP, false); // "false" overwrites
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
convection(cell,qp) = 0.0;
if (haveSource) convection(cell,qp) -= Source(cell,qp);
if (workset.transientTerms && enableTransient)
convection(cell,qp) += rho(cell,qp) * Cp(cell,qp) * Tdot(cell,qp);
if (haveFlow) {
for (std::size_t i=0; i < numDims; ++i) {
convection(cell,qp) +=
rho(cell,qp) * Cp(cell,qp) * V(cell,qp,i) * TGrad(cell,qp,i);
}
}
}
}
FST::integrate<ScalarT>(TResidual, convection, wBF, Intrepid2::COMP_CPP, true); // "true" sums into
if (haveSUPG) {
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t j=0; j < numDims; ++j) {
TResidual(cell,node) +=
rho(cell,qp) * Cp(cell,qp) * TauT(cell,qp) * convection(cell,qp) *
V(cell,qp,j) * wGradBF(cell,node,qp,j);
}
}
}
}
}
}
// If in immediate mode, quickly add a vertex.
// If building an action list, call pSource.
void PContextActions_t::Vertex(const pVec &pos, const long data)
{
if(PS->in_new_list) {
Source(1, PDPoint(pos));
return;
}
// Immediate mode. Quickly add the vertex.
pVec posB, siz, up, vel, rvel, col, alpha;
posB = PS->SrcSt.vertexB_tracks ? pos : PS->SrcSt.VertexB->Generate();
siz = PS->SrcSt.Size->Generate();
up = PS->SrcSt.Up->Generate();
vel = PS->SrcSt.Vel->Generate();
rvel = PS->SrcSt.RotVel->Generate();
col = PS->SrcSt.Color->Generate();
alpha = PS->SrcSt.Alpha->Generate();
float ag = PS->SrcSt.Age + pNRandf(PS->SrcSt.AgeSigma);
PS->PGroups[PS->pgroup_id].Add(pos, posB, up, vel, rvel, siz, col, alpha.x(), ag, PS->SrcSt.Mass, data);
}
