void StatusLineC::ToggleSecond(WC_TW)
{
// No second line when in full-screen mode
if (State == SL_FULLSCREEN)
{
return;
}
// If nothing is visible... make it so.
if (!Visible)
{
#ifdef WINCIT
Toggle(TW);
#else
Toggle();
#endif
}
else
{
int row = tw()logiRow, col = tw()logiCol;
if (State == SL_ONELINE)
{
// Make it two...
State = SL_TWOLINES;
scrollpos = conRows - Height();
if (row > scrollpos)
{
tw()scroll(row, row - scrollpos, cfg.attr);
row = scrollpos;
}
}
else
{
// Make it one...
State = SL_ONELINE;
scrollpos = conRows - Height();
tw()clearline(scrollpos, cfg.attr);
}
tw()position(row, col);
updateStatus = TRUE;
#ifdef WINCIT
Update(TW);
#else
Update();
#endif
}
}
Foam::tmp<Foam::scalarField> Foam::energyRegionCoupledFvPatchScalarField::
weights() const
{
const fvPatch& patch = regionCoupledPatch_.patch();
const scalarField deltas
(
patch.nf() & patch.delta()
);
const scalarField alphaDelta(kappa()/deltas);
const fvPatch& nbrPatch = regionCoupledPatch_.neighbFvPatch();
const energyRegionCoupledFvPatchScalarField& nbrField =
refCast
<
const energyRegionCoupledFvPatchScalarField
>
(
nbrPatch.lookupPatchField<volScalarField, scalar>("T")
);
// Needed in the first calculation of weights
nbrField.setMethod();
const scalarField nbrAlpha
(
regionCoupledPatch_.regionCoupledPatch().interpolate
(
nbrField.kappa()
)
);
const scalarField nbrDeltas
(
regionCoupledPatch_.regionCoupledPatch().interpolate
(
nbrPatch.nf() & nbrPatch.delta()
)
);
const scalarField nbrAlphaDelta(nbrAlpha/nbrDeltas);
tmp<scalarField> tw(new scalarField(deltas.size()));
scalarField& w = tw();
forAll(alphaDelta, faceI)
{
scalar di = alphaDelta[faceI];
scalar dni = nbrAlphaDelta[faceI];
w[faceI] = di/(di + dni);
}
void KisTransformProcessingVisitor::transformClones(KisLayer *layer, KisUndoAdapter *undoAdapter)
{
QList<KisCloneLayerWSP> clones = layer->registeredClones();
foreach(KisCloneLayerSP clone, clones) {
// we have just casted an object from a weak pointer,
// so check validity first
if(!clone) continue;
KisTransformWorker tw(clone->projection(), m_sx, m_sy, m_shearx, m_sheary,
m_shearOrigin.x(), m_shearOrigin.y(),
m_angle, m_tx, m_ty, 0,
m_filter);
QTransform trans = tw.transform();
QTransform offsetTrans = QTransform::fromTranslate(clone->x(), clone->y());
QTransform newTrans = trans.inverted() * offsetTrans * trans;
QPoint oldPos(clone->x(), clone->y());
QPoint newPos(newTrans.dx(), newTrans.dy());
KUndo2Command *command = new KisNodeMoveCommand2(clone, oldPos, newPos, undoAdapter);
undoAdapter->addCommand(command);
}
}
int main( int argc, char **argv )
{
QApplication a( argc, argv );
TW tw( &a );
tw.show();
// tw.testPixMapLines(1000);
// tw.testPixMapLines(100);
// tw.testPixMapLines(10);
// tw.testPixMapFill( 1000 );
// tw.testDrawImage();
// tw.testDrawPixmap();
tw.testPlotBench();
tw.testPlotBench(true);
tw.testPlotBench();
tw.testPlotBench(true);
return( 0 );
return a.exec();
}
const TransactionWeight* operator() (const DataStruct& ds)
{
// request latest prices
Matrix price = ds.price(ltaverage_window);
// std::cout << "(" << price.rows() << "x" << price.cols() << ")" << std::endl;
t1 = t2;
pos_t1 = pos_t2;
ltaverage_t1 = ltaverage_t2;
staverage_t1 = ltaverage_t2;
// compute averages
t2 = ds.time;
ltaverage_t2 = price.colwise().mean();
staverage_t2 = price.bottomRows(staverage_window).colwise().mean();
// new signal
pos_t2 = (ltaverage_t2.array() > staverage_t2.array()).cast<double>();
if (set){
signal = signal + (pos_t2 - pos_t1).transpose();
weight() = signal / signal.sum();
// weight_type() = TotalPercentage;
}
set = true;
return &tw();
}
int main( int argc , char** argv ){
if(argc!=2){
std::cerr << "usage: ./main [video name] || [picture name] || [camera]\n";
exit(-4);
}
const int bufferLength = 30;
cv::Mat** buffer = new cv::Mat*[bufferLength];
for(int i=0;i<bufferLength;i++){
buffer[i] = new cv::Mat(720,680,CV_8UC3,0.0);
}
Queue<cv::Mat*> q1;
Queue<SegmentedTableType> q2;
Queue<cv::Mat*> q3;
Reader<cv::Mat*> reader(q1,buffer,argv[1],bufferLength);
Table<cv::Mat*,SegmentedTableType> tableSegmenter(q1,q2);
BallSegmenter<SegmentedTableType,cv::Mat*> ballSegmenter(q2,q3);
Writer<cv::Mat*> writer(q3);
std::thread tr(reader);
std::thread tableSegmenterThread(tableSegmenter);
std::thread ballSegmenterThread(ballSegmenter);
std::thread tw(writer);
tr.join();
tableSegmenterThread.join();
ballSegmenterThread.join();
tw.join();
return 0;
}
void KisTransformWorkerTest::testIdentity()
{
TestUtil::TestProgressBar bar;
KoProgressUpdater pu(&bar);
KoUpdaterPtr updater = pu.startSubtask();
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->convertFromQImage(image, "");
KisFilterStrategy * filter = new KisBoxFilterStrategy();
KisTransaction t("test", dev);
KisTransformWorker tw(dev, 1.0, 1.0,
0.0, 0.0,
0.0, 0.0,
0.0,
0, 0, updater, filter, true);
tw.run();
t.end();
QRect rc = dev->exactBounds();
QVERIFY(rc.width() ==image.width());
QVERIFY(rc.height() == image.height());
QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
QPoint errpoint;
if (!TestUtil::compareQImages(errpoint, image, result)) {
image.save("test_identity_source.png");
result.save("test_identity_result.png");
QFAIL(QString("Failed to apply identity transformation to image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toAscii());
}
}
int main()
{
PyImport_AppendInittab("testprop", [](){
auto module = new TestProp();
return module->module().ptr();
});
init_python_api({&CyPy_Server::init,
&CyPy_Rules::init,
&CyPy_Atlas::init,
&CyPy_Physics::init,
&CyPy_Common::init});
Ref<Entity> wrld(new Entity("0", 0));
TestWorld tw(wrld);
run_python_string("from server import *");
run_python_string("import testprop");
run_python_string("t=Thing('1')");
run_python_string("t.props.line == None");
run_python_string("t.props.statistics == None");
run_python_string("t.props.terrain == None");
run_python_string("testprop.add_properties(t)");
run_python_string("t.props.line");
run_python_string("t.props.statistics");
run_python_string("t.props.terrain");
shutdown_python_api();
return 0;
}
void fade_colors(void)
{
if(lamp->have_winner) {
static uint32_t ctr = 0;
lamp->red = tw(23, ctr);
lamp->green = tw(29, ctr);
lamp->blue = tw(37, ctr);
lamp->white = 0;
ctr++;
} else {
int const p = 970;
int const p_div = 1000;
lamp->red = lamp->red * p / p_div;
lamp->green = lamp->green * p / p_div;
lamp->blue = lamp->blue * p / p_div;
lamp->white = lamp->white * p / p_div;
}
}
static void threadFunc(int threadNum)
{
TimeWaster tw(threadNum);
for (int i = 0; i < 10000000; i++)
{
mint_fetch_add_${TEST_INT_BITSIZE}_relaxed(&g_sharedInt, 1);
tw.wasteRandomCycles();
}
}
void KisTransformProcessingVisitor::transformPaintDevice(KisPaintDeviceSP device, KisUndoAdapter *adapter, const ProgressHelper &helper)
{
KisTransaction transaction(i18n("Transform Node"), device);
KisTransformWorker tw(device, m_sx, m_sy, m_shearx, m_sheary,
m_shearOrigin.x(), m_shearOrigin.y(),
m_angle, m_tx, m_ty, helper.updater(),
m_filter);
tw.run();
transaction.commit(adapter);
}
void emit_definitions( const wrSourceFile& srcFile )
{
OSFileName fileName = GetDestFileName( srcFile.name, WR_SOURCE_FILE_EXT );
FileWriter outputStream( fileName.ToChars() );
mxTextWriter tw( &outputStream );
tw << MXC("/* This ALWAYS GENERATED file contains the implementation for the interfaces */\n")
<< MXC("/* File created by HLSL wrapper generator version ") << WR_VERSION_STRING << MXC(" ") << GetCurrentDateTimeString() << MXC(" */\n")
;
tw << MXC("namespace ") << WR_NAMESPACE << MXC("\n{\n");
// Initialization order:
// 1) Render targets
// 2) State objects
// 3) Shaders
// 4) Input layouts
// 5) Everything else
/*
TList< const wrRenderTarget* > sortedRTs;
for( UINT iRenderTarget = 0;
iRenderTarget < srcFile.renderTargets.Num();
iRenderTarget++ )
{
sortedRTs.Add( &srcFile.renderTargets[ iRenderTarget ] );
}
// Sort render targets by size.
InsertionSort< const wrRenderTarget*, wrRenderTarget >( sortedRTs.ToPtr(), 0, sortedRTs.Num()-1 );
*/
Emit_initialize_render_targets( srcFile.renderTargets, tw );
emit_line_separator_comment( tw );
Emit_initialize_sampler_states( srcFile.samplerStates, tw );
emit_line_separator_comment( tw );
emit_initialize_depth_stencil_states( srcFile.depthStencilStates, tw );
tw << MXC("void SetupGPUResources( const SHADER_LIB_CREATE& creationParams )\n{\n")
;
tw << MXC("\n}//SetupGPUResources\n")
<< MXC("SetupRenderTargets( creationParams );\n")
<< MXC("SetupSamplerStates( creationParams );\n")
<< MXC("SetupDepthStencilStates( creationParams );\n")
<< MXC("SetupRasterizerStates( creationParams );\n")
<< MXC("SetupBlendStates( creationParams );\n")
;
tw << MXC("\n}//SetupGPUResources\n")
;
tw << MXC("\n}//namespace ") << WR_NAMESPACE << MXC("\n");
}
void KisTransformWorkerTest::testXScaleDown()
{
TestUtil::TestProgressBar bar;
KoProgressUpdater pu(&bar);
KoUpdaterPtr updater = pu.startSubtask();
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->convertFromQImage(image, "");
KisFilterStrategy * filter = new KisBoxFilterStrategy();
KisTransaction t("test", dev);
KisTransformWorker tw(dev, 0.123, 1.0,
0.0, 0.0,
0.0, 0.0,
0.0,
0, 0, updater, filter, true);
tw.run();
t.end();
QRect rc = dev->exactBounds();
QVERIFY(rc.width() == qRound(image.width() * 0.123));
QVERIFY(rc.height() == image.height() - 1); // the height is reduced by 1 because in the source image
// at the bottom line most pixels (except 1 or 2) are
// entirely transparent.
// when scaling down the image by ~ 1/10, the few non-tranparent
// pixels disappear when "mixed" with the transparent ones
// around
// KisTransaction t2("test", dev);
// KisRandomAccessorSP ac = dev->createRandomAccessorNG(rc.x(), rc.y());
// for(int x = rc.x(); x < rc.width(); ++x) {
// for(int y = rc.y(); y < rc.height(); ++y) {
// ac->moveTo(x, y);
// cs->setOpacity(ac->rawData(), 0.5, 1);
// }
// }
// t2.end();
QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
QPoint errpoint;
image.load(QString(FILES_DATA_DIR) + QDir::separator() + "scaledownx_result.png");
if (!TestUtil::compareQImages(errpoint, image, result)) {
image.save("scaledownx_source.png");
result.save("scaledownx_result.png");
QFAIL(QString("Failed to scale down the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toAscii());
}
}
void KisTransformWorkerTest::testCreation()
{
TestUtil::TestProgressBar bar;
KoProgressUpdater pu(&bar);
KoUpdaterPtr updater = pu.startSubtask();
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisFilterStrategy * filter = new KisBoxFilterStrategy();
KisPaintDeviceSP dev = new KisPaintDevice(cs);
KisTransformWorker tw(dev, 1.0, 1.0,
1.0, 1.0,
0.0, 0.0,
1.5,
0, 0, updater, filter, true);
}
void KisTransformProcessingVisitor::visit(KisExternalLayer *layer, KisUndoAdapter *undoAdapter)
{
KisTransformWorker tw(layer->projection(), m_sx, m_sy, m_shearx, m_sheary,
m_shearOrigin.x(), m_shearOrigin.y(),
m_angle, m_tx, m_ty, 0,
m_filter);
KUndo2Command* command = layer->transform(tw.transform() * m_shapesCorrection);
if(command) {
undoAdapter->addCommand(command);
}
transformClones(layer, undoAdapter);
}
void StatusLineC::Toggle(WC_TW)
{
int row = tw()logiRow, col = tw()logiCol;
if (Visible)
{
Visible = FALSE;
for (int i = scrollpos + 1; i <= conRows; i++)
{
tw()clearline(i, cfg.attr);
}
scrollpos = conRows;
}
else
{
Visible = TRUE;
scrollpos = conRows - Height();
if (row > scrollpos)
{
tw()scroll(row, row - scrollpos, cfg.attr);
row = scrollpos;
}
}
tw()position(row, col);
updateStatus = TRUE;
#ifdef WINCIT
Update(TW);
#else
Update();
#endif
}
void KisTransformWorkerTest::testYShear()
{
TestUtil::TestProgressBar bar;
KoProgressUpdater pu(&bar);
KoUpdaterPtr updater = pu.startSubtask();
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
KisPaintDeviceSP dev = new KisPaintDevice(cs);
dev->convertFromQImage(image, "");
KisFilterStrategy * filter = new KisBoxFilterStrategy();
KisTransaction t("test", dev);
KisTransformWorker tw(dev, 1.0, 1.0,
0.0, 1.0,
300., 200.,
0.0,
0, 0, updater, filter, true);
tw.run();
t.end();
QRect rc = dev->exactBounds();
QVERIFY(rc.width() == image.width());
QVERIFY(rc.height() == 959);
// KisTransaction t2("test", dev);
// KisRandomAccessorSP ac = dev->createRandomAccessorNG(rc.x(), rc.y());
// for(int x = rc.x(); x < rc.width(); ++x) {
// for(int y = rc.y(); y < rc.height(); ++y) {
// ac->moveTo(x, y);
// cs->setOpacity(ac->rawData(), 0.5, 1);
// }
// }
// t2.end();
QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
QPoint errpoint;
image.load(QString(FILES_DATA_DIR) + QDir::separator() + "sheary_result.png");
if (!TestUtil::compareQImages(errpoint, image, result)) {
image.save("sheary_source.png");
result.save("sheary_result.png");
QFAIL(QString("Failed to shear the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toAscii());
}
}
void
TaskWaypointTest::Run()
{
GeoPoint gp(Angle::Degrees(fixed(20)), Angle::Degrees(fixed(50)));
Waypoint wp(gp);
wp.name = _T("Test");
wp.altitude = fixed(42);
DummyTaskWaypoint tw(TaskPoint::AST, wp);
const Waypoint &wp2 = tw.GetWaypoint();
ok1(wp2.name == _T("Test"));
ok1(equals(tw.GetBaseElevation(), 42));
ok1(equals(tw.GetBaseElevation(), wp2.altitude));
ok1(equals(wp2.location, gp));
ok1(equals(tw.GetLocation(), gp));
}
int main()
{
init_python_api("cb44c6cc-64fa-46c4-83d1-f43c6a2bb56c");
Entity wrld("0", 0);
TestWorld tw(wrld);
run_python_string("from server import World");
run_python_string("w=World()");
run_python_string("w.get_time()");
run_python_string("w.get_object('0')");
run_python_string("w.get_object('1')");
expect_python_error("w.get_object(1)", PyExc_TypeError);
run_python_string("w == World()");
shutdown_python_api();
return 0;
}
void KisTransformProcessingVisitor::transformSelection(KisSelectionSP selection, KisUndoAdapter *adapter, const ProgressHelper &helper)
{
if(selection->hasPixelSelection()) {
transformPaintDevice(selection->pixelSelection(), adapter, helper);
}
if (selection->hasShapeSelection()) {
KisTransformWorker tw(selection->projection(), m_sx, m_sy, m_shearx, m_sheary,
m_shearOrigin.x(), m_shearOrigin.y(),
m_angle, m_tx, m_ty, 0,
m_filter);
KUndo2Command* command =
selection->shapeSelection()->transform(tw.transform() * m_shapesCorrection);
if (command) {
adapter->addCommand(command);
}
}
selection->updateProjection();
}
void emit_declarations( const wrSourceFile& srcFile )
{
OSFileName fileName = GetDestFileName( srcFile.name, WR_HEADER_FILE_EXT );
FileWriter outputStream( fileName.ToChars() );
mxTextWriter tw( &outputStream );
tw << MXC("/* This ALWAYS GENERATED file contains the definitions for the interfaces */\n")
<< MXC("/* File created by HLSL wrapper generator version ") << WR_VERSION_STRING << MXC(" ") << GetCurrentDateTimeString() << MXC(" */\n")
;
tw << MXC("namespace ") << WR_NAMESPACE << MXC("\n{\n");
tw << MXC("// Render targets\n");
emit_render_target_declarations( srcFile.renderTargets, tw );
tw << MXC("// Sampler states\n");
emit_sampler_state_declarations( srcFile.samplerStates, tw );
tw << MXC("// Depth-stencil states\n");
emit_depth_stencil_states_declarations( srcFile.depthStencilStates, tw );
tw << MXC("\n}//namespace ") << WR_NAMESPACE << MXC("\n");
}
int main()
{
init_python_api("b513b7b1-b0d8-4495-b3f0-54c2ef3f27f6");
setup_test_functions();
Entity wrld("0", 0);
TestWorld tw(wrld);
run_python_string("from server import *");
run_python_string("import testprop");
run_python_string("t=Thing('1')");
expect_python_error("t.line", PyExc_AttributeError);
expect_python_error("t.statistics", PyExc_AttributeError);
expect_python_error("t.terrain", PyExc_AttributeError);
run_python_string("testprop.add_properties(t)");
run_python_string("t.line");
run_python_string("t.statistics");
run_python_string("t.terrain");
shutdown_python_api();
return 0;
}
Bool OutputControl::CheckInput(Bool Pause)
#endif
{
if (User.Continuous)
{
Pause = FALSE;
}
if (User.ControlD)
{
tw()KBReady(); // for screenblanker
SetOutFlag(OUTSKIP); // Auto-Stop everything
return (TRUE);
}
// Cannot abort IMPERVIOUS
if (User.GetOutFlag() == IMPERVIOUS)
{
tw()KBReady(); // for screenblanker
return (FALSE);
}
// Carrier loss and not on Console
if (!tw()HaveConnectionToUser())
{
SetOutFlag(OUTSKIP);
return (TRUE);
}
Bool toReturn = FALSE;
// Check for keypress
if (tw()BBSCharReady() || Pause)
{
int c;
if (!Pause)
{
c = toupper(tw()iCharNE());
}
if (Pause || c == 'P' || c == 19) // P or ^S (XOFF) - Pause
{
if (Pause)
{
char Buffer[80];
tw()CurrentUser->GetMorePrompt(Buffer, sizeof(Buffer));
if (!tw()outSpeech(TRUE, tw()loggedIn ? Buffer : cfg.moreprompt))
{
tw()putWord((uchar *) (tw()loggedIn ? Buffer : cfg.moreprompt));
}
}
do
{
// wait to resume
c = toupper(tw()iCharNE());
} while (!tw()CurrentUser->IsPUnPauses() && (c == 'P' || c == 19));
if (Pause)
{
char Buffer[80];
int i, backspace = strlen(tw()loggedIn ?
tw()CurrentUser->GetMorePrompt(Buffer, sizeof(Buffer)) : cfg.moreprompt);
for (i = 0; i < backspace; i++)
{
tw()doBS();
}
}
}
if (User.GetOutFlag() == NOSTOP)
{
return (FALSE);
}
const Bool WasFormatting = Formatting;
Formatting = TRUE;
switch (c)
{
case CTRL_D:
{
User.ControlD = TRUE;
SetOutFlag(OUTSKIP);
toReturn = TRUE;
break;
}
case '9':
{
if (tw()hitSix)
{
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (!tw()outSpeech(TRUE, getmsg(69)))
{
tw()putWord((uchar *) getmsg(69));
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
tw()doCR();
}
break;
}
case 'J': // jump paragraph
{
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (!tw()outSpeech(TRUE, getmsg(547)))
{
tw()putWord((uchar *) getmsg(547));
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
tw()doCR();
SetOutFlag(OUTPARAGRAPH);
break;
}
case 'K': // kill
{
if (User.CanK)
{
tw()MRO.DotoMessage = PULL_IT;
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (!tw()outSpeech(TRUE, getmsg(546)))
{
tw()putWord((uchar *) getmsg(546));
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
SetOutFlag(OUTNEXT);
toReturn = TRUE;
}
break;
}
case 'M': // mark
{
if (User.CanM)
{
tw()MRO.DotoMessage = MARK_IT;
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (!tw()outSpeech(TRUE, getmsg(543)))
{
tw()putWord((uchar *) getmsg(543));
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
SetOutFlag(OUTNEXT);
toReturn = TRUE;
}
break;
}
case '*': // censor
{
if (User.CanStar)
{
tw()MRO.DotoMessage = CENSOR_IT;
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (!tw()outSpeech(TRUE, getmsg(538)))
{
tw()putWord((uchar *) getmsg(538));
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
SetOutFlag(OUTNEXT);
toReturn = TRUE;
}
break;
}
case 'N': // next
{
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (!tw()outSpeech(TRUE, getmsg(537)))
{
tw()putWord((uchar *) getmsg(537));
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
tw()doCR();
SetOutFlag(OUTNEXT);
toReturn = TRUE;
break;
}
case 'S': // stop
{
tw()numLines = 0; // Don't pause for stop!
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (!tw()outSpeech(TRUE, getmsg(528)))
{
tw()putWord((uchar *) getmsg(528));
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
tw()doCR();
SetOutFlag(OUTSKIP);
toReturn = TRUE;
break;
}
case 'C': // continuous
{
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (!User.Continuous)
{
if (!tw()outSpeech(TRUE, getmsg(527)))
{
tw()putWord((uchar *) getmsg(527));
}
}
else
{
if (!tw()outSpeech(TRUE, getmsg(526)))
{
tw()putWord((uchar *) getmsg(526));
}
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
User.Continuous = !User.Continuous;
tw()doCR();
break;
}
case 'R':
{
if (User.CanR)
{
tw()MRO.DotoMessage = REVERSE_READ;
SetOutFlag(OUTNEXT);
}
break;
}
case 'V':
{
tw()MRO.Verbose = !tw()MRO.Verbose;
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (tw()MRO.Verbose)
{
if (!tw()outSpeech(TRUE, getmsg(524)))
{
tw()putWord((uchar *) getmsg(524));
}
}
else
{
if (!tw()outSpeech(TRUE, getmsg(519)))
{
tw()putWord((uchar *) getmsg(519));
}
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
tw()doCR();
break;
}
case '!':
{
if (User.CanBang)
{
tw()MRO.Headerscan = !tw()MRO.Headerscan;
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (tw()MRO.Headerscan)
{
if (!tw()outSpeech(TRUE, getmsg(517)))
{
tw()putWord((uchar *) getmsg(517));
}
}
else
{
if (!tw()outSpeech(TRUE, getmsg(511)))
{
tw()putWord((uchar *) getmsg(511));
}
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
tw()doCR();
}
break;
}
case '@':
{
if (User.CanAt)
{
tw()MRO.DotoMessage = REPLY;
tw()doCR();
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(327));
tw()termCap(TERM_BOLD);
if (!tw()outSpeech(TRUE, getmsg(470)))
{
tw()putWord((uchar *) getmsg(470));
}
tw()termCap(TERM_NORMAL);
tw()putWord((const uchar *) getmsg(326));
tw()doCR();
}
break;
}
}
Formatting = WasFormatting;
if (c == '6')
{
tw()hitSix = TRUE;
}
else
{
tw()hitSix = FALSE;
}
}
return (toReturn);
}
/*static*/ bool ReflectionInfo::WriteDefinitions()
{
uint32_t numProblems = 0;
const ReflectionInfo * ri = s_FirstReflectionInfo;
for ( ; ri != nullptr; ri = ri->m_Next )
{
// ignore abstract classes
if ( ri->IsAbstract() )
{
continue;
}
// Serialize a default instance to a MemoryStream
MemoryStream ms;
{
// Create and serialize default instance
if ( ri->IsObject() )
{
RefObject * object = ri->CreateObject();
{
TextWriter tw( ms );
tw.Write( object );
}
FDELETE( object );
}
else
{
ASSERT( ri->IsStruct() )
Struct * str = ri->CreateStruct();
{
TextWriter tw( ms );
tw.Write( str, ri );
}
FDELETE( str );
}
}
AStackString<> fileName;
fileName.Format( "..\\Data\\Reflection\\.Definitions\\%s.definition", ri->GetTypeName() );
// avoid writing file if not changed
// Try to open existing file
FileStream f;
if ( f.Open( fileName.Get(), FileStream::READ_ONLY ) )
{
// read content
const uint64_t fileSize = f.GetFileSize();
if ( fileSize == ms.GetSize() )
{
AutoPtr< char > mem( (char *)Alloc( (size_t)fileSize ) );
if ( f.Read( mem.Get(), (size_t)fileSize ) == fileSize )
{
if ( memcmp( mem.Get(), ms.GetData(), (size_t)fileSize ) == 0 )
{
continue; // definition has not changed
}
}
}
f.Close();
}
// Definition changed - try to save it
int result = 0;
AutoPtr< char > memOut;
AutoPtr< char > memErr;
uint32_t memOutSize;
uint32_t memErrSize;
// existing definition?
if ( FileIO::FileExists( fileName.Get() ) )
{
// existing - need to open for edit?
if ( FileIO::GetReadOnly( fileName ) )
{
AStackString<> args( "edit " );
args += fileName;
Process p;
if ( p.Spawn( "p4", args.Get(), nullptr, nullptr ) )
{
p.ReadAllData( memOut, &memOutSize, memErr, &memErrSize );
result = p.WaitForExit();
}
}
}
else
{
// new - open for add
AStackString<> args( "add " );
args += fileName;
Process p;
if ( p.Spawn( "p4", args.Get(), nullptr, nullptr ) )
{
p.ReadAllData( memOut, &memOutSize, memErr, &memErrSize );
result = p.WaitForExit();
}
}
if ( result == 0 )
{
if ( f.Open( fileName.Get(), FileStream::WRITE_ONLY ) )
{
if ( f.Write( ms.GetData(), ms.GetSize() ) == ms.GetSize() )
{
continue; // all ok!
}
}
}
// PROBLEM!
OUTPUT( "Error writing definition '%s'\n", fileName.Get() );
if ( result != 0 )
{
OUTPUT( "Perforce error: %s\n", memErr.Get() );
}
++numProblems;
}
if ( numProblems > 0 )
{
FATALERROR( "Problem writing %u definition(s).\n", numProblems );
}
return ( numProblems == 0 );
}
static void s_TestGMT(int idx)
{
// Write time in timezone format
{{
CTime::SetFormat("M/D/Y h:m:s Z");
CTime t1(2001, 3, 12, 11, 22, 33, 999, CTime::eGmt);
assert(t1.AsString() == "03/12/2001 11:22:33 GMT");
CTime t2(2001, 3, 12, 11, 22, 33, 999, CTime::eLocal);
assert(t2.AsString() == "03/12/2001 11:22:33 ");
}}
// Process timezone string
{{
CTime t;
t.SetFormat("M/D/Y h:m:s Z");
t="03/12/2001 11:22:33 GMT";
assert(t.AsString() == "03/12/2001 11:22:33 GMT");
t="03/12/2001 11:22:33 ";
assert(t.AsString() == "03/12/2001 11:22:33 ");
}}
// Day of week
{{
CTime t(2001, 4, 1);
t.SetFormat("M/D/Y h:m:s w");
int i;
for (i=0; t<=CTime(2001, 4, 10); t.AddDay(),i++) {
assert(t.DayOfWeek() == (i%7));
}
}}
// Test GetTimeT
{{
time_t timer = time(0);
CTime tgmt(CTime::eCurrent, CTime::eGmt, CTime::eTZPrecisionDefault);
CTime tloc(CTime::eCurrent, CTime::eLocal, CTime::eTZPrecisionDefault);
CTime t(timer);
// Set the same time to all time objects
tgmt.SetTimeT(timer);
tloc.SetTimeT(timer);
assert(timer == t.GetTimeT());
assert(timer == tgmt.GetTimeT());
// On the day of changing to summer/winter time, the local time
// converted to GMT may differ from the value returned by time(0),
// because in the common case API don't know if DST is in effect for
// specified local time or not (see mktime()).
time_t l_ = tloc.GetTimeT();
if (timer != l_ ) {
if ( abs((int)(timer - l_)) > 3600 )
assert(timer == l_);
}
}}
// Test TimeZoneOffset (1) -- EST timezone only
{{
CTime tw(2001, 1, 1, 12);
CTime ts(2001, 6, 1, 12);
assert(tw.TimeZoneOffset() / 3600 == -5);
assert(ts.TimeZoneOffset()/3600 == -4);
}}
// Test TimeZoneOffset (2) -- EST timezone only
{{
CTime tw(2001, 6, 1, 12);
CTime ts(2002, 1, 1, 12);
assert(tw.TimeZoneOffset() / 3600 == -4);
assert(ts.TimeZoneOffset() / 3600 == -5);
}}
// Test AdjustTime
{{
CTime::SetFormat("M/D/Y h:m:s");
CTime t("03/11/2007 01:01:00");
CTime tn;
t.SetTimeZonePrecision(CTime::eTZPrecisionDefault);
// GMT
t.SetTimeZone(CTime::eGmt);
tn = t;
tn.AddDay(5);
assert(tn.AsString() == "03/16/2007 01:01:00");
tn = t;
tn.AddDay(40);
assert(tn.AsString() == "04/20/2007 01:01:00");
// Local eNone
t.SetTimeZone(CTime::eLocal);
t.SetTimeZonePrecision(CTime::eNone);
tn = t;
tn.AddDay(5);
assert(tn.AsString() == "03/16/2007 01:01:00");
tn = t;
tn.AddDay(40);
assert(tn.AsString() == "04/20/2007 01:01:00");
//Local eMonth
t.SetTimeZonePrecision(CTime::eMonth);
tn = t;
tn.AddDay(5);
assert(tn.AsString() == "03/16/2007 01:01:00");
tn = t;
tn.AddMonth(-1);
assert(tn.AsString() == "02/11/2007 01:01:00");
tn = t;
tn.AddMonth(+1);
assert(tn.AsString() == "04/11/2007 02:01:00");
// Local eDay
t.SetTimeZonePrecision(CTime::eDay);
tn = t;
tn.AddDay(-1);
assert(tn.AsString() == "03/10/2007 01:01:00");
tn.AddDay();
assert(tn.AsString() == "03/11/2007 01:01:00");
tn = t;
tn.AddDay();
assert(tn.AsString() == "03/12/2007 02:01:00");
// Local eHour
t.SetTimeZonePrecision(CTime::eHour);
tn = t;
tn.AddHour(-3);
CTime te = t;
te.AddHour(3);
assert(tn.AsString() == "03/10/2007 22:01:00");
assert(te.AsString() == "03/11/2007 05:01:00");
CTime th = tn;
th.AddHour(49);
assert(th.AsString() == "03/13/2007 00:01:00");
tn = "11/04/2007 00:01:00";
tn.SetTimeZonePrecision(CTime::eHour);
te = tn;
tn.AddHour(-3);
te.AddHour(9);
assert(tn.AsString() == "11/03/2007 21:01:00");
assert(te.AsString() == "11/04/2007 08:01:00");
th = tn;
th.AddHour(49);
assert(th.AsString() == "11/05/2007 21:01:00");
tn = "11/04/2007 09:01:00";
tn.SetTimeZonePrecision(CTime::eHour);
te = tn;
tn.AddHour(-10);
te.AddHour(+10);
assert(tn.AsString() == "11/04/2007 00:01:00");
assert(te.AsString() == "11/04/2007 19:01:00");
}}
}
int main()
{
// We have to use the TestWorld class, as it implements the functions
// missing from BaseWorld interface.
{
// Test constructor
Entity wrld("1", 1);
TestWorld tw(wrld);
}
{
// Test destructor
Entity wrld("1", 1);
BaseWorld * tw = new TestWorld(wrld);
delete tw;
}
{
// Test constructor sets singleton pointer
Entity wrld("1", 1);
TestWorld tw(wrld);
assert(&BaseWorld::instance() == &tw);
}
{
// Test constructor installs reference to world entity
Entity wrld("1", 1);
TestWorld tw(wrld);
assert(&tw.m_gameWorld == &wrld);
}
{
// Test retrieving non existant entity by string ID is ok
Entity wrld("1", 1);
TestWorld tw(wrld);
assert(tw.getEntity("2") == 0);
}
{
// Test retrieving existant entity by string ID is ok
Entity wrld("1", 1);
TestWorld tw(wrld);
Entity * tc = new Entity("2", 2);
tw.addEntity(tc);
assert(tw.getEntity("2") == tc);
}
{
// Test retrieving existant entity by integer ID is ok
Entity wrld("1", 1);
TestWorld tw(wrld);
Entity * tc = new Entity("2", 2);
tw.addEntity(tc);
assert(tw.getEntity(2) == tc);
}
{
// Test retrieving non existant entity by integer ID is ok
Entity wrld("1", 1);
TestWorld tw(wrld);
assert(tw.getEntity(2) == 0);
}
{
// Test retrieving reference to all entities is okay and empty
Entity wrld("1", 1);
TestWorld tw(wrld);
assert(tw.getEntities().size() == 1);
}
{
// Test getting the time
Entity wrld("1", 1);
TestWorld tw(wrld);
tw.getTime();
}
{
// Test getting the uptime
Entity wrld("1", 1);
TestWorld tw(wrld);
tw.upTime();
}
{
// Test connecting to the dispatch signal
Entity wrld("1", 1);
TestWorld tw(wrld);
tw.Dispatching.connect(sigc::ptr_fun(&test_function));
}
return 0;
}
inline void MacroAssembler::trap_range_check_ge(Register a, Register b) {
tw (traptoEqual | traptoGreaterThanUnsigned, a/*reg a*/, b/*reg b*/);
}
// SIGTRAP-based range checks for arrays.
inline void MacroAssembler::trap_range_check_l(Register a, Register b) {
tw (traptoLessThanUnsigned, a/*reg a*/, b/*reg b*/);
}
static int crypt(struct blkcipher_desc *d,
struct blkcipher_walk *w, struct priv *ctx,
void (*tw)(struct crypto_tfm *, u8 *, const u8 *),
void (*fn)(struct crypto_tfm *, u8 *, const u8 *))
{
int err;
unsigned int avail;
const int bs = XTS_BLOCK_SIZE;
struct sinfo s = {
.tfm = crypto_cipher_tfm(ctx->child),
.fn = fn
};
u8 *wsrc;
u8 *wdst;
err = blkcipher_walk_virt(d, w);
if (!w->nbytes)
return err;
s.t = (be128 *)w->iv;
avail = w->nbytes;
wsrc = w->src.virt.addr;
wdst = w->dst.virt.addr;
tw(crypto_cipher_tfm(ctx->tweak), w->iv, w->iv);
goto first;
for (;;) {
do {
gf128mul_x_ble(s.t, s.t);
first:
xts_round(&s, wdst, wsrc);
wsrc += bs;
wdst += bs;
} while ((avail -= bs) >= bs);
err = blkcipher_walk_done(d, w, avail);
if (!w->nbytes)
break;
avail = w->nbytes;
wsrc = w->src.virt.addr;
wdst = w->dst.virt.addr;
}
return err;
}
static int encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
struct scatterlist *src, unsigned int nbytes)
{
struct priv *ctx = crypto_blkcipher_ctx(desc->tfm);
struct blkcipher_walk w;
blkcipher_walk_init(&w, dst, src, nbytes);
return crypt(desc, &w, ctx, crypto_cipher_alg(ctx->tweak)->cia_encrypt,
crypto_cipher_alg(ctx->child)->cia_encrypt);
}
static int decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
struct scatterlist *src, unsigned int nbytes)
{
struct priv *ctx = crypto_blkcipher_ctx(desc->tfm);
struct blkcipher_walk w;
blkcipher_walk_init(&w, dst, src, nbytes);
return crypt(desc, &w, ctx, crypto_cipher_alg(ctx->tweak)->cia_encrypt,
crypto_cipher_alg(ctx->child)->cia_decrypt);
}
int xts_crypt(struct blkcipher_desc *desc, struct scatterlist *sdst,
struct scatterlist *ssrc, unsigned int nbytes,
struct xts_crypt_req *req)
{
const unsigned int bsize = XTS_BLOCK_SIZE;
const unsigned int max_blks = req->tbuflen / bsize;
struct blkcipher_walk walk={};
unsigned int nblocks;
be128 *src, *dst, *t;
be128 *t_buf = req->tbuf;
int err, i;
BUG_ON(max_blks < 1);
blkcipher_walk_init(&walk, sdst, ssrc, nbytes);
err = blkcipher_walk_virt(desc, &walk);
nbytes = walk.nbytes;
if (!nbytes)
return err;
nblocks = min(nbytes / bsize, max_blks);
src = (be128 *)walk.src.virt.addr;
dst = (be128 *)walk.dst.virt.addr;
req->tweak_fn(req->tweak_ctx, (u8 *)&t_buf[0], walk.iv);
i = 0;
goto first;
for (;;) {
do {
for (i = 0; i < nblocks; i++) {
gf128mul_x_ble(&t_buf[i], t);
first:
t = &t_buf[i];
be128_xor(dst + i, t, src + i);
}
req->crypt_fn(req->crypt_ctx, (u8 *)dst,
nblocks * bsize);
for (i = 0; i < nblocks; i++)
be128_xor(dst + i, dst + i, &t_buf[i]);
src += nblocks;
dst += nblocks;
nbytes -= nblocks * bsize;
nblocks = min(nbytes / bsize, max_blks);
} while (nblocks > 0);
*(be128 *)walk.iv = *t;
err = blkcipher_walk_done(desc, &walk, nbytes);
nbytes = walk.nbytes;
if (!nbytes)
break;
nblocks = min(nbytes / bsize, max_blks);
src = (be128 *)walk.src.virt.addr;
dst = (be128 *)walk.dst.virt.addr;
}
return err;
}
EXPORT_SYMBOL_GPL(xts_crypt);
static int init_tfm(struct crypto_tfm *tfm)
{
struct crypto_cipher *cipher;
struct crypto_instance *inst = (void *)tfm->__crt_alg;
struct crypto_spawn *spawn = crypto_instance_ctx(inst);
struct priv *ctx = crypto_tfm_ctx(tfm);
u32 *flags = &tfm->crt_flags;
cipher = crypto_spawn_cipher(spawn);
if (IS_ERR(cipher))
return PTR_ERR(cipher);
if (crypto_cipher_blocksize(cipher) != XTS_BLOCK_SIZE) {
*flags |= CRYPTO_TFM_RES_BAD_BLOCK_LEN;
crypto_free_cipher(cipher);
return -EINVAL;
}
ctx->child = cipher;
cipher = crypto_spawn_cipher(spawn);
if (IS_ERR(cipher)) {
crypto_free_cipher(ctx->child);
return PTR_ERR(cipher);
}
if (crypto_cipher_blocksize(cipher) != XTS_BLOCK_SIZE) {
crypto_free_cipher(cipher);
crypto_free_cipher(ctx->child);
*flags |= CRYPTO_TFM_RES_BAD_BLOCK_LEN;
return -EINVAL;
}
ctx->tweak = cipher;
return 0;
}
static void exit_tfm(struct crypto_tfm *tfm)
{
struct priv *ctx = crypto_tfm_ctx(tfm);
crypto_free_cipher(ctx->child);
crypto_free_cipher(ctx->tweak);
}
static struct crypto_instance *alloc(struct rtattr **tb)
{
struct crypto_instance *inst;
struct crypto_alg *alg;
int err;
err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_BLKCIPHER);
if (err)
return ERR_PTR(err);
alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER,
CRYPTO_ALG_TYPE_MASK);
if (IS_ERR(alg))
return ERR_CAST(alg);
inst = crypto_alloc_instance("xts", alg);
if (IS_ERR(inst))
goto out_put_alg;
inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER;
inst->alg.cra_priority = alg->cra_priority;
inst->alg.cra_blocksize = alg->cra_blocksize;
if (alg->cra_alignmask < 7)
inst->alg.cra_alignmask = 7;
else
inst->alg.cra_alignmask = alg->cra_alignmask;
inst->alg.cra_type = &crypto_blkcipher_type;
inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize;
inst->alg.cra_blkcipher.min_keysize =
2 * alg->cra_cipher.cia_min_keysize;
inst->alg.cra_blkcipher.max_keysize =
2 * alg->cra_cipher.cia_max_keysize;
inst->alg.cra_ctxsize = sizeof(struct priv);
inst->alg.cra_init = init_tfm;
inst->alg.cra_exit = exit_tfm;
inst->alg.cra_blkcipher.setkey = setkey;
inst->alg.cra_blkcipher.encrypt = encrypt;
inst->alg.cra_blkcipher.decrypt = decrypt;
out_put_alg:
crypto_mod_put(alg);
return inst;
}
static void free(struct crypto_instance *inst)
{
crypto_drop_spawn(crypto_instance_ctx(inst));
kfree(inst);
}
void StatusLineC::ToggleHelp(WC_TW)
{
if (!Visible)
{
#ifdef WINCIT
Toggle(TW);
#else
Toggle();
#endif
}
else
{
int row = tw()logiRow, col = tw()logiCol;
// small window?
if (!HelpTimeout)
{
if (LockMessages(MSG_HELP))
{
// Make big window...
time(&HelpTimeout);
scrollpos = conRows - Height();
if (row > scrollpos)
{
tw()scroll(row, row - scrollpos, cfg.attr);
row = scrollpos;
}
}
}
else
{
// Make small window...
HelpTimeout = 0;
if (State == SL_TWOLINES)
{
tw()clearline(conRows - 5, cfg.attr);
}
tw()clearline(conRows - 4, cfg.attr);
tw()clearline(conRows - 3, cfg.attr);
tw()clearline(conRows - 2, cfg.attr);
tw()clearline(conRows - 1, cfg.attr);
scrollpos = conRows - Height();
UnlockMessages(MSG_HELP);
}
tw()position(row, col);
updateStatus = TRUE;
#ifdef WINCIT
Update(TW);
#else
Update();
#endif
}
}
