static int Outcode(double x, double y, const struct LineClipping_Rectangle *r) /*returns the outcode for point (x, y) in relation to rectangle r*/
{
int result;
result = 0; /*empty set*/
if (x < r->xMin) {
Include(LEFT, &result);
} else if (x > r->xMax) {
Include(RIGHT, &result);
}
if (y < r->yMin) {
Include(BOTTOM, &result);
} else if (y > r->yMax) {
Include(TOP, &result);
}
return result;
}
Region& Region::Include(const Region ®ion)
{
BeginOperation();
for (int i = 0; i < region.CountRects(); i++)
Include(region.RectAt(i));
EndOperation();
return *this;
}
void CFunctionProfiler::FunctionEnter2(
/*[in]*/FunctionID funcID,
/*[in]*/UINT_PTR clientData,
/*[in]*/COR_PRF_FRAME_INFO func,
/*[in]*/COR_PRF_FUNCTION_ARGUMENT_INFO *argumentInfo)
{
ThreadID threadId;
m_profilerInfo2->GetCurrentThreadID(&threadId);
DWORD windowThreadId;
m_profilerInfo2->GetThreadInfo(threadId, &windowThreadId);
CComCritSecLock<CComAutoCriticalSection> lock(m_cs);
FunctionInfo & fi = m_functions[clientData];
if (!fi.trace) return;
if (!fi.assigned)
{
fi.assigned = true;
std::wstring szMethodName;
GetMetadataFullMethodName(funcID, func, szMethodName);
bool temp;
if (!Include(szMethodName, &temp)) {fi.trace=false; return; }
GetMetadataFullMethodNameWithSignature(funcID, func, fi.metadataSignature);
}
std::wstring runtimeSignature;
GetRuntimeFullMethodSignature(funcID, func, runtimeSignature);
CScopedLock<CMutex> lock2(m_hProcessMutex);
m_currentBuffer = m_formatBuffer + (*((DWORD*)m_pView));
BYTE type = 1;
double elapsed = m_timer.Elapsed();
Write(type);
Write(m_sequence);
Write(elapsed);
Write(windowThreadId);
Write<ULONGLONG>(funcID);
m_sequence++;
DWORD len1 = (DWORD)runtimeSignature.length();
Write(len1);
memcpy(m_currentBuffer, runtimeSignature.c_str(), len1 * 2);
m_currentBuffer += (len1 * 2);
DWORD len2 = (DWORD)fi.metadataSignature.length();
Write(len2);
memcpy(m_currentBuffer, fi.metadataSignature.c_str(), len2 * 2);
m_currentBuffer += (len2 * 2);
WriteData();
}
BOOL mrShaderFilter::Validate(PB2Value& v) {
ReferenceTarget* refTarg = v.r;
if((refTarg != NULL) && IsMtlBase(refTarg)) {
MtlBase* mtlBase = static_cast<MtlBase*>(refTarg);
return Include(*mtlBase, 0);
}
else {
// Null values are acceptable
return TRUE;
}
}
bool mrShaderFilter::Include(MtlBase& mtlBase, DWORD flags) {
// Validate using the class ID
ClassDesc* classDesc = GetCOREInterface()->GetDllDir().ClassDir().FindClass(mtlBase.SuperClassID(), mtlBase.ClassID());
DbgAssert(classDesc != NULL);
if(classDesc != NULL) {
return Include(*classDesc, flags);
}
else {
return true;
}
}
void FillPolygon (polygon_type &polygon, edge_list_type &list )
{
int Edges , start_Edge , end_Edge , scan;
LoadPolygon(polygon,list, Edges);
if (Edges==2) return;
scan = list.edge[1].Ymax ;
start_Edge = 1 ;
end_Edge = 1 ;
Include(list, end_Edge, Edges, scan);
while ( end_Edge != start_Edge - 1 )
{
XSort(list, start_Edge, end_Edge);
FillScan(list, end_Edge, start_Edge, scan);
scan--;
UpdateXValues(list, end_Edge, start_Edge, scan);
Include(list, end_Edge, Edges, scan);
}
}
void ProcInclude( void )
{
int old_srcrecnum;
ComPrint();
if( strlen( SrcBuff ) > LastColumn ) {
SrcBuff[ LastColumn ] = NULLCHAR;
}
old_srcrecnum = SrcRecNum;
SrcRecNum = CurrFile->rec; // in case we get an error processing INCLUDE
Include( SkipBlanks( &SrcBuff[ 10 ] ) );
SrcRecNum = old_srcrecnum;
}
void main()
{
char cArray[200][200],cTemp[200],cReverse[200];
int iCaseNum,iStringNum,i,j,k;
bool bFound;
cin>>iCaseNum;
while(iCaseNum--)
{
cin>>iStringNum;
for(i=0;i<iStringNum;i++)
cin>>cArray[i];
if(iStringNum==1)
{
cout<<strlen(cArray[0])<<endl;
continue;
}
bFound=false;
for(i=strlen(cArray[0]);i>=1;i--)
for(j=0;j<=strlen(cArray[0])-i;j++)
{
for(k=0;k<i;k++)
cReverse[i-k-1]=cTemp[k]=cArray[0][j+k];
cTemp[i]=cReverse[i]='\0';
bFound=true;
for(k=1;k<iStringNum;k++)
if(!Include(cArray[k],cTemp) && !Include(cArray[k],cReverse))
{
bFound=false;
break;
}
if(bFound)
goto OUT;
}
OUT:
cout<<i<<endl;
}
}
CfgPreprocessor::CfgPreprocessor(const char *path)
{
const char *p = path;
while(*p) p++;
while(p>path && *p!='/' && *p!='\\') p--;
if(*p=='/' || *p=='\\') p++;
base_dir.assign(path,p-path);
files.clear();
current = NULL;
read_pos = NULL;
read_size = 0;
Include(p);
}
EXPORT void DIRECT::Add(DIRECT &Dir, double MKA[9], WORD Qntt, WORD NewNum[])
{
DIRECT_LIST * DirLst;
WORD i, k, n;
double Matr[9];
for ( i=0; i<Dir.GetQuantityDirect(); i++ ) {
DirLst = (DIRECT_LIST*)&Dir.pDIRECT[i];
for ( k=0; k<DirLst->Quantity; k++ ) {
n = DirLst->List[k];
if ( n && n <= Qntt ) DirLst->List[k] = NewNum[n];
}
MultMatr(MKA,DirLst->MatrCos,3,3,3,Matr);
Include(Matr,DirLst->Type,DirLst->Quantity,DirLst->List);
}
}
void FUBoundingSphere::Include(const FUBoundingBox& boundingBox)
{
if (radius >= 0.0f)
{
FUBOUNDINGBOX_COORDINATES(coordinates, boundingBox);
for (size_t i = 0; i < FUBOUNDINGBOX_COORDINATE_COUNT; ++i)
{
Include(coordinates[i]);
}
}
else
{
center = boundingBox.GetCenter();
radius = (boundingBox.GetMax() - center).Length();
}
}
bool
CLxItemSelection::GetFirst (
CLxUser_Item &item)
{
LXtScanInfoID scan;
void *pkt;
scan = 0;
while (scan = srv_sel.ScanLoop (scan, sel_ID, &pkt)) {
pkt_trans.GetItem (pkt, item);
if (Include (item))
return true;
}
return false;
}
void
CLxItemSelection::GetList (
ItemList &list)
{
CLxUser_Item item;
LXtScanInfoID scan;
void *pkt;
list.clear ();
scan = 0;
while (scan = srv_sel.ScanLoop (scan, sel_ID, &pkt)) {
pkt_trans.GetItem (pkt, item);
if (Include (item))
list.push_back (item);
}
}
void
CLxItemSelection::GetSet (
ItemSet &set)
{
CLxUser_Item item;
LXtScanInfoID scan;
void *pkt;
set.clear ();
scan = 0;
while (scan = srv_sel.ScanLoop (scan, sel_ID, &pkt)) {
pkt_trans.GetItem (pkt, item);
if (Include (item))
set.insert (item);
}
}
int IpsiusService::NObjBoardFilter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
typedef Domain::NamedObject QMocSuperClass;
_id = QMocSuperClass::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: Include((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 1: Exclude((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 2: Clear(); break;
default: ;
}
_id -= 3;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QString*>(_v) = getExclude(); break;
case 1: *reinterpret_cast< QString*>(_v) = getInclude(); break;
}
_id -= 2;
} else if (_c == QMetaObject::WriteProperty) {
_id -= 2;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 2;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 2;
}
#endif // QT_NO_PROPERTIES
return _id;
}
int main(void) {
int a[100000][2];
int n, i, j;
int flag;
int ans;
scanf("%d", &n);
for(i = 0; i < n; i++)
scanf("%d%d", &a[i][0], &a[i][1]);
ans = 0;
for(i = 0; i < n; i++) {
for(j = 0; j < n; j++)
if(Include(a, i, j)) {
ans++;
break;
}
}
printf("%d\n", ans);
return 0;
}
void
CLxVertexMapSelection::GetList (
MapList &list)
{
LXtScanInfoID scan;
MapInfo info;
const char *str;
void *pkt;
scan = 0;
while (scan = srv_sel.ScanLoop (scan, sel_ID, &pkt)) {
pkt_trans.Type (pkt, &info.type);
if (!Include (info.type))
continue;
pkt_trans.Name (pkt, &str);
info.name = str;
list.push_back (info);
}
}
void CpInclude(void) {
//===================
// Process INCLUDE statement.
// INCLUDE 'file-name'
char *lit;
StmtExtension( SP_STRUCTURED_EXT );
if( RecLiteral() ) {
lit = MkNodeStr( CITNode );
AdvanceITPtr();
if( ReqEOS() ) {
Include( lit );
ComRead();
}
FrNodeStr( lit );
} else {
Error( SX_EXPECT_CHAR_CONST );
}
}
bool
CLxVertexMapSelection::First (
std::string &name)
{
LXtScanInfoID scan;
LXtID4 type;
const char *str;
void *pkt;
scan = 0;
while (scan = srv_sel.ScanLoop (scan, sel_ID, &pkt)) {
pkt_trans.Type (pkt, &type);
if (!Include (type))
continue;
pkt_trans.Name (pkt, &str);
name = str;
return true;
}
return false;
}
// 高角砲ならtrue
bool Weapon::IsHAG() const noexcept {
return Include(L"高角砲");
}
void csRectRegionDebug::UnitTest()
{
csPrintf("Running tests");
int i,j;
csRectRegion rr;
rr.makeEmpty();
MakeEmpty();
AssertEqual(rr);
// include test
for(i= 0; i < 500; i++)
{
csRect r = RandNonEmptyRect();
rr.Include(r);
Include(r);
AssertEqual(rr);
}
rr.makeEmpty();
MakeEmpty();
AssertEqual(rr);
for(i = 0; i < 500; i++)
{
csRect r = RandRect();
rr.Include(r);
Include(r);
AssertEqual(rr);
}
rr.makeEmpty();
MakeEmpty();
AssertEqual(rr);
//exclude test
csRect r(0,0,CS_RECT_REG_SIZE,CS_RECT_REG_SIZE);
Include(r);
rr.Include(r);
AssertEqual(rr);
for(i = 0; i < 500; i++)
{
csRect r = RandRect();
rr.Exclude(r);
Exclude(r);
AssertEqual(rr);
}
csRect r1(0,0,CS_RECT_REG_SIZE,CS_RECT_REG_SIZE);
Include(r1);
rr.Include(r1);
AssertEqual(rr);
for(i = 0; i < 500; i++)
{
csRect r = RandNonEmptyRect();
rr.Exclude(r);
Exclude(r);
AssertEqual(rr);
}
// Clip test
rr.makeEmpty();
MakeEmpty();
AssertEqual(rr);
for(i = 0; i < 100; i++)
{
for(j = 0; j < 50; j++)
{
csRect r = RandNonEmptyRect();
rr.Include(r);
Include(r);
}
csRect r = RandNonEmptyRect();
ClipTo(r);
rr.ClipTo(r);
AssertEqual(rr);
}
rr.makeEmpty();
MakeEmpty();
AssertEqual(rr);
for(i = 0; i < 10; i++)
{
for(j = 0; j < 50; j++)
{
csRect r = RandRect();
rr.Include(r);
Include(r);
}
csRect r = RandRect();
ClipTo(r);
rr.ClipTo(r);
AssertEqual(rr);
}
// intermixed op test
rr.makeEmpty();
MakeEmpty();
AssertEqual(rr);
for(i = 0; i < 50000; i++)
{
if(i % 1000 == 0)
csPrintf(".");
unsigned int op = rand->Get(11);
csRect r = RandRect();
if(op < 5)
{
Include(r);
rr.Include(r);
}
else if(op < 10)
{
Exclude(r);
rr.Exclude(r);
}
else
{
ClipTo(r);
rr.ClipTo(r);
}
AssertEqual(rr);
}
csPrintf("Done\n");
}
/*
* Manual page at function.def
*/
INT16 CGEN_VPUBLIC CFunction::Include(const char* lpsFilename)
{
FNC_DELEGATE Include(lpsFilename); // Use a weird macro (see function.def)
return IncludeEx(lpsFilename,m_nPp); // Do include script
}
EXPORT void DATA_LOAD::Add( int QuantityElem, BYTE TypeElem[], FORCE_GROUP &FrcGrpInp, FORCE_VALUE *FrcVl, BYTE MaskQw, float Coef )
{
int i, j, n, k, te, ne, net, m, qw, qn, kzpm, iqw;
FORCE_LIST *FrcLst;
FORCE_TYPE *FrcTp;
FORCE_VALUE *FrcValue;
float *ForceV;
for ( i=0; i<FrcGrpInp.QuantityForceList; i++ ) {
FrcLst = &FrcGrpInp.ForceList[i];
for ( j=0; j<FrcLst->QuantityForce; j++ ) {
FrcTp = &FrcLst->Force[j];
qw = FrcTp->Qw; qn = FrcTp->Qn;
if ( MaskQw != 0xFF && qw != MaskQw ) continue;
FrcValue = (FORCE_VALUE*)&FrcVl[FrcTp->NumForceValue-1];
kzpm = FrcValue->QuantityValue;
ForceV = (float*) Memory(kzpm+1,sizeof(float));
memcpy(ForceV,FrcValue->Value,kzpm*(long)sizeof(float));
if ( TypeElem == NULL ) {
ForceV[0] *= Coef; goto _10; }
if ( FrcLst->NumNodeFe == 0 || FrcLst->NumNodeFe > QuantityElem )
continue;
ne = TypeElem[FrcLst->NumNodeFe-1];
net = ne % 100;
te = ElemType(ne);
iqw = qw % 10;
if ( te == 4 ) { // стеpжни
ForceV[0] *= Coef;
goto _10; }
if ( te == 1 || te == 4 ) { // стеpжни
ForceV[0] *= Coef;
if ( iqw == 7 && kzpm > 2 ) ForceV[2] *= Coef;
if ( iqw == 8 && qn > 1 && kzpm > 1 )
ForceV[1] *= Coef;
goto _10; }
if ( te == 2 || te == 5 || te == 6 || te == 7 ) { // пластины
if ( iqw == 9 || iqw == 0 ) {
for ( k=2; k<kzpm; k++ ) ForceV[k] *= Coef;
goto _10; }
ForceV[0] *= Coef;
if ( iqw < 7 ) goto _10;
if ( iqw == 7 ) {
for ( k=1; k<kzpm; k++ ) ForceV[k] *= Coef;
goto _10; }
if ( qw == 8 || qw == 18 ) {
if ( net > 40 && net <= 50 && kzpm > 1 && qn == 0 )
ForceV[1] *= Coef;
goto _10; }
if ( qw == 28 ) {
for ( k=1; k<kzpm-1; k++ ) ForceV[k] *= Coef;
goto _10; }
if ( qw == 38 ) {
if ( net > 40 && net <= 50 && kzpm > 1 ) ForceV[1] *= Coef;
goto _10; }
if ( qw == 48 ) {
for ( k=1; k<kzpm; k++ ) ForceV[k] *= Coef;
goto _10; }
if ( qw == 88 && kzpm > 1 ) {
ForceV[1] *= Coef; goto _10; }
}
if ( te == 3 ) {
ForceV[0] *= Coef;
if ( iqw == 8 ) {
m = 1;
if ( qw == 18 ) m = 3;
if ( qw == 38 || qw == 48 ) m = 0;
if ( m < kzpm ) for ( k=1; k<kzpm-m; k++ ) ForceV[k] *= Coef;
}
goto _10; }
_10: n = AddForceValue(1,kzpm,ForceV);
if ( n ) Include(FrcLst->NumNodeFe,qw,qn,n);
}
}
Modify = 1;
}
template <class Type> bool Box2d<Type>::Include(const Seg2d & s) const
{
return Include(SegComp(s));
}
template <class Type> bool Box2d<Type>::Include(const SegComp & s) const
{
return Include(s.p0()) && Include(s.p1());
}
// ***************************************************************************
// Function: AddMacroLine
// Description: Add a line to the MacroBlock
// ***************************************************************************
PMACROBLOCK AddMacroLine(PCHAR szLine)
{
PMACROBLOCK pBlock = NULL;
// replace all tabs with spaces
if ((szLine[0]==0) || (szLine[0]=='|')) return (PMACROBLOCK)1;
PDEFINE pDef = pDefines;
if (szLine[0]!='#') while (pDef) {
while (strstr(szLine,pDef->szName)) {
CHAR szNew[MAX_STRING] = {0};
strncpy(szNew,szLine,strstr(szLine,pDef->szName)-szLine);
strcat(szNew,pDef->szReplace);
strcat(szNew,strstr(szLine,pDef->szName)+strlen(pDef->szName));
strcpy(szLine,szNew);
}
pDef = pDef->pNext;
}
if (szLine[0]=='#') {
if (!strnicmp(szLine,"#include ",9)) {
CHAR Filename[MAX_STRING] = {0};
szLine+=8;
while (szLine[0]==' ') szLine++;
if (!strstr(szLine,".")) strcat(szLine,".mac");
sprintf(Filename,"%s\\%s",gszMacroPath, szLine);
//DebugSpewNoFile("AddMacroLine - Including file: %s",Filename);
return (PMACROBLOCK)Include(Filename);
} else if (!strnicmp(szLine,"#turbo",6)) {
gTurbo = TRUE;
CHAR szArg[MAX_STRING] = {0};
GetArg(szArg,szLine,2);
gMaxTurbo = atoi(szArg);
if (gMaxTurbo==0)
gMaxTurbo=20;
else if (gMaxTurbo>40)
{
MacroError("#turbo %d is too high, setting at 40 (maximum)",gMaxTurbo);
gMaxTurbo=40;
}
} else if (!strnicmp(szLine,"#define ",8)) {
CHAR szArg1[MAX_STRING] = {0};
CHAR szArg2[MAX_STRING] = {0};
PDEFINE pDef = (PDEFINE)malloc(sizeof(DEFINE));
GetArg(szArg1,szLine,2);
GetArg(szArg2,szLine,3);
if ((szArg1[0]!=0) && (szArg2[0]!=0)) {
strcpy(pDef->szName,szArg1);
strcpy(pDef->szReplace,szArg2);
pDef->pNext = pDefines;
pDefines = pDef;
} else {
MacroError("Bad #define: %s",szLine);
}
} else if (!strnicmp(szLine,"#event ",7)) {
CHAR szArg1[MAX_STRING] = {0};
CHAR szArg2[MAX_STRING] = {0};
PEVENTLIST pEvent = (PEVENTLIST)malloc(sizeof(EVENTLIST));
GetArg(szArg1,szLine,2);
GetArg(szArg2,szLine,3);
if ((szArg1[0]!=0) && (szArg2[0]!=0)) {
sprintf(pEvent->szName,"Sub Event_%s",szArg1);
strcpy(pEvent->szMatch,szArg2);
#ifdef USEBLECHEVENTS
pEvent->BlechID=pEventBlech->AddEvent(pEvent->szMatch,EventBlechCallback,pEvent);
#endif
pEvent->pEventFunc = NULL;
pEvent->pNext = pEventList;
pEventList = pEvent;
} else {
MacroError("Bad #event: %s",szLine);
}
} else if (!strnicmp(szLine,"#chat ",6)) {
szLine+=5;
while (szLine[0]==' ') szLine++;
if (!stricmp(szLine,"say")) gEventChat = gEventChat | CHAT_SAY;
if (!stricmp(szLine,"tell")) gEventChat = gEventChat | CHAT_TELL;
if (!stricmp(szLine,"ooc")) gEventChat = gEventChat | CHAT_OOC;
if (!stricmp(szLine,"shout")) gEventChat = gEventChat | CHAT_SHOUT;
if (!stricmp(szLine,"auc")) gEventChat = gEventChat | CHAT_AUC;
if (!stricmp(szLine,"guild")) gEventChat = gEventChat | CHAT_GUILD;
if (!stricmp(szLine,"group")) gEventChat = gEventChat | CHAT_GROUP;
if (!stricmp(szLine,"chat")) gEventChat = gEventChat | CHAT_CHAT;
} else if (szLine[1]=='!') {
// Like: #!/usr/local/bin/LegacyMQ2
// ignore.
} else {
MacroError("Unknown # command: %s",szLine);
return FALSE;
}
}
pBlock = (PMACROBLOCK)malloc(sizeof(MACROBLOCK));
if (!pBlock) return NULL;
//DebugSpewNoFile("AddMacroLine - Adding: %s",szLine);
strcpy(pBlock->Line,szLine);
pBlock->LineNumber = -1;
pBlock->SourceFile[0]=0;
pBlock->pNext=NULL;
pBlock->pPrev=NULL;
if ((!stricmp(szLine,"Sub Event_Chat")) || (!strnicmp(szLine,"Sub Event_Chat(",15))) {
gEventFunc[EVENT_CHAT] = pBlock;
} else if ((!stricmp(szLine,"Sub Event_Timer")) || (!strnicmp(szLine,"Sub Event_Timer(",16))) {
gEventFunc[EVENT_TIMER] = pBlock;
} else {
PEVENTLIST pEvent = pEventList;
while (pEvent) {
if (!stricmp(szLine,pEvent->szName)) {
pEvent->pEventFunc = pBlock;
} else {
CHAR szNameP[MAX_STRING] = {0};
sprintf(szNameP,"%s(",pEvent->szName);
if (!strnicmp(szLine,szNameP,strlen(szNameP))) {
pEvent->pEventFunc = pBlock;
}
}
pEvent = pEvent->pNext;
}
}
if (!gMacroBlock) {
gMacroBlock=pBlock;
} else {
PMACROBLOCK pLoop = gMacroBlock;
while (pLoop->pNext) pLoop = pLoop->pNext;
pLoop->pNext = pBlock;
pBlock->pPrev = pLoop;
}
return pBlock;
}
int directive( int i, long direct )
/* Handle all directives */
{
int ret;
/* no expansion on the following */
switch( direct ) {
case T_MASM:
Options.mode &= ~MODE_IDEAL;
return( NOT_ERROR );
case T_IDEAL:
Options.mode |= MODE_IDEAL;
return( NOT_ERROR );
case T_DOT_286C:
direct = T_DOT_286;
case T_DOT_8086:
case T_DOT_186:
case T_DOT_286:
case T_DOT_286P:
case T_DOT_386:
case T_DOT_386P:
case T_DOT_486:
case T_DOT_486P:
case T_DOT_586:
case T_DOT_586P:
case T_DOT_686:
case T_DOT_686P:
case T_DOT_8087:
case T_DOT_287:
case T_DOT_387:
case T_DOT_NO87:
case T_DOT_K3D:
case T_DOT_MMX:
case T_DOT_XMM:
case T_DOT_XMM2:
case T_DOT_XMM3:
if( Options.mode & MODE_IDEAL ) {
AsmError( UNKNOWN_DIRECTIVE );
return( ERROR );
} else {
ret = cpu_directive(direct);
if( Parse_Pass != PASS_1 )
ret = NOT_ERROR;
return( ret );
}
case T_P286N:
direct = T_P286;
case T_P8086:
case T_P186:
case T_P286:
case T_P286P:
case T_P386:
case T_P386P:
case T_P486:
case T_P486P:
case T_P586:
case T_P586P:
case T_P686:
case T_P686P:
case T_P8087:
case T_P287:
case T_P387:
case T_PK3D:
case T_PMMX:
case T_PXMM:
case T_PXMM2:
case T_PXMM3:
ret = cpu_directive(direct);
if( Parse_Pass != PASS_1 )
ret = NOT_ERROR;
return( ret );
case T_DOT_DOSSEG:
if( Options.mode & MODE_IDEAL ) {
AsmError( UNKNOWN_DIRECTIVE );
return( ERROR );
}
case T_DOSSEG:
Globals.dosseg = TRUE;
return( NOT_ERROR );
case T_PUBLIC:
/* special case - expanded inside iff it is an EQU to a symbol */
return( Parse_Pass == PASS_1 ? PubDef(i+1) : NOT_ERROR );
case T_ELSE:
case T_ELSEIF:
case T_ELSEIF1:
case T_ELSEIF2:
case T_ELSEIFB:
case T_ELSEIFDEF:
case T_ELSEIFE:
case T_ELSEIFNB:
case T_ELSEIFNDEF:
case T_ELSEIFDIF:
case T_ELSEIFDIFI:
case T_ELSEIFIDN:
case T_ELSEIFIDNI:
case T_ENDIF:
case T_IF:
case T_IF1:
case T_IF2:
case T_IFB:
case T_IFDEF:
case T_IFE:
case T_IFNB:
case T_IFNDEF:
case T_IFDIF:
case T_IFDIFI:
case T_IFIDN:
case T_IFIDNI:
return( conditional_assembly_directive( i ) );
case T_DOT_ERR:
case T_DOT_ERRB:
case T_DOT_ERRDEF:
case T_DOT_ERRDIF:
case T_DOT_ERRDIFI:
case T_DOT_ERRE:
case T_DOT_ERRIDN:
case T_DOT_ERRIDNI:
case T_DOT_ERRNB:
case T_DOT_ERRNDEF:
case T_DOT_ERRNZ:
if( Options.mode & MODE_IDEAL ) {
AsmError( UNKNOWN_DIRECTIVE );
return( ERROR );
}
case T_ERR:
case T_ERRIFB:
case T_ERRIFDEF:
case T_ERRIFDIF:
case T_ERRIFDIFI:
case T_ERRIFE:
case T_ERRIFIDN:
case T_ERRIFIDNI:
case T_ERRIFNDEF:
return( conditional_error_directive( i ) );
case T_ENDS:
if( Definition.struct_depth != 0 )
return( StructDef( i ) );
// else fall through to T_SEGMENT
case T_SEGMENT:
return( Parse_Pass == PASS_1 ? SegDef(i) : SetCurrSeg(i) );
case T_GROUP:
return( Parse_Pass == PASS_1 ? GrpDef(i) : NOT_ERROR );
case T_PROC:
return( ProcDef( i, TRUE ) );
case T_ENDP:
return( ProcEnd(i) );
case T_ENUM:
return( EnumDef( i ) );
case T_DOT_CODE:
case T_DOT_STACK:
case T_DOT_DATA:
case T_DOT_DATA_UN:
case T_DOT_FARDATA:
case T_DOT_FARDATA_UN:
case T_DOT_CONST:
if( Options.mode & MODE_IDEAL ) {
AsmError( UNKNOWN_DIRECTIVE );
return( ERROR );
}
case T_CODESEG:
case T_STACK:
case T_DATASEG:
case T_UDATASEG:
case T_FARDATA:
case T_UFARDATA:
case T_CONST:
return( SimSeg(i) );
case T_WARN:
case T_NOWARN:
return( NOT_ERROR ); /* Not implemented yet */
case T_DOT_ALPHA:
case T_DOT_SEQ:
case T_DOT_LIST:
case T_DOT_LISTALL:
case T_DOT_LISTIF:
case T_DOT_LISTMACRO:
case T_DOT_LISTMACROALL:
case T_DOT_NOLIST:
case T_DOT_XLIST:
case T_DOT_TFCOND:
case T_DOT_SFCOND:
case T_DOT_LFCOND:
case T_DOT_CREF:
case T_DOT_XCREF:
case T_DOT_NOCREF:
case T_DOT_SALL:
case T_PAGE:
case T_TITLE:
case T_SUBTITLE:
case T_SUBTTL:
if( Options.mode & MODE_IDEAL ) {
AsmError( UNKNOWN_DIRECTIVE );
return( ERROR );
}
AsmWarn( 4, IGNORING_DIRECTIVE );
return( NOT_ERROR );
case T_DOT_BREAK:
case T_DOT_CONTINUE:
case T_DOT_ELSE:
case T_DOT_ENDIF:
case T_DOT_ENDW:
case T_DOT_IF:
case T_DOT_RADIX:
case T_DOT_REPEAT:
case T_DOT_UNTIL:
case T_DOT_WHILE:
if( Options.mode & MODE_IDEAL ) {
AsmError( UNKNOWN_DIRECTIVE );
return( ERROR );
}
case T_ECHO:
case T_HIGH:
case T_HIGHWORD:
case T_LOW:
case T_LOWWORD:
case T_ADDR:
case T_BOUND:
case T_CASEMAP:
case T_INVOKE:
case T_LROFFSET:
case T_OPATTR:
case T_OPTION:
case T_POPCONTEXT:
case T_PUSHCONTEXT:
case T_PROTO:
case T_THIS:
case T_WIDTH:
if( Options.mode & MODE_IDEAL ) {
AsmError( UNKNOWN_DIRECTIVE );
return( ERROR );
}
case T_CATSTR:
case T_MASK:
case T_PURGE:
case T_RECORD:
case T_TYPEDEF:
case T_UNION:
AsmError( NOT_SUPPORTED );
return( ERROR );
case T_ORG:
ExpandTheWorld( 0, FALSE, TRUE );
break;
case T_TEXTEQU: /* TEXTEQU */
if( Options.mode & MODE_IDEAL ) {
AsmError( UNKNOWN_DIRECTIVE );
return( ERROR );
}
case T_EQU2: /* = */
case T_EQU: /* EQU */
/* expand any constants and simplify any expressions */
ExpandTheConstant( 0, FALSE, TRUE );
break;
case T_NAME: /* no expand parameters */
break;
case T_DOT_STARTUP:
case T_DOT_EXIT:
if( Options.mode & MODE_IDEAL ) {
AsmError( UNKNOWN_DIRECTIVE );
return( ERROR );
}
case T_STARTUPCODE:
case T_EXITCODE:
default:
/* expand any constants in all other directives */
ExpandAllConsts( 0, FALSE );
break;
}
switch( direct ) {
case T_ALIAS:
if( Parse_Pass == PASS_1 )
return( AddAlias( i ) );
return( NOT_ERROR );
case T_EXTERN:
if( Options.mode & MODE_IDEAL ) {
break;
}
case T_EXTRN:
return( Parse_Pass == PASS_1 ? ExtDef( i+1, FALSE ) : NOT_ERROR );
case T_COMM:
return( Parse_Pass == PASS_1 ? CommDef(i+1) : NOT_ERROR );
case T_EXTERNDEF:
if( Options.mode & MODE_IDEAL ) {
break;
}
case T_GLOBAL:
return( Parse_Pass == PASS_1 ? ExtDef( i+1, TRUE ) : NOT_ERROR );
case T_DOT_MODEL:
if( Options.mode & MODE_IDEAL ) {
break;
}
case T_MODEL:
return( Model(i) );
case T_INCLUDE:
return( Include(i+1) );
case T_INCLUDELIB:
return( Parse_Pass == PASS_1 ? IncludeLib(i+1) : NOT_ERROR );
case T_ASSUME:
return( SetAssume(i) );
case T_END:
return( ModuleEnd(Token_Count) );
case T_EQU:
return( DefineConstant( i-1, FALSE, FALSE ) );
case T_EQU2:
return( DefineConstant( i-1, TRUE, FALSE ) );
case T_TEXTEQU:
return( DefineConstant( i-1, TRUE, TRUE ) );
case T_MACRO:
return( MacroDef(i, FALSE ) );
case T_ENDM:
return( MacroEnd( FALSE ) );
case T_EXITM:
return( MacroEnd( TRUE ) );
case T_ARG:
return( Parse_Pass == PASS_1 ? ArgDef(i) : NOT_ERROR );
case T_USES:
return( Parse_Pass == PASS_1 ? UsesDef(i) : NOT_ERROR );
case T_LOCAL:
return( Parse_Pass == PASS_1 ? LocalDef(i) : NOT_ERROR );
case T_COMMENT:
if( Options.mode & MODE_IDEAL )
break;
return( Comment( START_COMMENT, i ) );
case T_STRUCT:
if( Options.mode & MODE_IDEAL ) {
break;
}
case T_STRUC:
return( StructDef( i ) );
case T_NAME:
return( Parse_Pass == PASS_1 ? NameDirective(i) : NOT_ERROR );
case T_LABEL:
return( LabelDirective( i ) );
case T_ORG:
return( OrgDirective( i ) );
case T_ALIGN:
case T_EVEN:
return( AlignDirective( direct, i ) );
case T_FOR:
if( Options.mode & MODE_IDEAL ) {
break;
}
case T_IRP:
return( ForDirective ( i+1, IRP_WORD ) );
case T_FORC:
if( Options.mode & MODE_IDEAL ) {
break;
}
case T_IRPC:
return( ForDirective ( i+1, IRP_CHAR ) );
case T_REPEAT:
if( Options.mode & MODE_IDEAL ) {
break;
}
case T_REPT:
return( ForDirective ( i+1, IRP_REPEAT ) );
case T_DOT_STARTUP:
case T_DOT_EXIT:
case T_STARTUPCODE:
case T_EXITCODE:
return( Startup ( i ) );
case T_LOCALS:
case T_NOLOCALS:
return( Locals( i ) );
}
AsmError( UNKNOWN_DIRECTIVE );
return( ERROR );
}
