test

这是一个软件水平资格考试中使用的CASL汇编语言的编译器,实现文件中包括一个编译器,一个虚拟机,一个类似于Debug的调试器.

 wchar_t * __cdecl _wstrtime(wchar_t *);


#line 649 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\wchar.h"



typedef int mbstate_t;
typedef wchar_t _Wint_t;

 wint_t __cdecl btowc(int);
 size_t __cdecl mbrlen(const char *, size_t, mbstate_t *);
 size_t __cdecl mbrtowc(wchar_t *, const char *, size_t, mbstate_t *);
 size_t __cdecl mbsrtowcs(wchar_t *, const char **, size_t, mbstate_t *);

 size_t __cdecl wcrtomb(char *, wchar_t, mbstate_t *);
 size_t __cdecl wcsrtombs(char *, const wchar_t **, size_t, mbstate_t *);
 int __cdecl wctob(wint_t);


inline int fwide(FILE *, int _M)
        {return (_M); }
inline int mbsinit(const mbstate_t *)
        {return (1); }
inline const wchar_t *wmemchr(const wchar_t *_S, wchar_t _C, size_t _N)
        {for (; 0 < _N; ++_S, --_N)
                if (*_S == _C)
                        return (_S);
        return (0); }
inline int wmemcmp(const wchar_t *_S1, const wchar_t *_S2, size_t _N)
        {for (; 0 < _N; ++_S1, ++_S2, --_N)
                if (*_S1 != *_S2)
                        return (*_S1 < *_S2 ? -1 : +1);
        return (0); }
inline wchar_t *wmemcpy(wchar_t *_S1, const wchar_t *_S2, size_t _N)
        {wchar_t *_Su1 = _S1;
        for (; 0 < _N; ++_Su1, ++_S2, --_N)
                *_Su1 = *_S2;
        return (_S1); }
inline wchar_t *wmemmove(wchar_t *_S1, const wchar_t *_S2, size_t _N)
        {wchar_t *_Su1 = _S1;
        if (_S2 < _Su1 && _Su1 < _S2 + _N)
                for (_Su1 += _N, _S2 += _N; 0 < _N; --_N)
                        *--_Su1 = *--_S2;
        else
                for (; 0 < _N; --_N)
                        *_Su1++ = *_S2++;
        return (_S1); }
inline wchar_t *wmemset(wchar_t *_S, wchar_t _C, size_t _N)
        {wchar_t *_Su = _S;
        for (; 0 < _N; ++_Su, --_N)
                *_Su = _C;
        return (_S); }
}       
inline wchar_t *wmemchr(wchar_t *_S, wchar_t _C, size_t _N)
        {return ((wchar_t *)wmemchr((const wchar_t *)_S, _C, _N)); }
inline wchar_t *wcschr(wchar_t *_S, wchar_t _C)
        {return ((wchar_t *)wcschr((const wchar_t *)_S, _C)); }
inline wchar_t *wcspbrk(wchar_t *_S, const wchar_t *_P)
        {return ((wchar_t *)wcspbrk((const wchar_t *)_S, _P)); }
inline wchar_t *wcsrchr(wchar_t *_S, wchar_t _C)
        {return ((wchar_t *)wcsrchr((const wchar_t *)_S, _C)); }
inline wchar_t *wcsstr(wchar_t *_S, const wchar_t *_P)
        {return ((wchar_t *)wcsstr((const wchar_t *)_S, _P)); }
#line 710 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\wchar.h"


#pragma pack(pop)
#line 714 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\wchar.h"

#line 716 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\wchar.h"













#line 730 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\wchar.h"
#line 15 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\cwchar"
#line 16 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\cwchar"
#line 17 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\cwchar"





#line 12 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\iosfwd"
#line 1 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\xstddef"



#pragma once
#line 6 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\xstddef"




 #line 1 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\yvals.h"



#line 1 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\use_ansi.h"















#pragma once
#line 18 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\use_ansi.h"
























#pragma comment(lib,"libcp")
#line 44 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\use_ansi.h"
#line 45 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\use_ansi.h"

#line 47 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\use_ansi.h"
#line 5 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\yvals.h"











#pragma pack(push,8)
#line 18 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\yvals.h"

 #pragma warning(4: 4018 4114 4146 4244 4245)
 #pragma warning(4: 4663 4664 4665)
 #pragma warning(disable: 4237 4284 4290 4514)
		
 
  
  
  
  
 



#line 33 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\yvals.h"
namespace std {
		
 
typedef bool _Bool;
 #line 38 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\yvals.h"
		



		






		
 
  
  
 


#line 57 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\yvals.h"

		
 
class  _Lockit
	{	
public:
  




   
	_Lockit()
		{}
	~_Lockit()
		{}
  #line 74 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\yvals.h"
	};
 #line 76 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\yvals.h"
		




};

#pragma pack(pop)
#line 85 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\yvals.h"

#line 87 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\yvals.h"





#line 11 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\xstddef"
#line 12 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\xstddef"
#line 1 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\cstddef"



#pragma once
#line 6 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\cstddef"




 
 #line 1 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\stddef.h"















#pragma once
#line 18 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\stddef.h"






#line 25 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\stddef.h"



extern "C" {
#line 30 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\stddef.h"

















#line 48 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\stddef.h"































#line 80 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\stddef.h"
 extern int errno;
#line 82 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\stddef.h"





typedef int ptrdiff_t;

#line 90 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\stddef.h"






















}
#line 114 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\stddef.h"

#line 116 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\stddef.h"
#line 12 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\cstddef"
 


#line 16 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\cstddef"
#line 17 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\cstddef"





#line 13 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\xstddef"











#pragma pack(push,8)
#line 26 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\xstddef"
namespace std {
		
 
 
 
 
 
 
 
 
 
		
		
 
 
		


 
 
 
 
 
		
enum _Uninitialized {_Noinit};
		
 void __cdecl _Nomemory();
};

#pragma pack(pop)
#line 57 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\xstddef"

#line 59 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\xstddef"





#line 13 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\iosfwd"


#pragma pack(push,8)
#line 17 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\iosfwd"
namespace std {
                
typedef long streamoff;
const streamoff _BADOFF = -1;
typedef int streamsize;
extern  const fpos_t _Fpz;
                
template<class _St>
        class fpos {
        typedef fpos<_St> _Myt;
public:






        fpos(streamoff _O = 0)
                : _Off(_O), _Fpos(_Fpz), _State(_Stz) {}
#line 37 "D:\\Program Files\\Microsoft Visual Studio\\VC98\\include\\iosfwd"
        fpos(_St _S, fpos_t _F)
                : _Off(0), _Fpos(_F), _State(_S) {}
        _St state() const
                {return (_State); }
        void state(_St _S)
                {_State = _S; }
        fpos_t get_fpos_t() const
                {return (_Fpos); }
        operator streamoff() const
                {return (_Off + ((long)(_Fpos))); }
        streamoff operator-(const _Myt& _R) const
                {return ((streamoff)*this - (streamoff)_R); }
        _Myt& operator+=(streamoff _O)
                {_Off += _O;
                return (*this); }
        _Myt& operator-=(streamoff _O)
                {_Off -= _O;
                return (*this); }
        _Myt operator+(streamoff _O) const
                {_Myt _Tmp = *this;
                return (_Tmp += _O); }
        _Myt operator-(streamoff _O) const
                {_Myt _Tmp = *this;
                return (_Tmp -= _O); }
        bool operator==(const _Myt& _R) const
                {return ((streamoff)*this == (streamoff)_R); }
        bool operator!=(const _Myt& _R) const
                {return (!(*this == _R)); }
private:
        static _St _Stz;
        streamoff _Off;
        fpos_t _Fpos;
        _St _State;
        };
template<class _St>
        _St fpos<_St>::_Stz;
typedef fpos<mbstate_t> streampos;
typedef streampos wstreampos;
                
template<class _E>
        struct char_traits {
        typedef _E char_type;
        typedef _E int_type;
        typedef streampos pos_type;
        typedef streamoff off_type;
        typedef mbstate_t state_type;
        static void __cdecl assign(_E& _X, const _E& _Y)
                {_X = _Y; }
        static bool __cdecl eq(const _E& _X, const _E& _Y)
                {return (_X == _Y); }
        static bool __cdecl lt(const _E& _X, const _E& _Y)
                {return (_X < _Y); }
        static int __cdecl compare(const _E *_U, const _E *_V, size_t _N)
                {for (size_t _I = 0; _I < _N; ++_I, ++_U, ++_V)
                        if (!eq(*_U, *_V))
                                return (lt(*_U, *_V) ? -1 : +1);
                return (0); }
        static size_t __cdecl length(const _E *_U)
                {size_t _N;
                for (_N = 0; !eq(*_U, _E(0)); ++_U)
                        ++_N;
                return (_N); }
        static _E * __cdecl copy(_E *_U, const _E *_V, size_t _N)
                {_E *_S = _U;
                for (; 0 < _N; --_N, ++_U, ++_V)
                        assign(*_U, *_V);
                return (_S); }
        static const _E * __cdecl find(const _E *_U, size_t _N,
                const _E& _C)
                {for (; 0 < _N; --_N, ++_U)
                        if (eq(*_U, _C))
                                return (_U);
                return (0); }
        static _E * __cdecl move(_E *_U, const _E *_V, size_t _N)
                {_E *_Ans = _U;
                if (_V < _U && _U < _V + _N)
                        for (_U += _N, _V += _N; 0 < _N; --_N)
                                assign(*--_U, *--_V);
                else
                        for (; 0 < _N; --_N, ++_U, ++_V)
                                assign(*_U, *_V);
                return (_Ans); }
        static _E * __cdecl assign(_E *_U, size_t _N, const _E& _C)
                {_E *_Ans = _U;
                for (; 0 < _N; --_N, ++_U)
                        assign(*_U, _C);
                return (_Ans); }
        static _E __cdecl to_char_type(const int_type& _C)
                {return ((_E)_C); }
        static int_type __cdecl to_int_type(const _E& _C)
                {return ((int_type)_C); }
        static bool __cdecl eq_int_type(const int_type& _X,
                const int_type& _Y)
                {return (_X == _Y); }
        static int_type __cdecl eof()
                {return ((-1)); }
        static int_type __cdecl not_eof(const int_type& _C)
                {return (_C != eof() ? _C : !eof()); }
        };
                
template<> struct  char_traits<wchar_t> {
        typedef wchar_t _E;
        typedef _E char_type;   
        typedef wint_t int_type;
        typedef streampos pos_type;
        typedef streamoff off_type;
        typedef mbstate_t state_type;
        static void __cdecl assign(_E& _X, const _E& _Y)
                {_X = _Y; }
        static bool __cdecl eq(const _E& _X, const _E& _Y)
                {return (_X == _Y); }
        static bool __cdecl lt(const _E& _X, const _E& _Y)
                {return (_X < _Y); }
        static int __cdecl compare(const _E *_U, const _E *_V, size_t _N)
                {return (wmemcmp(_U, _V, _N)); }
        static size_t __cdecl length(const _E *_U)
                {return (wcslen(_U)); }
        static _E *__cdecl copy(_E *_U, const _E *_V, size_t _N)
                {return (wmemcpy(_U, _V, _N)); }
        static const _E * __cdecl find(const _E *_U, size_t _N,
                const _E& _C)
                {return ((const _E *)wmemchr(_U, _C, _N)); }
        static _E * __cdecl move(_E *_U, const _E *_V, size_t _N)
                {return (wmemmove(_U, _V, _N)); }
        static _E * __cdecl assign(_E *_U, size_t _N, const _E& _C)
                {return (wmemset(_U, _C, _N)); }
        static _E __cdecl to_char_type(const int_type& _C)
                {return ((_E)_C); }
        static int_type __cdecl to_int_type(const _E& _C)
                {return ((int_type)_C); }
        static bool __cdecl eq_int_type(const int_type& _X,
                const int_type& _Y)
                {return (_X == _Y); }
        static int_type __cdecl eof()
                {return ((wint_t)(0xFFFF)); }
        static int_type __cdecl not_eof(const int_type& _C)
                {return (_C != eof() ? _C : !eof()); }
        };
                
template<> struct  char_traits<char> {
        typedef char _E;
        typedef _E char_type;
        typedef int int_type;
        typedef streampos pos_type;
        typedef streamoff off_type;
        typedef mbstate_t state_type;
        static void __cdecl assign(_E& _X, const _E& _Y)
                {_X = _Y; }
        static bool __cdecl eq(const _E& _X, const _E& _Y)
                {return (_X == _Y); }
        static bool __cdecl lt(const _E& _X, const _E& _Y)
                {return (_X < _Y); }
        static int __cdecl compare(const _E *_U, const _E *_V, size_t _N)
                {return (memcmp(_U, _V, _N)); }
        static size_t __cdecl length(const _E *_U)
                {return (strlen(_U)); }
        static _E * __cdecl copy(_E *_U, const _E *_V, size_t _N)
                {return ((_E *)memcpy(_U, _V, _N)); }
        static const _E * __cdecl find(const _E *_U, size_t _N,
                const _E& _C)
                {return ((const _E *)memchr(_U, _C, _N)); }
        static _E * __cdecl move(_E *_U, const _E *_V, size_t _N)
                {return ((_E *)memmove(_U, _V, _N)); }
        static _E * __cdecl assign(_E *_U, size_t _N, const _E& _C)
                {return ((_E *)memset(_U, _C, _N)); }
        static _E __cdecl to_char_type(const int_type& _C)
                {return ((_E)_C); }
        static int_type __cdecl to_int_type(const _E& _C)
                {return ((int_type)((unsigned char)_C)); }
        static bool __cdecl eq_int_type(const int_type& _X,
                const int_type& _Y)
                {return (_X == _Y); }
        static int_type __cdecl eof()
                {return ((-1)); }
        static int_type __cdecl not_eof(const int_type& _C)
                {return (_C != eof() ? _C : !eof()); }
        };
                
template<class T>
        class allocator;
class ios_base;
template<class _E, class _Tr = char_traits<_E> >
        class basic_ios;
template<class _E, class _Tr = char_traits<_E> >
        class istreambuf_iterator;
template<class _E, class _Tr = char_traits<_E> >
        class ostreambuf_iterator;
template<class _E, class _Tr = char_traits<_E> >
        class basic_streambuf;
template<class _E, class _Tr = char_traits<_E> >
        class basic_istream;
template<class _E, class _Tr = char_traits<_E> >
        class basic_ostream;
template<class _E, class _Tr = char_traits<_E> >
        class basic_iostream;
template<class _E, class _Tr = char_traits<_E>,
        class _A = allocator<_E> >
        class basic_stringbuf;
template<class _E, class _Tr = char_traits<_E>,
        class _A = allocator<_E> >
        class basic_istringstream;
template<class _E, class _Tr = char_traits<_E>,
        class _A = allocator<_E> >
        class basic_ostringstream;
template<class _E, class _Tr = char_traits<_E>,
        class _A = allocator<_E> >
        class basic_stringstream;
template<class _E, class _Tr = char_traits<_E> >
        class basic_filebuf;
template<class _E, class _Tr = char_traits<_E> >
        class basic_ifstream;
template<class _E, class _Tr = char_traits<_E> >
        class basic_ofstream;
template<class _E, class _Tr = char_traits<_E> >
        class basic_fstream;

                
typedef basic_ios<char, char_traits<char> > ios;
typedef basic_streambuf<char, char_traits<char> > streambuf;
typedef basic_istream<char, char_traits<char> > istream;
typedef basic_ostream<char, char_traits<char> > ostream;
typedef basic_iostream<char, char_traits<char> > iostream;
typedef basic_stringbuf<char, char_traits<char>,
        allocator<char> > stringbuf;
typedef basic_istringstream<char, char_traits<char>,
        allocator<char> > istringstream;
typedef basic_ostringstream<char, char_traits<char>,
        allocator<char> > ostringstream;
typedef basic_stringstream<char, char_traits<char>,
        allocator<char> > stringstream;
typedef basic_filebuf<char, char_traits<char> > filebuf;
typedef basic_ifstream<char, char_traits<c