Position NetworkMessage::GetPosition()
{
	Position pos;
	pos.x = GetU16();
	pos.y = GetU16();
	pos.z = GetByte();
	return pos;
}
Beispiel #2
0
void    FCPassLabel( void ) {
//=====================

// Pass label to run-time routine.

    call_handle handle;

    handle = InitCall( GetU16() );
    CGAddParm( handle, CGBackName( (back_handle)GetLabel( GetU16() ), TY_POINTER ), TY_POINTER );
    CGDone( CGCall( handle ) );
}
Beispiel #3
0
	Dictionary::Dictionary(char const *filename) : mDefinition(null)
	{
		mFile = LoadFile("english.dictionary", &mFileSize);

		if(mFile != null)
		{
			uint8 const *p = mFile;
			uint8 const *bufferEnd = p + mFileSize;

			char const *id = (char const *)p;
			if(strncmp(id, "dictionary", 10) == 0)
			{
				p += 10;

				mVersion = GetU16(p);
				mNumWords = GetU32(p);

				mWord = (char *)p;
				p += mNumWords * 8;

				mDefinition = new char *[mNumWords];

				int wordIndex = 0;
				while(p < bufferEnd)
				{
					mDefinition[wordIndex] = (char *)p;

					uint16 definitionMask = GetU16(p);

					for(int i = 0; i < eWordType::kNumWordTypes; ++i)
					{
						if((definitionMask & (1 << i)) != 0)
						{
							if(*p++ == eReferenceType::kNone)
							{
								p += strlen((char *)p) + 1;
							}
							else
							{
								p += 3;
							}
						}
					}
					++wordIndex;
				}
			}
		}
		SaveAsJSON();
	}
Beispiel #4
0
void    DtFieldSubstring( void ) {
//==========================

// Data initialize a substring character item within a structure.

    sym_id      fd;
    intstar4    base;
    intstar4    first;
    intstar4    last;
    char        name[MAX_SYMLEN+1];

    base = DXPop();
    first = DXPop();
    fd = GetPtr();
    last = GetInt();
    if( last != 0 ) {
        last += first - 1;
    } else {
        last = DXPop();
    }
    GetU16(); // skip typing information
    if( DoSubstring( first, last, fd->u.fd.xt.size ) ) {
        DXPush( base + first - 1 );
        DtItemSize = last - first + 1;
    } else {
        STFieldName( fd, name );
        Error( EV_SSTR_INVALID, name, StmtKeywords[ PR_DATA ] );
    }
}
Beispiel #5
0
void    DtSubstring( void ) {
//=====================

// Data initialize a character substring.

    intstar4    first;
    intstar4    last;
    sym_id      cv;

    cv = GetPtr();
    GetU16();   // skip typing information
    first = DXPop();
    if( cv != NULL ) {
        if( DtFlags & DT_SS_NO_HIGH ) {
            last = cv->u.ns.xt.size;
            DtFlags &= ~DT_SS_NO_HIGH;
        } else {
            last = DXPop();
        }
    } else {
        last = first + GetInt() - 1;
    }
    if( !DoSubstring( first, last, InitVar->u.ns.xt.size ) ) {
        NameStmtErr( EV_SSTR_INVALID, InitVar, PR_DATA );
    }
    DtOffset += first - 1;
    DtItemSize = last - first + 1;
}
Beispiel #6
0
void    DtExp( void ) {
//===============

// Exponentiate constants.

    intstar4    op2;
    intstar4    op1;
    intstar4    result;

    op1 = DXPop();
    op2 = DXPop();
    if( op1 == 0 ) {
        if( op2 <= 0 ) {
            Error( EX_Z_2_NOT_POS );
        }
        DXPush( 0 );
    } else if( op2 < 0 ) {
        DXPush( 0 );
    } else {
        result = 1;
        while( op2 != 0 ) {
            result *= op1;
            --op2;
        }
        DXPush( result );
    }
    GetU16();   // skip typing information
}
Beispiel #7
0
static  void    Equivalent( cg_op op_code ) {
//===========================================


    cg_name     op1;
    cg_name     op2;
    unsigned_16 typ_info;
    cg_type     typ1;
    cg_type     typ2;

    typ_info = GetU16();
    typ1 = GetType1( typ_info );
    typ2 = GetType2( typ_info );
    op1 = XPopValue( typ1 );
    op2 = XPopValue( typ2 );
    typ1 = CGType( op1 );
    if( typ1 != TY_BOOLEAN ) {
        op1 = CGCompare( O_NE, op1, CGInteger( 0, typ1 ), typ1 );
    }
    typ2 = CGType( op2 );
    if( typ2 != TY_BOOLEAN ) {
        op2 = CGCompare( O_NE, op2, CGInteger( 0, typ2 ), typ2 );
    }
    XPush( CGCompare( op_code, op1, op2, TY_UINT_1 ) );
}
Beispiel #8
0
void    FCMulMixCX( void ) {
//====================

// Multiply a complex by a scalar.

    XMulDivMix( O_TIMES, true, GetU16() );
}
Beispiel #9
0
void            FCDeAllocate( void ) {
//==============================

    call_handle         handle;
    sym_id              arr;
    uint                num;

    num = 0;
    handle = InitCall( RT_DEALLOCATE );
    for(;;) {
        arr = GetPtr();
        if( arr == NULL ) break;
        CGAddParm( handle, CGFEName( arr, T_POINTER ), T_POINTER );
        CGAddParm( handle, getFlags( arr ), FLAG_PARM_TYPE );
        ++num;
    }
    CGAddParm( handle, CGInteger( num, T_INTEGER ), T_INTEGER );
    if( GetU16() & ALLOC_STAT ) {
        FCodeSequence();
        CGAddParm( handle, XPop(), T_POINTER );
    } else {
        CGAddParm( handle, CGInteger( 0, T_POINTER ), T_POINTER );
    }
    CGDone( CGCall( handle ) );
}
Beispiel #10
0
void    FCCat( void ) {
//===============

// Do concatenation operation.

    XPush( Concat( GetU16(), XPop() ) );
}
Beispiel #11
0
void    FCFreeLabel( void ) {
//=====================

// Free specified label since it will no longer be referenced.

    DoneLabel( GetU16() );
}
Beispiel #12
0
void    FCMulMixXC( void ) {
//====================

// Multiply a scalar by a complex.

    XMulDivMix( O_TIMES, false, GetU16() );
}
Beispiel #13
0
void    FCSeek( void ) {
//======================

// Seek to ObjPtr + offset.

    FCodeSeek( FCodeTell( GetU16() ) );
}
Beispiel #14
0
void    FCDivMixCX( void ) {
//====================

// Divide a complex by a scalar.

    XMulDivMix( O_DIV, true, GetU16() );
}
Beispiel #15
0
FCODE   GetFCode( void ) {
//========================

// Get an F-Code from object memory.

    return( GetU16() );
}
Beispiel #16
0
void    FCMulCmplx( void ) {
//====================

// Multiply one complex number by another.
#if _CPU == 8086 || _CPU == 386
    if( CPUOpts & CPUOPT_FPC ) {
        // generate call to runtime complex multiply
        XCmplxOp( RT_C8MUL );
    } else {
        // do multiplication inline
        InLineMulCC( GetU16() );
    }
#else
    // For risc we just inline the entire code
    InLineMulCC( GetU16() );
#endif
}
Beispiel #17
0
void    DtUMinus( void ) {
//==================

// Negate constant.

    DXPush( -DXPop() );
    GetU16();   // skip typing information
}
Beispiel #18
0
void    FCSetAtEnd( void ) {
//====================

// Set END= for ATEND statement.

    CGDone( CGCall( InitCall( RT_SET_END ) ) );
    EndEqLabel = GetU16();
}
Beispiel #19
0
void    FCJmpFalse( void ) {
//====================

    unsigned_16 typ_info;
    cg_type     typ;
    cg_name     bool_expr;

    typ_info = GetU16();
    typ = GetType( typ_info );
    if( IntType( typ_info ) ) {
        bool_expr = CGCompare( O_NE, XPopValue( typ ),
                               CGInteger( 0, typ ), typ );
    } else {
        bool_expr = XPopValue( typ );
    }
    CGControl( O_IF_FALSE, bool_expr, GetLabel( GetU16() ) );
}
Beispiel #20
0
std::string NetworkMessage::GetString()
{
	uint16_t stringlen = GetU16();
	if(stringlen >= (16384 - m_ReadPos))
		return std::string();

	char* v = (char*)(m_MsgBuf + m_ReadPos);
	m_ReadPos += stringlen;
	return std::string(v, stringlen);
}
Beispiel #21
0
std::string NetworkMessage::GetString()
{
  uint16_t stringlen = GetU16();
  if(stringlen >= (NETWORKMESSAGE_MAXSIZE - m_ReadPos))
    return std::string();

  char* v = (char*)(m_MsgBuf + m_ReadPos);
  m_ReadPos += stringlen;
  return std::string(v, stringlen);
}
Beispiel #22
0
void    DtUnaryMul( void ) {
//====================

// Multiply constants.

    intstar4    op;

    op = DXPop();
    DXPush( op * op );
    GetU16();   // skip typing information
}
Beispiel #23
0
void    FCConjg( void ) {
//=================

    cg_cmplx    z;
    cg_type     typ;

    typ = GetType( GetU16() );
    XPopCmplx( &z, typ );
    XPush( CGUnary( O_UMINUS, z.imagpart, CmplxBaseType( typ ) ) );
    XPush( z.realpart );
}
Beispiel #24
0
inttarg GetInt( void ) {
//======================

// Get integer from object memory.

#if _CPU == 8086
    return( GetU16() );
#else // _CPU == 386
    return( GetConst32() );
#endif
}
Beispiel #25
0
void    FCDbgLine( void ) {
//====================

// Generate line # information.

    unsigned_16 line_num;

    line_num = GetU16();
    if( ( SubProgId->ns.flags & SY_SUBPROG_TYPE ) == SY_BLOCK_DATA ) return;
    DBLineNum( line_num );
}
Beispiel #26
0
void    FCStartDataStmt( void ) {
//=========================

// Start DATA statement processing.

    FCTablePtr = DataJmpTab;
    DtConstList = FCodeTell( GetU16() - sizeof( unsigned_16 ) );
    DtRepCount = 0;
    DtFlags = 0;
    DtItemSize = 0;
    DtStartSequence();
}
Beispiel #27
0
	/*! DRAGONS: We use the current UTF16String GetString trait to ensure that we always have the correct handling,
	 *           even if the user wants these strings handled differently (i.e. we do it their way!)
	 */
	std::list<std::string> SplitStringArray(const MDObjectPtr &Array)
	{
		std::list<std::string> Ret;

		// Quit early if an invalid parameter
		if(!Array) return Ret;

		// Build a working string
		static MDTypePtr ValType = MDType::Find("UTF16String");
		MDObjectPtr Value = ValType ? new MDObject(ValType) : NULL;
		if(!Value)
		{
			error("Can't build UTF16String value required by SplitStringArray() - need this type to be defined in the dictionary file\n");
			return Ret;
		}

		// Assemble the data value (which may be an array of sub-values)
		DataChunkPtr Data = Array->PutData();

		// Get a pointer to the start of the data
		UInt8 *pData = Data->Data;

		// The number of bytes of data to split
		size_t BytesLeft = Data->Size;

		while(BytesLeft > 1)
		{
			// Find the end of the current string
			size_t Len = 0;
			UInt8 *p = pData;
			while(BytesLeft > 1)
			{
				BytesLeft -= 2;
				Len += 2;
				UInt16 Char = GetU16(p);
				p += 2;

				// End when we find a null
				if(Char == 0) break;
			}

			// Copy this string to the working value
			Value->SetValue(pData, Len);

			// Read out the traits-formatted version of the string
			Ret.push_back(Value->GetString());

			// Move the pointer forward to the next value after the string terminator
			pData = p;
		}

		return Ret;
	}
std::string NetworkMessage::GetString(uint16_t size/* = 0*/)
{
	if(!size)
		size = GetU16();

	if(size >= (NETWORKMESSAGE_MAXSIZE - m_ReadPos))
		return std::string();

	char* v = (char*)(m_MsgBuf + m_ReadPos);
	m_ReadPos += size;
	return std::string(v, size);
}
Beispiel #29
0
void    FCChar1Move( void ) {
//=====================

// Perform single character assignment.

    cg_type     typ;
    cg_name     dest;

    typ = GetType( GetU16() );
    dest = XPop();
    XPush( CGLVAssign( SCBPointer( dest ), GetChOp( typ ), typ ) );
}
Beispiel #30
0
void    FCFmtScan( void ) {
//===================

// Call runtime routine to scan a format specification from a character
// expression.

    call_handle handle;

    handle = InitCall( RT_FMT_SCAN );
    CGAddParm( handle, CGInteger( GetU16(), TY_UNSIGNED ), TY_UNSIGNED );
    CGAddParm( handle, XPop(), TY_POINTER );
    CGDone( CGCall( handle ) );
}