wyTransactionTestLayer() : m_db(NULL) {
const char* path = "/sdcard/WiEngine/transaction_test.db";
// value label
m_hint = wyLabel::make("row count: 0");
m_hint->setPosition(wyDevice::winWidth / 2, wyDevice::winHeight * 3 / 4);
addChildLocked(m_hint);
// create buttons
createButton("Insert One Row", this, wyDevice::winWidth / 2, wyDevice::winHeight / 2,
wyTargetSelector::make(this, SEL(wyTransactionTestLayer::onInsert)));
createButton("Commit", this, wyDevice::winWidth / 2, wyDevice::winHeight / 2 - DP(60),
wyTargetSelector::make(this, SEL(wyTransactionTestLayer::onCommit)));
createButton("Rollback", this, wyDevice::winWidth / 2, wyDevice::winHeight / 2 - DP(120),
wyTargetSelector::make(this, SEL(wyTransactionTestLayer::onRollback)));
// open database, if it is not there, will create it
m_db = wyDatabase::make(path);
m_db->open();
m_db->retain();
// if no test table, create it
if(!m_db->tableExists("test"))
m_db->executeUpdate("CREATE TABLE test (_id INTEGER PRIMARY KEY autoincrement, test_column INTEGER)");
// query the value inserted
int rowCount = m_db->intForQuery("SELECT count() FROM test");
char buf[64];
sprintf(buf, "row count: %d", rowCount);
m_hint->setText(buf);
}
wyCreateDatabaseTestLayer() {
// value label
m_value = wyLabel::make("value is");
m_value->setPosition(wyDevice::winWidth / 2, wyDevice::winHeight * 3 / 4);
addChildLocked(m_value);
// create buttons
createButton("Create Database", this, wyDevice::winWidth / 2, wyDevice::winHeight / 2 + DP(40),
wyTargetSelector::make(this, SEL(wyCreateDatabaseTestLayer::onCreate)));
createButton("Delete Database", this, wyDevice::winWidth / 2, wyDevice::winHeight / 2 - DP(40),
wyTargetSelector::make(this, SEL(wyCreateDatabaseTestLayer::onDelete)));
// if database exist, update hint label now
const char* path = "/sdcard/WiEngine/create_database_test.db";
if(wyUtils::isPathExistent(path)) {
// create database and open it
wyDatabase* db = wyDatabase::make(path);
db->open();
// query the value inserted
wyResultSet* rs = db->executeQuery("SELECT * FROM test");
if(rs != NULL && rs->next()) {
int value = rs->intForColumn("test_column");
char buf[64];
sprintf(buf, "value is %d", value);
m_value->setText(buf);
}
}
}
static int compare(const void * l, const void * r)
{
Int wDiff;
TableEntry * p1 = (TableEntry*)l, * p2 = (TableEntry*)r;
/* sort entries by count, class name, selector name */
if((wDiff = p2->wCount - p1->wCount) == 0 && p1->wCount != 0) {
if((wDiff = strcmp(tyc_CLASS(ID(p1->wKey))->pszName,
tyc_CLASS(ID(p2->wKey))->pszName)) == 0) {
wDiff = strcmp(tyc_SELECTOR(SEL(p1->wKey)), tyc_SELECTOR(SEL(p2->wKey)));
}
}
return wDiff;
}
/***********************************************************************
* NE_LoadAllSegments
*/
BOOL NE_LoadAllSegments( NE_MODULE *pModule )
{
int i;
SEGTABLEENTRY * pSegTable = (SEGTABLEENTRY *) NE_SEG_TABLE(pModule);
if (pModule->flags & NE_FFLAGS_SELFLOAD)
{
HANDLE hf;
HFILE16 hFile16;
HGLOBAL16 sel;
/* Handle self-loading modules */
SELFLOADHEADER *selfloadheader;
HMODULE16 mod = GetModuleHandle16("KERNEL");
DWORD oldstack;
TRACE_(module)("%.*s is a self-loading module!\n",
*((BYTE*)pModule + pModule->name_table),
(char *)pModule + pModule->name_table + 1);
if (!NE_LoadSegment( pModule, 1 )) return FALSE;
selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg), 0) );
selfloadheader->EntryAddrProc = GetProcAddress16(mod,"EntryAddrProc");
selfloadheader->MyAlloc = GetProcAddress16(mod,"MyAlloc");
selfloadheader->SetOwner = GetProcAddress16(mod,"FarSetOwner");
sel = GlobalAlloc16( GMEM_ZEROINIT, 0xFF00 );
pModule->self_loading_sel = SEL(sel);
FarSetOwner16( sel, pModule->self );
oldstack = NtCurrentTeb()->WOW32Reserved;
NtCurrentTeb()->WOW32Reserved = MAKESEGPTR(pModule->self_loading_sel,
0xff00 - sizeof(STACK16FRAME) );
DuplicateHandle( GetCurrentProcess(), NE_OpenFile(pModule),
GetCurrentProcess(), &hf, 0, FALSE, DUPLICATE_SAME_ACCESS );
hFile16 = Win32HandleToDosFileHandle( hf );
TRACE_(dll)("CallBootAppProc(hModule=0x%04x,hf=0x%04x)\n",
pModule->self,hFile16);
NE_CallTo16_word_ww(selfloadheader->BootApp, pModule->self,hFile16);
TRACE_(dll)("Return from CallBootAppProc\n");
_lclose16(hFile16);
NtCurrentTeb()->WOW32Reserved = oldstack;
for (i = 2; i <= pModule->seg_count; i++)
if (!NE_LoadSegment( pModule, i )) return FALSE;
}
else
{
for (i = 1; i <= pModule->seg_count; i++)
if (!NE_LoadSegment( pModule, i )) return FALSE;
}
return TRUE;
}
/***********************************************************************
* NE_LoadAllSegments
*/
BOOL NE_LoadAllSegments( NE_MODULE *pModule )
{
int i;
SEGTABLEENTRY * pSegTable = NE_SEG_TABLE(pModule);
if (pModule->ne_flags & NE_FFLAGS_SELFLOAD)
{
HFILE16 hFile16;
HGLOBAL16 sel;
/* Handle self-loading modules */
SELFLOADHEADER *selfloadheader;
HMODULE16 mod = GetModuleHandle16("KERNEL");
void *oldstack;
WORD args[2];
TRACE_(module)("%.*s is a self-loading module!\n",
*((BYTE*)pModule + pModule->ne_restab),
(char *)pModule + pModule->ne_restab + 1);
if (!NE_LoadSegment( pModule, 1 )) return FALSE;
selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg), 0) );
selfloadheader->EntryAddrProc = GetProcAddress16(mod,"EntryAddrProc");
selfloadheader->MyAlloc = GetProcAddress16(mod,"MyAlloc");
selfloadheader->SetOwner = GetProcAddress16(mod,"FarSetOwner");
sel = GlobalAlloc16( GMEM_ZEROINIT, 0xFF00 );
pModule->self_loading_sel = SEL(sel);
FarSetOwner16( sel, pModule->self );
oldstack = getWOW32Reserved();
setWOW32Reserved((void *)MAKESEGPTR(pModule->self_loading_sel,
0xff00 - sizeof(STACK16FRAME) ));
hFile16 = NE_OpenFile(pModule);
TRACE_(dll)("CallBootAppProc(hModule=0x%04x,hf=0x%04x)\n",
pModule->self,hFile16);
args[1] = pModule->self;
args[0] = hFile16;
WOWCallback16Ex( (DWORD)selfloadheader->BootApp, WCB16_PASCAL, sizeof(args), args, NULL );
TRACE_(dll)("Return from CallBootAppProc\n");
_lclose16(hFile16);
setWOW32Reserved(oldstack);
for (i = 2; i <= pModule->ne_cseg; i++)
if (!NE_LoadSegment( pModule, i )) return FALSE;
}
else
{
for (i = 1; i <= pModule->ne_cseg; i++)
if (!NE_LoadSegment( pModule, i )) return FALSE;
}
return TRUE;
}
static void dumpTable(void)
{
/* print header */
fflush(stdout);
fprintf(stdout, "\nTVM-Profiler Statistical Output");
fprintf(stdout, "\n-------------------------------\n");
fprintf(stdout, " events recorded: %d\n", nEvents);
fprintf(stdout, " events lost: %d\n", nUnrecorded);
fprintf(stdout, "additional lookups: %d\n", nMiss);
fprintf(stdout, "\nMethod Calls");
fprintf(stdout, "\n------------\n");
fflush(stdout);
/* sort entries */
qsort(&aHashTable, nENTRIES, sizeof(TableEntry), compare);
/* print entries */
{
Word n;
Int nFill;
char * pClassName, * pSelectorName;
for(n = 0; n < nENTRIES; n++) {
if(aHashTable[n].wKey != 0) {
pClassName = tyc_CLASS(ID(aHashTable[n].wKey))->pszName;
pSelectorName = tyc_SELECTOR(SEL(aHashTable[n].wKey));
fprintf(stdout, "%s.%s", pClassName, pSelectorName);
for(nFill = 30 - (strlen(pClassName) + strlen(pSelectorName));
nFill > 0; nFill--)
putchar(' ');
fprintf(stdout,"\t%d events (%.2f%%)\n", aHashTable[n].wCount,
(float)100 * (float)aHashTable[n].wCount / (float)nEvents);
fflush(stdout);
}
}
}
return;
}
wyMotionStreak::wyMotionStreak(float fade, wyTexture2D* tex, wyColor4B color, wyMotionStreakStyle style) :
m_segThreshold(3),
m_lastLocation(wyp(-1, -1)),
m_currentLocation(wyp(-1, -1)),
m_paused(false) {
// init member
m_pendingPoints = WYNEW vector<PendingPoint>();
m_pendingPoints->reserve(10);
// create ribbon by style
switch(style) {
case MS_STYLE_STRIP:
m_ribbon = wyStripRibbon::make(tex, color, fade);
break;
case MS_STYLE_SPOT:
m_ribbon = wySpotRibbon::make(tex, color, fade);
break;
case MS_STYLE_BLADE:
m_ribbon = wyBladeRibbon::make(tex, color, fade);
break;
case MS_STYLE_LINE:
m_ribbon = wyLineRibbon::make(tex, color);
break;
}
// add ribbon to motion streak
addChildLocked(m_ribbon);
// update ribbon position
wyTargetSelector* ts = wyTargetSelector::make(this, SEL(wyMotionStreak::update));
wyTimer* timer = wyTimer::make(ts);
scheduleLocked(timer);
}
int SEL(int *A,int m,int p,int k,int r) {
int temp = 0;
int n = 0,i = 0,j = 0;
if(p - m + 1 <= r) {
INSERTIONSORT(A,m,p);
return m + k - 1;
}
while(1) {
n = p - m + 1;
for(i = 1;i <= n/r;i++) {
INSERTIONSORT(A,m + (i - 1) * r,m + i * r - 1); //将中间值收集到A的前部
temp = A[m+i-1];
if(r%2) r++;
A[m+i-1] = A[m+(i-1)*r+r/2-1];
A[m+(i-1)*r+r/2-1] = temp;
}
if((n / r) % 2) j = (n / r) / 2;
else j = (n / r) / 2 + 1;
j = SEL(A,m,m + n/r - 1,j,r);
temp = A[m];
A[m] = A[j];
A[j] = A[m];
j = p + 1;
j = PARTITION(A,m,j);
if(j - m + 1 == k) return j;
else if(j - m + 1 > k) p = j -1;
else {
k = k - (j - m + 1);
m = j + 1;
}
}
}
/***********************************************************************
* PatchCodeHandle (KERNEL.110)
*
* Needed for self-loading modules.
*/
DWORD WINAPI PatchCodeHandle16(HANDLE16 hSeg)
{
WORD segnum;
WORD sel = SEL(hSeg);
NE_MODULE *pModule = NE_GetPtr(FarGetOwner16(sel));
SEGTABLEENTRY *pSegTable = NE_SEG_TABLE(pModule);
TRACE_(module)("(%04x);\n", hSeg);
/* find the segment number of the module that belongs to hSeg */
for (segnum = 1; segnum <= pModule->ne_cseg; segnum++)
{
if (SEL(pSegTable[segnum-1].hSeg) == sel)
{
NE_FixupSegmentPrologs(pModule, segnum);
break;
}
}
return MAKELONG(hSeg, sel);
}
/* SelectAllUnusedFonts()
* ====================================================================
*/
void
SelectAllUnusedFonts( void )
{
FON_PTR curptr;
curptr = available_list;
while( curptr )
{
if( !SEL( curptr ) )
AFLAG( curptr ) = TRUE;
curptr = FNEXT( curptr );
}
}
/***********************************************************************
* MyAlloc (KERNEL.668) Wine-specific export
*
* MyAlloc() function for self-loading apps.
*/
DWORD WINAPI MyAlloc16( WORD wFlags, WORD wSize, WORD wElem )
{
WORD size = wSize << wElem;
HANDLE16 hMem = 0;
if (wSize || (wFlags & NE_SEGFLAGS_MOVEABLE))
hMem = GlobalAlloc16( NE_Ne2MemFlags(wFlags), size);
if ( ((wFlags & 0x7) != 0x1) && /* DATA */
((wFlags & 0x7) != 0x7) ) /* DATA|ALLOCATED|LOADED */
{
WORD hSel = SEL(hMem);
WORD access = SelectorAccessRights16(hSel,0,0);
access |= 2<<2; /* SEGMENT_CODE */
SelectorAccessRights16(hSel,1,access);
}
if (size)
return MAKELONG( hMem, SEL(hMem) );
else
return MAKELONG( 0, hMem );
}
/***********************************************************************
* NE_InitDLL
*
* Call the DLL initialization code
*/
static BOOL NE_InitDLL( NE_MODULE *pModule )
{
SEGTABLEENTRY *pSegTable;
WORD hInst, ds, heap;
CONTEXT context;
pSegTable = NE_SEG_TABLE( pModule );
if (!(pModule->ne_flags & NE_FFLAGS_LIBMODULE) ||
(pModule->ne_flags & NE_FFLAGS_WIN32)) return TRUE; /*not a library*/
/* Call USER signal handler for Win3.1 compatibility. */
NE_CallUserSignalProc( pModule->self, USIG16_DLL_LOAD );
if (!SELECTOROF(pModule->ne_csip)) return TRUE; /* no initialization code */
/* Registers at initialization must be:
* cx heap size
* di library instance
* ds data segment if any
* es:si command line (always 0)
*/
memset( &context, 0, sizeof(context) );
NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
context.Ecx = heap;
context.Edi = hInst;
context.SegDs = ds;
context.SegEs = ds; /* who knows ... */
context.SegFs = wine_get_fs();
context.SegGs = wine_get_gs();
context.SegCs = SEL(pSegTable[SELECTOROF(pModule->ne_csip)-1].hSeg);
context.Eip = OFFSETOF(pModule->ne_csip);
context.Ebp = OFFSETOF(getWOW32Reserved()) + FIELD_OFFSET(STACK16FRAME,bp);
pModule->ne_csip = 0; /* Don't initialize it twice */
TRACE_(dll)("Calling LibMain for %.*s, cs:ip=%04x:%04x ds=%04x di=%04x cx=%04x\n",
*((BYTE*)pModule + pModule->ne_restab),
(char *)pModule + pModule->ne_restab + 1,
context.SegCs, context.Eip, context.SegDs,
LOWORD(context.Edi), LOWORD(context.Ecx) );
WOWCallback16Ex( 0, WCB16_REGS, 0, NULL, (DWORD *)&context );
return TRUE;
}
/***********************************************************************
* NE_InitDLL
*
* Call the DLL initialization code
*/
static BOOL NE_InitDLL( NE_MODULE *pModule )
{
SEGTABLEENTRY *pSegTable;
WORD hInst, ds, heap;
CONTEXT86 context;
pSegTable = NE_SEG_TABLE( pModule );
if (!(pModule->flags & NE_FFLAGS_LIBMODULE) ||
(pModule->flags & NE_FFLAGS_WIN32)) return TRUE; /*not a library*/
/* Call USER signal handler for Win3.1 compatibility. */
TASK_CallTaskSignalProc( USIG16_DLL_LOAD, pModule->self );
if (!pModule->cs) return TRUE; /* no initialization code */
/* Registers at initialization must be:
* cx heap size
* di library instance
* ds data segment if any
* es:si command line (always 0)
*/
memset( &context, 0, sizeof(context) );
NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
context.Ecx = heap;
context.Edi = hInst;
context.SegDs = ds;
context.SegEs = ds; /* who knows ... */
context.SegCs = SEL(pSegTable[pModule->cs-1].hSeg);
context.Eip = pModule->ip;
context.Ebp = OFFSETOF(NtCurrentTeb()->WOW32Reserved) + (WORD)&((STACK16FRAME*)0)->bp;
pModule->cs = 0; /* Don't initialize it twice */
TRACE_(dll)("Calling LibMain, cs:ip=%04lx:%04lx ds=%04lx di=%04x cx=%04x\n",
context.SegCs, context.Eip, context.SegDs,
LOWORD(context.Edi), LOWORD(context.Ecx) );
wine_call_to_16_regs_short( &context, 0 );
return TRUE;
}
wyScrollableLayer::wyScrollableLayer(wyColor4B color) :
wyColorLayer(color),
m_vertical(false),
m_horizontal(false),
m_scrolling(false),
m_flinging(false),
m_childTouchCancelled(false),
m_lastX(0),
m_lastY(0),
m_firstX(0),
m_firstY(0),
m_leftMargin(0),
m_rightMargin(0),
m_topMargin(0),
m_bottomMargin(0),
m_leftBorder(0),
m_rightBorder(0),
m_topBorder(0),
m_bottomBorder(0),
m_xExtent(0),
m_yExtent(0),
m_horizontalThumb(NULL),
m_verticalThumb(NULL),
m_fadeOutTime(0),
m_noScrollTime(0),
m_fadeingOut(false),
m_callback(NULL),
#if ANDROID
m_jCallback(NULL),
#endif
m_scroller(WYNEW wyScroller()) {
// enable event
setTouchEnabled(true);
setGestureEnabled(true);
// create container
m_container = wyScrollContainer::make();
addChildLocked(m_container);
// schedule fling timer
wyTargetSelector* ts = wyTargetSelector::make(this, SEL(wyScrollableLayer::updateFling));
wyTimer* timer = wyTimer::make(ts);
scheduleLocked(timer);
}
wyIntervalAction* wyRadialCCWTransition::getOutAction() {
// create progress by action
wyIntervalAction* progress = wyProgressBy::make(m_duration, -100);
// use ease if set
if(m_outEase) {
m_outEase->setWrappedAction(progress);
progress = m_outEase;
}
// create call finish func
wyTargetSelector* ts = wyTargetSelector::make(this, SEL(wyTransitionScene::finish));
wyFiniteTimeAction* callFinish = wyCallFunc::make(ts);
// create sequence
wySequence* seq = wySequence::make(progress, callFinish, NULL);
// return sequence
return seq;
}
wyIntervalAction* wyRightPushInTransition::getOutAction() {
// create eased move by
wyIntervalAction* moveBy = wyMoveBy::make(m_duration, -wyDevice::winWidth, 0);
wyIntervalAction* easeMove = wyEaseOut::make(2.0f, moveBy);
// if ease is set, use ease
if(m_outEase) {
m_outEase->setWrappedAction(easeMove);
easeMove = m_outEase;
}
// create call func
wyTargetSelector* ts = wyTargetSelector::make(this, SEL(wyTransitionScene::finish));
wyFiniteTimeAction* call = wyCallFunc::make(ts);
// create sequence
wySequence* seq = wySequence::make(easeMove, call, NULL);
// return
return seq;
}
int main() {
int i = 0,j = 0,x = 0;
int k[5] = {1,7,1,7,4};
int m[5] = {1,23,30,8,17};
int p[5] = {30,29,30,14,30};
int r[2] = {5,9};
int A[5][32] = {{0,81,5,13,67,54,73,25,103,109,99,4888821,77,88,99,12,3,34,65,3425,5367,76457648,36456346,34656346,346,4654,24654,456546,24564,4444464,4664,MAX},
{0,100000000,0,23,1,5,2147483646,9,1000002,1,3,245,344,34,4354,56,5,78,43,54657,6686,6786,667,567,878,34,45,5778,14,34,5,MAX},
{0,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,MAX},
{0,10,10,10,10,1,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,MAX},
{0,301,291,281,271,261,251,241,231,221,211,201,191,181,171,161,151,141,131,121,111,101,91,81,71,61,51,41,31,21,11,MAX}};
for(i = 0;i < 5;i++) {
for(j = 1;j <= 30;j++) printf("%d ",A[i][j]);
printf("%s","\n\n");
}
for(i = 0;i < 5;i++) {
if(i > 2) x = 1;
j = SEL(A[i],m[i],p[i],k[i],r[x]);
printf("A[%d]的%d-%d第%d小元素为：%d\n",i,m[i],p[i],k[i],A[i][j]);
}
return 1;
}
void wyDirector_android::onSurfaceDestroyed() {
if(m_surfaceCreated) {
wyDirector::onSurfaceDestroyed();
// if allow background running and has scene
if(m_allowBackgroundRunning && m_scenesStack->num > 0) {
pthread_mutex_lock(&gCondMutex);
m_backgroundRunning = true;
pthread_mutex_unlock(&gCondMutex);
// ensure next delta is zero
setNextDeltaTimeZero(true);
// change max frame rate
m_originalMaxFrameRate = m_maxFrameRate;
setMaxFrameRate(60);
// create wyThread
wyThread::runThread(wyTargetSelector::make(this, SEL(wyDirector_android::backgroundLooper)));
}
}
}
wyIntervalAction* wyShrinkGrowTransition::getOutAction() {
// create scale
wyScaleTo* scale = wyScaleTo::make(m_duration, m_outScene->getScale(), 0.01f);
// ease scale
wyIntervalAction* easeScale = wyEaseOut::make(2.0f, scale);
// use ease if set
if(m_outEase) {
m_outEase->setWrappedAction(easeScale);
easeScale = m_outEase;
}
// create call func
wyTargetSelector* ts = wyTargetSelector::make(this, SEL(wyTransitionScene::finish));
wyFiniteTimeAction* call = wyCallFunc::make(ts);
// create sequence
wySequence* seq = wySequence::make(easeScale, call, NULL);
// return
return seq;
}
/***********************************************************************
* NE_GetDLLInitParams
*/
static VOID NE_GetDLLInitParams( NE_MODULE *pModule,
WORD *hInst, WORD *ds, WORD *heap )
{
SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
if (!(pModule->ne_flags & NE_FFLAGS_SINGLEDATA))
{
if (pModule->ne_flags & NE_FFLAGS_MULTIPLEDATA || pModule->ne_autodata)
{
/* Not SINGLEDATA */
ERR_(dll)("Library is not marked SINGLEDATA\n");
exit(1);
}
else /* DATA NONE DLL */
{
*ds = 0;
*heap = 0;
}
}
else /* DATA SINGLE DLL */
{
if (pModule->ne_autodata) {
*ds = SEL(pSegTable[pModule->ne_autodata-1].hSeg);
*heap = pModule->ne_heap;
}
else /* hmm, DLL has no dgroup,
but why has it NE_FFLAGS_SINGLEDATA set ?
Buggy DLL compiler ? */
{
*ds = 0;
*heap = 0;
}
}
*hInst = *ds ? GlobalHandle16(*ds) : pModule->self;
}
wyPageControl::wyPageControl() :
m_pages(wyArrayNew(5)),
m_container(NULL),
m_lastX(0),
m_lastY(0),
m_scroller(WYNEW wyScroller()),
m_flinging(false),
m_scrolling(false),
m_vertical(false),
m_initialPageIndex(-1),
m_indicator(NULL),
m_data(NULL),
#if ANDROID
m_jCallback(NULL),
#endif
m_centerY(-1),
m_centerX(-1) {
// set page control properties
setRelativeAnchorPoint(false);
setContentSize(wyDevice::winWidth, wyDevice::winHeight);
memset(&m_callback, 0, sizeof(wyPageControlCallback));
// create container
m_container = WYNEW wyLayer();
m_container->setPosition(0, 0);
addChildLocked(m_container);
m_container->release();
// enable events
setTouchEnabled(true);
// schedule fling timer
wyTargetSelector* ts = wyTargetSelector::make(this, SEL(wyPageControl::updateFling));
wyTimer* timer = wyTimer::make(ts);
scheduleLocked(timer);
}
Elem & Machine::execute(std::ostream &out)
{
Instruction *command;
std::shared_ptr<Elem> command_ptr;
Elem *ADD(new Instruction("ADD"));
Elem *MUL(new Instruction("MUL"));
Elem *SUB(new Instruction("SUB"));
Elem *DIV(new Instruction("DIV"));
Elem *REM(new Instruction("REM"));
Elem *EQ(new Instruction("EQ"));
Elem *LEQ(new Instruction("LEQ"));
Elem *SEL(new Instruction("SEL"));
Elem *LD(new Instruction("LD"));
Elem *LDC(new Instruction("LDC"));
Elem *LDF(new Instruction("LDF"));
Elem *CAR(new Instruction("CAR"));
Elem *CDR(new Instruction("CDR"));
Elem *CONS(new Instruction("CONS"));
Elem *NIL(new Instruction("NIL"));
Elem *DUM(new Instruction("DUM"));
Elem *AP(new Instruction("AP"));
Elem *RAP(new Instruction("RAP"));
Elem *RTN(new Instruction("RTN"));
Elem *JOIN(new Instruction("JOIN"));
Elem *STOP(new Instruction("STOP"));
while (!C->empty())
{
if (out != 0x0)
{
print_S(out);
print_E(out);
print_C(out);
out << std::endl;
}
command_ptr = C->pop_ret();
command = dynamic_cast<Instruction*>(&*command_ptr);
if (command == nullptr) throw Exception("Execute", "FatalError");
if (*command == *ADD) this->ADD();
else if (*command == *MUL) this->MUL();
else if (*command == *SUB) this->SUB();
else if (*command == *DIV) this->DIV();
else if (*command == *REM) this->REM();
else if (*command == *EQ) this->EQ();
else if (*command == *LEQ) this->LEQ();
else if (*command == *SEL) this->SEL();
else if (*command == *LD) this->LD();
else if (*command == *LDC) this->LDC();
else if (*command == *LDF) this->LDF();
else if (*command == *CAR) this->CAR();
else if (*command == *CDR) this->CDR();
else if (*command == *CONS) this->CONS();
else if (*command == *NIL) this->NIL();
else if (*command == *DUM) this->DUM();
else if (*command == *AP) this->AP();
else if (*command == *RAP) this->RAP();
else if (*command == *RTN) this->RTN();
else if (*command == *JOIN) this->JOIN();
else if (*command == *STOP) { return (*(this->STOP()));}
else throw Exception("Execute", "Expected 'instruction' but greeted constant.");
}
throw Exception("Execute", "FatalError");
}
//_____________________________________________________________________________//
void study(int type, bool wBkg){
string slep="_ee";
string SLEP="_EE_";
if(type==1){
slep = "_mm";
SLEP = "_MM_";
}
if(type==2){
slep = "_em";
SLEP = "_EM_";
}
TCut EE("llType==0");
TCut MM("llType==1");
TCut EM("llType==2");
//
//start modif
//
bool logy=false;//true;
TCut SJ("j_isC20 || j_isB20 || j_isF30");
TCut SEL("nSJets>=0 ");
//TCut SEL("nSJets>0 && metrel>60 ");
//TCut SEL(SJ && "nSJets==1 && (mll>100 & mll<110) && l_pt[0]>30 ");
//TCut SEL("nSJets==1 && metrel>40 && (mll>100 & mll<110) ");
//TCut SEL("nSJets==1 && met>40 && l_pt[0]>30");
//TCut SEL("nSJets==1 && metrel>40");
//TCut SEL("nSJets==1 && metrel>40 && l_pt[0]>30");
//TCut SEL(SJ && "nSJets==1 && metrel>40 && l_pt[0]>30 && (mll>100 & mll<110)");
//TCut SEL(SJ && "nSJets==1 && l_pt[0]>30 && (mll>100 & mll<110)");
//TCut SEL("nSJets==1 && metrel>40 && mll>90 & mll<120 && l_pt[0]");
//TCut SEL("nSJets<2 && metrel>40 ");
//string var = "l_pt[1]";
//string var = "l_q[0]+l_q[1]";
//string var = "sqrt(2*l_pt[0]*met * (1- cos(acos(cos(l_phi[0]-met_phi)))))";
// string var = "mll";
//string var = "pTll";
//string var = "met";
string var = "metrel";
//string var = "met_refEle";
//string var = "met_refMuo";
//string var = "met_refJet";
//string var = "met_cellout";
// string var = "acos(cos(l_phi[1]-met_phi))";
//string var = "nSJets";
//string var = "j_pt";
//string var = "j_eta";
//string var = "j_jvf";
string sName = "CR2LepSS_noCut"+ SLEP + var;
//string sName = "CR2LepSS_VR1SS"+ SLEP + var;
//string sName = "CR2LepSS_Jveto"+ SLEP + var;
//string sName = "CR2LepSS_ge1SJ_metrel70"+ SLEP + var;
//string sName = "CR2LepSS_1Jptl030Mll100-110"+ SLEP + var;
//string sName = "CR2LepSS_1JMetrel40"+ SLEP + var;
//string sName = "CR2LepSS_Metrel40Mll100-110"+ SLEP + var;
//string sName = "CR2LepSS_1JMet40ptl030"+ SLEP + var;
// string sName = "CR2LepSS_1JMetrel40"+ SLEP + var;
//string sName = "CR2LepSS_1JMetrel40ptl030"+ SLEP + var;
//string sName = "CR2LepSS_LE1JMetrel40"+ SLEP + var;
//string sName = "CR2LepSS_1JMetrel40Mll90-120"+ SLEP + var;
// string sName = "CR2LepSS_1JMetrel40ptl030mll102-106"+ SLEP + var;
//string sName = "CR2LepSS_1JMetrel40ptl030mll100-110"+ SLEP + var;
//string sName = "CR2LepSS_1Jptl030IN"+ SLEP + var;
//string sName = "CR2LepSS_1JMetrel40ptl030IN"+ SLEP + var;
//string sName = "CR2LepSS_1JMetrel40ptl030OUT"+ SLEP + var;
//
//end modif
//
//No changes needed below
string hName ="hdata"+slep;
TH1F* hdata = bookHist(var,hName);
if(hdata==NULL) abort();
TCut CEE( (SEL && EE ) * "w");
TCut CMM( (SEL && MM ) * "w");
TCut CEM( (SEL && EM ) * "w");
if(wBkg){
TH1F* hFake = (TH1F*) hdata->Clone();
hFake->SetTitle(string("hFake"+slep).c_str());
hFake->SetName(string("hFake"+slep).c_str());
TH1F* hWW = (TH1F*) hdata->Clone();
hWW->SetTitle(string("hWW"+slep).c_str());
hWW->SetName(string("hWW"+slep).c_str());
TH1F* hWZ = (TH1F*) hdata->Clone();
hWZ->SetTitle(string("hWZ"+slep).c_str());
hWZ->SetName(string("hWZ"+slep).c_str());
TH1F* hZZ = (TH1F*) hdata->Clone();
hZZ->SetTitle(string("hZZ"+slep).c_str());
hZZ->SetName(string("hZZ"+slep).c_str());
TH1F* hTOP = (TH1F*) hdata->Clone();
hTOP->SetTitle(string("hTOP"+slep).c_str());
hTOP->SetName(string("hTOP"+slep).c_str());
TH1F* hZJET = (TH1F*) hdata->Clone();
hZJET->SetTitle(string("hZJET"+slep).c_str());
hZJET->SetName(string("hZJET"+slep).c_str());
}
//Fill histo
if(type==0){
string cmd1 = var + ">>hdata_ee";
c_data->Draw(cmd1.c_str(),CEE,"goff");
if(wBkg){
cmd1 = var + ">>hFake_ee";
c_fake->Draw(cmd1.c_str(),CEE,"goff");
cmd1 = var + ">>hWW_ee";
c_WW->Draw(cmd1.c_str(),CEE,"goff");
cmd1 = var + ">>hWZ_ee";
c_WZ->Draw(cmd1.c_str(),CEE,"goff");
cmd1 = var + ">>hZZ_ee";
c_ZZ->Draw(cmd1.c_str(),CEE,"goff");
cmd1 = var + ">>hTOP_ee";
c_TOP->Draw(cmd1.c_str(),CEE,"goff");
cmd1 = var + ">>hZJET_ee";
c_ZJET->Draw(cmd1.c_str(),CEE,"goff");
}
}
else if (type==1) {
string cmd1 = var + ">>hdata_mm";
c_data->Draw(cmd1.c_str(),CMM,"goff");
if(wBkg){
cmd1 = var + ">>hFake_mm";
c_fake->Draw(cmd1.c_str(),CMM,"goff");
cmd1 = var + ">>hWW_mm";
c_WW->Draw(cmd1.c_str(),CMM,"goff");
cmd1 = var + ">>hWZ_mm";
c_WZ->Draw(cmd1.c_str(),CMM,"goff");
cmd1 = var + ">>hZZ_mm";
c_ZZ->Draw(cmd1.c_str(),CMM,"goff");
cmd1 = var + ">>hTOP_mm";
c_TOP->Draw(cmd1.c_str(),CMM,"goff");
cmd1 = var + ">>hZJET_mm";
c_ZJET->Draw(cmd1.c_str(),CMM,"goff");
}
}
else if (type==2) {
string cmd1 = var + ">>hdata_em";
c_data->Draw(cmd1.c_str(),CEM,"goff");
if(wBkg){
cmd1 = var + ">>hFake_em";
c_fake->Draw(cmd1.c_str(),CEM,"goff");
cmd1 = var + ">>hWW_em";
c_WW->Draw(cmd1.c_str(),CEM,"goff");
cmd1 = var + ">>hWZ_em";
c_WZ->Draw(cmd1.c_str(),CEM,"goff");
cmd1 = var + ">>hZZ_em";
c_ZZ->Draw(cmd1.c_str(),CEM,"goff");
cmd1 = var + ">>hTOP_em";
c_TOP->Draw(cmd1.c_str(),CEM,"goff");
cmd1 = var + ">>hZJET_em";
c_ZJET->Draw(cmd1.c_str(),CEM,"goff");
}
}
if(wBkg) plot(hdata,hFake,hWW,hWZ,hZZ,hTOP,hZJET, sName,logy);
else plot(hdata,sName,logy);
}
/***********************************************************************
* NE_FixupSegmentPrologs
*
* Fixup exported functions prologs of one segment
*/
static void NE_FixupSegmentPrologs(NE_MODULE *pModule, WORD segnum)
{
SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
ET_BUNDLE *bundle;
ET_ENTRY *entry;
WORD dgroup, num_entries, sel = SEL(pSegTable[segnum-1].hSeg);
BYTE *pSeg, *pFunc;
TRACE("(%d);\n", segnum);
if (pSegTable[segnum-1].flags & NE_SEGFLAGS_DATA)
{
pSegTable[segnum-1].flags |= NE_SEGFLAGS_LOADED;
return;
}
if (!pModule->ne_autodata) return;
if (!pSegTable[pModule->ne_autodata-1].hSeg) return;
dgroup = SEL(pSegTable[pModule->ne_autodata-1].hSeg);
pSeg = MapSL( MAKESEGPTR(sel, 0) );
bundle = (ET_BUNDLE *)((BYTE *)pModule+pModule->ne_enttab);
do {
TRACE("num_entries: %d, bundle: %p, next: %04x, pSeg: %p\n", bundle->last - bundle->first, bundle, bundle->next, pSeg);
if (!(num_entries = bundle->last - bundle->first))
return;
entry = (ET_ENTRY *)((BYTE *)bundle+6);
while (num_entries--)
{
/*TRACE("entry: %p, entry->segnum: %d, entry->offs: %04x\n", entry, entry->segnum, entry->offs);*/
if (entry->segnum == segnum)
{
pFunc = pSeg+entry->offs;
TRACE("pFunc: %p, *(DWORD *)pFunc: %08x, num_entries: %d\n", pFunc, *(DWORD *)pFunc, num_entries);
if (*(pFunc+2) == 0x90)
{
if (*(WORD *)pFunc == 0x581e) /* push ds, pop ax */
{
TRACE("patch %04x:%04x -> mov ax, ds\n", sel, entry->offs);
*(WORD *)pFunc = 0xd88c; /* mov ax, ds */
}
if (*(WORD *)pFunc == 0xd88c)
{
if ((entry->flags & 2)) /* public data ? */
{
TRACE("patch %04x:%04x -> mov ax, dgroup [%04x]\n", sel, entry->offs, dgroup);
*pFunc = 0xb8; /* mov ax, */
*(WORD *)(pFunc+1) = dgroup;
}
else if ((pModule->ne_flags & NE_FFLAGS_MULTIPLEDATA)
&& (entry->flags & 1)) /* exported ? */
{
TRACE("patch %04x:%04x -> nop, nop\n", sel, entry->offs);
*(WORD *)pFunc = 0x9090; /* nop, nop */
}
}
}
}
entry++;
}
} while ( (bundle->next) && (bundle = ((ET_BUNDLE *)((BYTE *)pModule + bundle->next))) );
}
void
gen8_vec4_generator::generate_vec4_instruction(vec4_instruction *instruction,
struct brw_reg dst,
struct brw_reg *src)
{
vec4_instruction *ir = (vec4_instruction *) instruction;
if (dst.width == BRW_WIDTH_4) {
/* This happens in attribute fixups for "dual instanced" geometry
* shaders, since they use attributes that are vec4's. Since the exec
* width is only 4, it's essential that the caller set
* force_writemask_all in order to make sure the instruction is executed
* regardless of which channels are enabled.
*/
assert(ir->force_writemask_all);
/* Fix up any <8;8,1> or <0;4,1> source registers to <4;4,1> to satisfy
* the following register region restrictions (from Graphics BSpec:
* 3D-Media-GPGPU Engine > EU Overview > Registers and Register Regions
* > Register Region Restrictions)
*
* 1. ExecSize must be greater than or equal to Width.
*
* 2. If ExecSize = Width and HorzStride != 0, VertStride must be set
* to Width * HorzStride."
*/
for (int i = 0; i < 3; i++) {
if (src[i].file == BRW_GENERAL_REGISTER_FILE)
src[i] = stride(src[i], 4, 4, 1);
}
}
switch (ir->opcode) {
case BRW_OPCODE_MOV:
MOV(dst, src[0]);
break;
case BRW_OPCODE_ADD:
ADD(dst, src[0], src[1]);
break;
case BRW_OPCODE_MUL:
MUL(dst, src[0], src[1]);
break;
case BRW_OPCODE_MACH:
MACH(dst, src[0], src[1]);
break;
case BRW_OPCODE_MAD:
MAD(dst, src[0], src[1], src[2]);
break;
case BRW_OPCODE_FRC:
FRC(dst, src[0]);
break;
case BRW_OPCODE_RNDD:
RNDD(dst, src[0]);
break;
case BRW_OPCODE_RNDE:
RNDE(dst, src[0]);
break;
case BRW_OPCODE_RNDZ:
RNDZ(dst, src[0]);
break;
case BRW_OPCODE_AND:
AND(dst, src[0], src[1]);
break;
case BRW_OPCODE_OR:
OR(dst, src[0], src[1]);
break;
case BRW_OPCODE_XOR:
XOR(dst, src[0], src[1]);
break;
case BRW_OPCODE_NOT:
NOT(dst, src[0]);
break;
case BRW_OPCODE_ASR:
ASR(dst, src[0], src[1]);
break;
case BRW_OPCODE_SHR:
SHR(dst, src[0], src[1]);
break;
case BRW_OPCODE_SHL:
SHL(dst, src[0], src[1]);
break;
case BRW_OPCODE_CMP:
CMP(dst, ir->conditional_mod, src[0], src[1]);
break;
case BRW_OPCODE_SEL:
SEL(dst, src[0], src[1]);
break;
case BRW_OPCODE_DPH:
DPH(dst, src[0], src[1]);
break;
case BRW_OPCODE_DP4:
DP4(dst, src[0], src[1]);
break;
case BRW_OPCODE_DP3:
DP3(dst, src[0], src[1]);
break;
case BRW_OPCODE_DP2:
DP2(dst, src[0], src[1]);
break;
case BRW_OPCODE_F32TO16:
F32TO16(dst, src[0]);
break;
case BRW_OPCODE_F16TO32:
F16TO32(dst, src[0]);
break;
case BRW_OPCODE_LRP:
LRP(dst, src[0], src[1], src[2]);
break;
case BRW_OPCODE_BFREV:
/* BFREV only supports UD type for src and dst. */
BFREV(retype(dst, BRW_REGISTER_TYPE_UD),
retype(src[0], BRW_REGISTER_TYPE_UD));
break;
case BRW_OPCODE_FBH:
/* FBH only supports UD type for dst. */
FBH(retype(dst, BRW_REGISTER_TYPE_UD), src[0]);
break;
case BRW_OPCODE_FBL:
/* FBL only supports UD type for dst. */
FBL(retype(dst, BRW_REGISTER_TYPE_UD), src[0]);
break;
case BRW_OPCODE_CBIT:
/* CBIT only supports UD type for dst. */
CBIT(retype(dst, BRW_REGISTER_TYPE_UD), src[0]);
break;
case BRW_OPCODE_ADDC:
ADDC(dst, src[0], src[1]);
break;
case BRW_OPCODE_SUBB:
SUBB(dst, src[0], src[1]);
break;
case BRW_OPCODE_BFE:
BFE(dst, src[0], src[1], src[2]);
break;
case BRW_OPCODE_BFI1:
BFI1(dst, src[0], src[1]);
break;
case BRW_OPCODE_BFI2:
BFI2(dst, src[0], src[1], src[2]);
break;
case BRW_OPCODE_IF:
IF(ir->predicate);
break;
case BRW_OPCODE_ELSE:
ELSE();
break;
case BRW_OPCODE_ENDIF:
ENDIF();
break;
case BRW_OPCODE_DO:
DO();
break;
case BRW_OPCODE_BREAK:
BREAK();
break;
case BRW_OPCODE_CONTINUE:
CONTINUE();
break;
case BRW_OPCODE_WHILE:
WHILE();
break;
case SHADER_OPCODE_RCP:
MATH(BRW_MATH_FUNCTION_INV, dst, src[0]);
break;
case SHADER_OPCODE_RSQ:
MATH(BRW_MATH_FUNCTION_RSQ, dst, src[0]);
break;
case SHADER_OPCODE_SQRT:
MATH(BRW_MATH_FUNCTION_SQRT, dst, src[0]);
break;
case SHADER_OPCODE_EXP2:
MATH(BRW_MATH_FUNCTION_EXP, dst, src[0]);
break;
case SHADER_OPCODE_LOG2:
MATH(BRW_MATH_FUNCTION_LOG, dst, src[0]);
break;
case SHADER_OPCODE_SIN:
MATH(BRW_MATH_FUNCTION_SIN, dst, src[0]);
break;
case SHADER_OPCODE_COS:
MATH(BRW_MATH_FUNCTION_COS, dst, src[0]);
break;
case SHADER_OPCODE_POW:
MATH(BRW_MATH_FUNCTION_POW, dst, src[0], src[1]);
break;
case SHADER_OPCODE_INT_QUOTIENT:
MATH(BRW_MATH_FUNCTION_INT_DIV_QUOTIENT, dst, src[0], src[1]);
break;
case SHADER_OPCODE_INT_REMAINDER:
MATH(BRW_MATH_FUNCTION_INT_DIV_REMAINDER, dst, src[0], src[1]);
break;
case SHADER_OPCODE_TEX:
case SHADER_OPCODE_TXD:
case SHADER_OPCODE_TXF:
case SHADER_OPCODE_TXF_CMS:
case SHADER_OPCODE_TXF_MCS:
case SHADER_OPCODE_TXL:
case SHADER_OPCODE_TXS:
case SHADER_OPCODE_TG4:
case SHADER_OPCODE_TG4_OFFSET:
generate_tex(ir, dst);
break;
case VS_OPCODE_URB_WRITE:
generate_urb_write(ir, true);
break;
case SHADER_OPCODE_GEN4_SCRATCH_READ:
generate_scratch_read(ir, dst, src[0]);
break;
case SHADER_OPCODE_GEN4_SCRATCH_WRITE:
generate_scratch_write(ir, dst, src[0], src[1]);
break;
case VS_OPCODE_PULL_CONSTANT_LOAD:
case VS_OPCODE_PULL_CONSTANT_LOAD_GEN7:
generate_pull_constant_load(ir, dst, src[0], src[1]);
break;
case GS_OPCODE_URB_WRITE:
generate_urb_write(ir, false);
break;
case GS_OPCODE_THREAD_END:
generate_gs_thread_end(ir);
break;
case GS_OPCODE_SET_WRITE_OFFSET:
generate_gs_set_write_offset(dst, src[0], src[1]);
break;
case GS_OPCODE_SET_VERTEX_COUNT:
generate_gs_set_vertex_count(dst, src[0]);
break;
case GS_OPCODE_SET_DWORD_2_IMMED:
generate_gs_set_dword_2_immed(dst, src[0]);
break;
case GS_OPCODE_PREPARE_CHANNEL_MASKS:
generate_gs_prepare_channel_masks(dst);
break;
case GS_OPCODE_SET_CHANNEL_MASKS:
generate_gs_set_channel_masks(dst, src[0]);
break;
case SHADER_OPCODE_SHADER_TIME_ADD:
assert(!"XXX: Missing Gen8 vec4 support for INTEL_DEBUG=shader_time");
break;
case SHADER_OPCODE_UNTYPED_ATOMIC:
assert(!"XXX: Missing Gen8 vec4 support for UNTYPED_ATOMIC");
break;
case SHADER_OPCODE_UNTYPED_SURFACE_READ:
assert(!"XXX: Missing Gen8 vec4 support for UNTYPED_SURFACE_READ");
break;
case VS_OPCODE_UNPACK_FLAGS_SIMD4X2:
assert(!"VS_OPCODE_UNPACK_FLAGS_SIMD4X2 should not be used on Gen8+.");
break;
default:
if (ir->opcode < (int) ARRAY_SIZE(opcode_descs)) {
_mesa_problem(ctx, "Unsupported opcode in `%s' in VS\n",
opcode_descs[ir->opcode].name);
} else {
_mesa_problem(ctx, "Unsupported opcode %d in VS", ir->opcode);
}
abort();
}
}
/***********************************************************************
* NE_LoadSegment
*/
BOOL NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
{
WORD count;
DWORD pos;
const struct relocation_entry_s *rep;
int size;
SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
SEGTABLEENTRY *pSeg = pSegTable + segnum - 1;
if (pSeg->flags & NE_SEGFLAGS_LOADED)
{
/* self-loader ? -> already loaded it */
if (pModule->ne_flags & NE_FFLAGS_SELFLOAD)
return TRUE;
/* leave, except for DGROUP, as this may be the second instance */
if (segnum != pModule->ne_autodata)
return TRUE;
}
if (!pSeg->filepos) return TRUE; /* No file image, just return */
TRACE_(module)("Loading segment %d, hSeg=%04x, flags=%04x\n",
segnum, pSeg->hSeg, pSeg->flags );
pos = pSeg->filepos << pModule->ne_align;
if (pSeg->size) size = pSeg->size;
else size = pSeg->minsize ? pSeg->minsize : 0x10000;
if (pModule->ne_flags & NE_FFLAGS_SELFLOAD && segnum > 1)
{
/* Implement self-loading segments */
SELFLOADHEADER *selfloadheader;
void *oldstack;
HFILE16 hFile16;
WORD args[3];
DWORD ret;
selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg),0) );
oldstack = getWOW32Reserved();
setWOW32Reserved((void *)MAKESEGPTR(pModule->self_loading_sel,
0xff00 - sizeof(STACK16FRAME)));
hFile16 = NE_OpenFile( pModule );
TRACE_(dll)("Call LoadAppSegProc(hmodule=0x%04x,hf=%x,segnum=%d)\n",
pModule->self,hFile16,segnum );
args[2] = pModule->self;
args[1] = hFile16;
args[0] = segnum;
WOWCallback16Ex( (DWORD)selfloadheader->LoadAppSeg, WCB16_PASCAL, sizeof(args), args, &ret );
pSeg->hSeg = LOWORD(ret);
TRACE_(dll)("Ret LoadAppSegProc: hSeg=0x%04x\n", pSeg->hSeg);
_lclose16( hFile16 );
setWOW32Reserved(oldstack);
pSeg->flags |= NE_SEGFLAGS_LOADED;
return TRUE;
}
else if (!(pSeg->flags & NE_SEGFLAGS_ITERATED))
{
void *mem = GlobalLock16(pSeg->hSeg);
if (!NE_READ_DATA( pModule, mem, pos, size ))
return FALSE;
pos += size;
}
else
{
/*
The following bit of code for "iterated segments" was written without
any documentation on the format of these segments. It seems to work,
but may be missing something.
*/
const char *buff = NE_GET_DATA( pModule, pos, size );
const char* curr = buff;
char *mem = GlobalLock16(pSeg->hSeg);
pos += size;
if (buff == NULL) return FALSE;
while(curr < buff + size) {
unsigned int rept = ((const short *)curr)[0];
unsigned int len = ((const short *)curr)[1];
curr += 2*sizeof(short);
while (rept--)
{
memcpy( mem, curr, len );
mem += len;
}
curr += len;
}
}
pSeg->flags |= NE_SEGFLAGS_LOADED;
/* Perform exported function prolog fixups */
NE_FixupSegmentPrologs( pModule, segnum );
if (!(pSeg->flags & NE_SEGFLAGS_RELOC_DATA))
return TRUE; /* No relocation data, we are done */
if (!NE_READ_DATA( pModule, &count, pos, sizeof(count) ) || !count) return TRUE;
pos += sizeof(count);
TRACE("Fixups for %.*s, segment %d, hSeg %04x\n",
*((BYTE *)pModule + pModule->ne_restab),
(char *)pModule + pModule->ne_restab + 1,
segnum, pSeg->hSeg );
if (!(rep = NE_GET_DATA( pModule, pos, count * sizeof(struct relocation_entry_s) )))
return FALSE;
return apply_relocations( pModule, rep, count, segnum );
}
/***********************************************************************
* apply_relocations
*
* Apply relocations to a segment. Helper for NE_LoadSegment.
*/
static inline BOOL apply_relocations( NE_MODULE *pModule, const struct relocation_entry_s *rep,
int count, int segnum )
{
BYTE *func_name;
char buffer[256];
int i, ordinal;
WORD offset, *sp;
HMODULE16 module;
FARPROC16 address = 0;
HMODULE16 *pModuleTable = (HMODULE16 *)((char *)pModule + pModule->ne_modtab);
SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
SEGTABLEENTRY *pSeg = pSegTable + segnum - 1;
/*
* Go through the relocation table one entry at a time.
*/
for (i = 0; i < count; i++, rep++)
{
/*
* Get the target address corresponding to this entry.
*/
/* If additive, there is no target chain list. Instead, add source
and target */
int additive = rep->relocation_type & NE_RELFLAG_ADDITIVE;
switch (rep->relocation_type & 3)
{
case NE_RELTYPE_ORDINAL:
module = pModuleTable[rep->target1-1];
ordinal = rep->target2;
address = NE_GetEntryPoint( module, ordinal );
if (!address)
{
NE_MODULE *pTarget = NE_GetPtr( module );
if (!pTarget)
WARN_(module)("Module not found: %04x, reference %d of module %*.*s\n",
module, rep->target1,
*((BYTE *)pModule + pModule->ne_restab),
*((BYTE *)pModule + pModule->ne_restab),
(char *)pModule + pModule->ne_restab + 1 );
else
{
ERR("No implementation for %.*s.%d, setting to 0xdeadbeef\n",
*((BYTE *)pTarget + pTarget->ne_restab),
(char *)pTarget + pTarget->ne_restab + 1,
ordinal );
address = (FARPROC16)0xdeadbeef;
}
}
if (TRACE_ON(fixup))
{
NE_MODULE *pTarget = NE_GetPtr( module );
TRACE("%d: %.*s.%d=%04x:%04x %s\n", i + 1,
*((BYTE *)pTarget + pTarget->ne_restab),
(char *)pTarget + pTarget->ne_restab + 1,
ordinal, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
}
break;
case NE_RELTYPE_NAME:
module = pModuleTable[rep->target1-1];
func_name = (BYTE *)pModule + pModule->ne_imptab + rep->target2;
memcpy( buffer, func_name+1, *func_name );
buffer[*func_name] = '\0';
ordinal = NE_GetOrdinal( module, buffer );
address = NE_GetEntryPoint( module, ordinal );
if (ERR_ON(fixup) && !address)
{
NE_MODULE *pTarget = NE_GetPtr( module );
ERR("No implementation for %.*s.%s, setting to 0xdeadbeef\n",
*((BYTE *)pTarget + pTarget->ne_restab),
(char *)pTarget + pTarget->ne_restab + 1, buffer );
}
if (!address) address = (FARPROC16) 0xdeadbeef;
if (TRACE_ON(fixup))
{
NE_MODULE *pTarget = NE_GetPtr( module );
TRACE("%d: %.*s.%s=%04x:%04x %s\n", i + 1,
*((BYTE *)pTarget + pTarget->ne_restab),
(char *)pTarget + pTarget->ne_restab + 1,
buffer, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
}
break;
case NE_RELTYPE_INTERNAL:
if ((rep->target1 & 0xff) == 0xff)
{
address = NE_GetEntryPoint( pModule->self, rep->target2 );
}
else
{
address = (FARPROC16)MAKESEGPTR( SEL(pSegTable[rep->target1-1].hSeg), rep->target2 );
}
TRACE("%d: %04x:%04x %s\n",
i + 1, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
break;
case NE_RELTYPE_OSFIXUP:
/* Relocation type 7:
*
* These appear to be used as fixups for the Windows
* floating point emulator. Let's just ignore them and
* try to use the hardware floating point. Linux should
* successfully emulate the coprocessor if it doesn't
* exist.
*/
TRACE("%d: TYPE %d, OFFSET %04x, TARGET %04x %04x %s\n",
i + 1, rep->relocation_type, rep->offset,
rep->target1, rep->target2,
NE_GetRelocAddrName( rep->address_type, additive ) );
continue;
}
offset = rep->offset;
/* Apparently, high bit of address_type is sometimes set; */
/* we ignore it for now */
if (rep->address_type > NE_RADDR_OFFSET32)
{
char module[10];
GetModuleName16( pModule->self, module, sizeof(module) );
ERR("WARNING: module %s: unknown reloc addr type = 0x%02x. Please report.\n",
module, rep->address_type );
}
if (additive)
{
sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
TRACE(" %04x:%04x\n", offset, *sp );
switch (rep->address_type & 0x7f)
{
case NE_RADDR_LOWBYTE:
*(BYTE *)sp += LOBYTE((int)address);
break;
case NE_RADDR_OFFSET16:
*sp += LOWORD(address);
break;
case NE_RADDR_POINTER32:
*sp += LOWORD(address);
*(sp+1) = HIWORD(address);
break;
case NE_RADDR_SELECTOR:
/* Borland creates additive records with offset zero. Strange, but OK */
if (*sp)
ERR("Additive selector to %04x.Please report\n",*sp);
else
*sp = HIWORD(address);
break;
default:
goto unknown;
}
}
else /* non-additive fixup */
{
do
{
WORD next_offset;
sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
next_offset = *sp;
TRACE(" %04x:%04x\n", offset, *sp );
switch (rep->address_type & 0x7f)
{
case NE_RADDR_LOWBYTE:
*(BYTE *)sp = LOBYTE((int)address);
break;
case NE_RADDR_OFFSET16:
*sp = LOWORD(address);
break;
case NE_RADDR_POINTER32:
*(FARPROC16 *)sp = address;
break;
case NE_RADDR_SELECTOR:
*sp = SELECTOROF(address);
break;
default:
goto unknown;
}
if (next_offset == offset) break; /* avoid infinite loop */
if (next_offset >= GlobalSize16(pSeg->hSeg)) break;
offset = next_offset;
} while (offset != 0xffff);
}
}
return TRUE;
unknown:
WARN("WARNING: %d: unknown ADDR TYPE %d, "
"TYPE %d, OFFSET %04x, TARGET %04x %04x\n",
i + 1, rep->address_type, rep->relocation_type,
rep->offset, rep->target1, rep->target2);
return FALSE;
}
wySQLFileTestLayer() {
createButton("Execute SQL File", this, wyDevice::winWidth / 2, wyDevice::winHeight / 2,
wyTargetSelector::make(this, SEL(wySQLFileTestLayer::onExecute)));
createButton("Delete Database", this, wyDevice::winWidth / 2, wyDevice::winHeight / 2 - DP(80),
wyTargetSelector::make(this, SEL(wySQLFileTestLayer::onDelete)));
}
/***********************************************************************
* NE_LoadSegment
*/
BOOL NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
{
SEGTABLEENTRY *pSegTable, *pSeg;
WORD *pModuleTable;
WORD count, i, offset, next_offset;
HMODULE16 module;
FARPROC16 address = 0;
HFILE hf;
DWORD res;
struct relocation_entry_s *rep, *reloc_entries;
char *func_name;
int size;
char* mem;
char buffer[256];
int ordinal, additive;
unsigned short *sp;
pSegTable = NE_SEG_TABLE( pModule );
pSeg = pSegTable + segnum - 1;
if (pSeg->flags & NE_SEGFLAGS_LOADED)
{
/* self-loader ? -> already loaded it */
if (pModule->flags & NE_FFLAGS_SELFLOAD)
return TRUE;
/* leave, except for DGROUP, as this may be the second instance */
if (segnum != pModule->dgroup)
return TRUE;
}
if (!pSeg->filepos) return TRUE; /* No file image, just return */
pModuleTable = NE_MODULE_TABLE( pModule );
hf = NE_OpenFile( pModule );
TRACE_(module)("Loading segment %d, hSeg=%04x, flags=%04x\n",
segnum, pSeg->hSeg, pSeg->flags );
SetFilePointer( hf, pSeg->filepos << pModule->alignment, NULL, SEEK_SET );
if (pSeg->size) size = pSeg->size;
else size = pSeg->minsize ? pSeg->minsize : 0x10000;
mem = GlobalLock16(pSeg->hSeg);
if (pModule->flags & NE_FFLAGS_SELFLOAD && segnum > 1)
{
/* Implement self-loading segments */
SELFLOADHEADER *selfloadheader;
DWORD oldstack;
HANDLE hFile32;
HFILE16 hFile16;
selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg),0) );
oldstack = NtCurrentTeb()->WOW32Reserved;
NtCurrentTeb()->WOW32Reserved = MAKESEGPTR(pModule->self_loading_sel,
0xff00 - sizeof(STACK16FRAME));
TRACE_(dll)("CallLoadAppSegProc(hmodule=0x%04x,hf=0x%04x,segnum=%d\n",
pModule->self,hf,segnum );
DuplicateHandle( GetCurrentProcess(), hf, GetCurrentProcess(), &hFile32,
0, FALSE, DUPLICATE_SAME_ACCESS );
hFile16 = Win32HandleToDosFileHandle( hFile32 );
pSeg->hSeg = NE_CallTo16_word_www( selfloadheader->LoadAppSeg,
pModule->self, hFile16, segnum );
TRACE_(dll)("Ret CallLoadAppSegProc: hSeg = 0x%04x\n", pSeg->hSeg);
_lclose16( hFile16 );
NtCurrentTeb()->WOW32Reserved = oldstack;
}
else if (!(pSeg->flags & NE_SEGFLAGS_ITERATED))
ReadFile(hf, mem, size, &res, NULL);
else {
/*
The following bit of code for "iterated segments" was written without
any documentation on the format of these segments. It seems to work,
but may be missing something. If you have any doc please either send
it to me or fix the code yourself. [email protected]
*/
char* buff = HeapAlloc(GetProcessHeap(), 0, size);
char* curr = buff;
if(buff == NULL) {
WARN_(dll)("Memory exausted!");
return FALSE;
}
ReadFile(hf, buff, size, &res, NULL);
while(curr < buff + size) {
unsigned int rept = *((short*) curr);
curr = (char *)(((short*) curr) + 1);
unsigned int len = *((short*) curr);
curr = (char *)(((short*) curr) + 1);
for(; rept > 0; rept--) {
char* bytes = curr;
unsigned int byte;
for(byte = 0; byte < len; byte++)
*mem++ = *bytes++;
}
curr += len;
}
HeapFree(GetProcessHeap(), 0, buff);
}
pSeg->flags |= NE_SEGFLAGS_LOADED;
/* Perform exported function prolog fixups */
NE_FixupSegmentPrologs( pModule, segnum );
if (!(pSeg->flags & NE_SEGFLAGS_RELOC_DATA))
return TRUE; /* No relocation data, we are done */
ReadFile(hf, &count, sizeof(count), &res, NULL);
if (!count) return TRUE;
TRACE_(fixup)("Fixups for %.*s, segment %d, hSeg %04x\n",
*((BYTE *)pModule + pModule->name_table),
(char *)pModule + pModule->name_table + 1,
segnum, pSeg->hSeg );
TRACE_(segment)("Fixups for %.*s, segment %d, hSeg %04x\n",
*((BYTE *)pModule + pModule->name_table),
(char *)pModule + pModule->name_table + 1,
segnum, pSeg->hSeg );
reloc_entries = (struct relocation_entry_s *)HeapAlloc(GetProcessHeap(), 0, count * sizeof(struct relocation_entry_s));
if(reloc_entries == NULL) {
WARN_(fixup)("Not enough memory for relocation entries!");
return FALSE;
}
if (!ReadFile( hf, reloc_entries, count * sizeof(struct relocation_entry_s), &res, NULL) ||
(res != count * sizeof(struct relocation_entry_s)))
{
WARN_(fixup)("Unable to read relocation information\n" );
return FALSE;
}
/*
* Go through the relocation table one entry at a time.
*/
rep = reloc_entries;
for (i = 0; i < count; i++, rep++)
{
/*
* Get the target address corresponding to this entry.
*/
/* If additive, there is no target chain list. Instead, add source
and target */
additive = rep->relocation_type & NE_RELFLAG_ADDITIVE;
rep->relocation_type &= 0x3;
switch (rep->relocation_type)
{
case NE_RELTYPE_ORDINAL:
module = pModuleTable[rep->target1-1];
ordinal = rep->target2;
address = NE_GetEntryPoint( module, ordinal );
if (!address)
{
NE_MODULE *pTarget = NE_GetPtr( module );
if (!pTarget)
WARN_(module)("Module not found: %04x, reference %d of module %*.*s\n",
module, rep->target1,
*((BYTE *)pModule + pModule->name_table),
*((BYTE *)pModule + pModule->name_table),
(char *)pModule + pModule->name_table + 1 );
else
{
ERR_(fixup)("No implementation for %.*s.%d, setting to 0xdeadbeef\n",
*((BYTE *)pTarget + pTarget->name_table),
(char *)pTarget + pTarget->name_table + 1,
ordinal );
address = (FARPROC16)0xdeadbeef;
}
}
if (TRACE_ON(fixup))
{
NE_MODULE *pTarget = NE_GetPtr( module );
TRACE_(fixup)("%d: %.*s.%d=%04x:%04x %s\n", i + 1,
*((BYTE *)pTarget + pTarget->name_table),
(char *)pTarget + pTarget->name_table + 1,
ordinal, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
}
break;
case NE_RELTYPE_NAME:
module = pModuleTable[rep->target1-1];
func_name = (char *)pModule + pModule->import_table + rep->target2;
memcpy( buffer, func_name+1, *func_name );
buffer[(BYTE)*func_name] = '\0';
func_name = buffer;
ordinal = NE_GetOrdinal( module, func_name );
address = NE_GetEntryPoint( module, ordinal );
if (ERR_ON(fixup) && !address)
{
NE_MODULE *pTarget = NE_GetPtr( module );
ERR_(fixup)("No implementation for %.*s.%s, setting to 0xdeadbeef\n",
*((BYTE *)pTarget + pTarget->name_table),
(char *)pTarget + pTarget->name_table + 1, func_name );
}
if (!address) address = (FARPROC16) 0xdeadbeef;
if (TRACE_ON(fixup))
{
NE_MODULE *pTarget = NE_GetPtr( module );
TRACE_(fixup)("%d: %.*s.%s=%04x:%04x %s\n", i + 1,
*((BYTE *)pTarget + pTarget->name_table),
(char *)pTarget + pTarget->name_table + 1,
func_name, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
}
break;
case NE_RELTYPE_INTERNAL:
if ((rep->target1 & 0xff) == 0xff)
{
address = NE_GetEntryPoint( pModule->self, rep->target2 );
}
else
{
address = (FARPROC16)MAKESEGPTR( SEL(pSegTable[rep->target1-1].hSeg), rep->target2 );
}
TRACE_(fixup)("%d: %04x:%04x %s\n",
i + 1, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
break;
case NE_RELTYPE_OSFIXUP:
/* Relocation type 7:
*
* These appear to be used as fixups for the Windows
* floating point emulator. Let's just ignore them and
* try to use the hardware floating point. Linux should
* successfully emulate the coprocessor if it doesn't
* exist.
*/
TRACE_(fixup)("%d: TYPE %d, OFFSET %04x, TARGET %04x %04x %s\n",
i + 1, rep->relocation_type, rep->offset,
rep->target1, rep->target2,
NE_GetRelocAddrName( rep->address_type, additive ) );
continue;
}
offset = rep->offset;
/* Apparently, high bit of address_type is sometimes set; */
/* we ignore it for now */
if (rep->address_type > NE_RADDR_OFFSET32)
{
char module[10];
GetModuleName16( pModule->self, module, sizeof(module) );
ERR_(fixup)("WARNING: module %s: unknown reloc addr type = 0x%02x. Please report.\n",
module, rep->address_type );
}
if (additive)
{
sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
TRACE_(fixup)(" %04x:%04x\n", offset, *sp );
switch (rep->address_type & 0x7f)
{
case NE_RADDR_LOWBYTE:
*(BYTE *)sp += LOBYTE((int)address);
break;
case NE_RADDR_OFFSET16:
*sp += LOWORD(address);
break;
case NE_RADDR_POINTER32:
*sp += LOWORD(address);
*(sp+1) = HIWORD(address);
break;
case NE_RADDR_SELECTOR:
/* Borland creates additive records with offset zero. Strange, but OK */
if (*sp)
ERR_(fixup)("Additive selector to %04x.Please report\n",*sp);
else
*sp = HIWORD(address);
break;
default:
goto unknown;
}
}
else /* non-additive fixup */
{
do
{
sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
next_offset = *sp;
TRACE_(fixup)(" %04x:%04x\n", offset, *sp );
switch (rep->address_type & 0x7f)
{
case NE_RADDR_LOWBYTE:
*(BYTE *)sp = LOBYTE((int)address);
break;
case NE_RADDR_OFFSET16:
*sp = LOWORD(address);
break;
case NE_RADDR_POINTER32:
*(FARPROC16 *)sp = address;
break;
case NE_RADDR_SELECTOR:
*sp = SELECTOROF(address);
break;
default:
goto unknown;
}
if (next_offset == offset) break; /* avoid infinite loop */
if (next_offset >= GlobalSize16(pSeg->hSeg)) break;
offset = next_offset;
} while (offset != 0xffff);
}
}
HeapFree(GetProcessHeap(), 0, reloc_entries);
return TRUE;
unknown:
WARN_(fixup)("WARNING: %d: unknown ADDR TYPE %d, "
"TYPE %d, OFFSET %04x, TARGET %04x %04x\n",
i + 1, rep->address_type, rep->relocation_type,
rep->offset, rep->target1, rep->target2);
HeapFree(GetProcessHeap(), 0, reloc_entries);
return FALSE;
}
/* MoveToInstalled()
* ====================================================================
* Move any Available fonts to the Installed List.
* type -> 0 -> USE Available list CALLS
* -> 1 -> Skip available list calls
*/
void
MoveToInstalled( int flag )
{
FON_PTR curptr;
FON_PTR xcurptr;
int index;
curptr = available_list;
/* Try to maintain the top node displayed to remain that way if
* at all possible.
*/
xcurptr = Active_Slit[ 0 ];
if( curptr && xcurptr )
index = Get_Findex( curptr, xcurptr );
/* Go through the list looking for selected nodes ( AFLAG == TRUE )
* and set their SEL() to FALSE.
* Where SEL == TRUE means installed. and SEL == FALSE means
* available.
* Set MakeWidth Tables flag if moving Outline Fonts TO INSTALLED!
*/
while( curptr )
{
if( AFLAG( curptr ) )
{
if( FTYPE( curptr ) == SPD_FONT )
MakeWidthFlag = TRUE;
SEL( curptr ) = TRUE;
}
curptr = FNEXT( curptr );
}
/* Now, fix up the linked list for both the
* available and installed fonts.
*/
free_arena_links();
installed_count = build_list( &installed_list, &installed_last, ACTIVE );
available_count = build_list( &available_list, &available_last, INACTIVE );
/* Prompt to save SYS files */
SetChangeFlag();
if( !flag )
{
mover_setup( available_list, available_count,
IBASE, ISLIDER, IUP, IDOWN,
ILINE0, ILINE13, ILINE, index, INACTIVE_HEIGHT );
RedrawObject( tree, IBASE );
Objc_draw( tree, ILINE, MAX_DEPTH, NULL );
if( !IsDisabled( IINSTALL ) )
ChangeButton( ad_inactive, IINSTALL, FALSE );
if( !IsDisabled( ICONFIG ) )
ChangeButton( ad_inactive, ICONFIG, FALSE );
CheckSelectAll( TRUE );
}
}
