Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Class.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Class.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Class.h	(revision 828)
@@ -28,4 +28,8 @@
 	{
 	}
+
+private:
+	ClassPrototype(ClassPrototype const&);
+	ClassPrototype& operator =(ClassPrototype const&);
 };
 
@@ -497,4 +501,8 @@
 
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
+
+private:
+	CClass(CClass const&);
+	CClass& operator =(CClass const&);
 };
 
@@ -528,3 +536,7 @@
 	const CClass *GetObjectClassPtr() const;
 	const CClass *GetInterfaceInfoClassPtr() const;
+
+private:
+	Classes(Classes const&);
+	Classes& operator =(Classes const&);
 };
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Const.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Const.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Const.h	(revision 828)
@@ -43,7 +43,12 @@
 	{
 	}
+private:
 	CConst()
+		: RelationalObjectModuleItem()
+		, type()
+		, i64data()
 	{
 	}
+public:
 	~CConst()
 	{
@@ -66,4 +71,8 @@
 
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
+
+private:
+	CConst(CConst const&);
+	CConst& operator =(CConst const&);
 };
 class Consts : public Jenga::Common::Hashmap<CConst>
@@ -81,4 +90,5 @@
 
 public:
+	Consts() {}
 
 	void Add( const Symbol &symbol, _int64 i64data, const Type &type );
@@ -93,4 +103,8 @@
 	double GetDoubleData( const Symbol &symbol );
 	bool IsStringPtr( const Symbol &symbol, bool isUnicode );
+
+private:
+	Consts(Consts const&);
+	Consts& operator =(Consts const&);
 };
 
@@ -153,4 +167,8 @@
 
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
+
+private:
+	ConstMacro(ConstMacro const&);
+	ConstMacro& operator =(ConstMacro const&);
 };
 class ConstMacros
@@ -169,5 +187,11 @@
 
 public:
+	ConstMacros() {}
+
 	bool Add( const Symbol &symbol, const char *parameterStr );
 	ConstMacro *Find( const Symbol &name );
+
+private:
+	ConstMacros(ConstMacros const&);
+	ConstMacros& operator =(ConstMacros const&);
 };
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Delegate.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Delegate.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Delegate.h	(revision 828)
@@ -96,4 +96,8 @@
 
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
+
+private:
+	Delegate(Delegate const&);
+	Delegate& operator =(Delegate const&);
 };
 typedef Jenga::Common::Hashmap<Delegate> Delegates;
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Interface.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Interface.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Interface.h	(revision 828)
@@ -17,9 +17,25 @@
 
 public:
-	DynamicMethodsPrototype(){}
-	DynamicMethodsPrototype( const DynamicMethodsPrototype &dynamicMethodsPrototype )
-		: dynamicMethods( dynamicMethodsPrototype.dynamicMethods )
+	DynamicMethodsPrototype() {}
+	DynamicMethodsPrototype(DynamicMethodsPrototype&& dynamicMethodsPrototype)
+		: dynamicMethods(std::move(dynamicMethodsPrototype.dynamicMethods))
 	{
 	}
+	DynamicMethodsPrototype(const DynamicMethodsPrototype &dynamicMethodsPrototype)
+		: dynamicMethods(dynamicMethodsPrototype.dynamicMethods)
+	{
+	}
+
+	DynamicMethodsPrototype& operator =(DynamicMethodsPrototype&& y)
+	{
+		dynamicMethods = std::move(y.dynamicMethods);
+		return *this;
+	}
+
+	DynamicMethodsPrototype& operator =(DynamicMethodsPrototype const& y)
+	{
+		return *this = std::move(DynamicMethodsPrototype(y));
+	}
+
 	~DynamicMethodsPrototype(){}
 
@@ -62,4 +78,10 @@
 public:
 	Interface( const CClass *pInterfaceClass, const Types &actualTypeParameters );
+	Interface(Interface&& objInterface)
+		: DynamicMethodsPrototype(std::move(objInterface))
+		, pInterfaceClass(std::move(objInterface.pInterfaceClass))
+		, vtblOffset(std::move(objInterface.vtblOffset))
+	{
+	}
 	Interface( const Interface &objInterface )
 		: DynamicMethodsPrototype( objInterface )
@@ -72,4 +94,17 @@
 		, vtblOffset( NULL )
 	{
+	}
+
+	Interface& operator =(Interface&& y)
+	{
+		DynamicMethodsPrototype::operator =(std::move(y));
+		pInterfaceClass = std::move(y.pInterfaceClass);
+		vtblOffset = std::move(y.vtblOffset);
+		return *this;
+	}
+
+	Interface& operator =(Interface const& y)
+	{
+		return *this = std::move(Interface(y));
 	}
 
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Meta.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Meta.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Meta.h	(revision 828)
@@ -163,3 +163,7 @@
 
 	void Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
+
+private:
+	Meta(Meta const&);
+	Meta& operator =(Meta const&);
 };
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Method.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Method.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Method.h	(revision 828)
@@ -25,8 +25,19 @@
 	{
 	}
+
 	CMethod()
-	{
-	}
-
+		: MemberPrototype()
+		, pUserProc()
+	{
+	}
+
+protected:
+	CMethod(CMethod const& y)
+		: MemberPrototype(y)
+		, pUserProc(y.pUserProc)
+	{
+	}
+
+public:
 	const UserProc &GetUserProc() const
 	{
@@ -50,4 +61,7 @@
 
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
+
+private:
+	CMethod& operator =(CMethod const&);
 };
 
@@ -103,5 +117,5 @@
 	{
 	}
-	DynamicMethod( const CMethod &method )
+	explicit DynamicMethod( const CMethod &method )
 		: CMethod( &method.GetUserProc(), method.GetAccessibility() )
 		, isAbstract( method.IsAbstract() )
@@ -116,4 +130,26 @@
 	}
 
+	DynamicMethod(DynamicMethod&& y)
+		: CMethod(std::move(y))
+		, isAbstract(std::move(y.isAbstract))
+		, isVirtual(std::move(y.isVirtual))
+		, isConst(std::move(y.isConst))
+		, pInheritsClass(std::move(y.pInheritsClass))
+		, isNotUse(std::move(y.isNotUse))
+	{
+	}
+
+	DynamicMethod(DynamicMethod const& y)
+		: CMethod(y)
+		, isAbstract(y.isAbstract)
+		, isVirtual(y.isVirtual)
+		, isConst(y.isConst)
+		, pInheritsClass(y.pInheritsClass)
+		, isNotUse(y.isNotUse)
+	{
+	}
+
+	DynamicMethod& operator =(DynamicMethod const&);
+
 	DynamicMethod::OverrideResult::EnumType Override( const UserProc *pUserProc, Prototype::Accessibility accessibility, bool isOverrideModifier );
 
@@ -161,5 +197,5 @@
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
-BOOST_CLASS_EXPORT( DynamicMethod );
+BOOST_CLASS_EXPORT_KEY( DynamicMethod );
 class StaticMethod : public CMethod
 {
@@ -182,4 +218,7 @@
 	}
 
+	// ムーブコンストラクタ
+	StaticMethod(StaticMethod&& y);
+
 	// コピーコンストラクタ
 	StaticMethod( const StaticMethod &staticMethod );
@@ -237,5 +276,5 @@
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
-BOOST_CLASS_EXPORT( StaticMethod );
+BOOST_CLASS_EXPORT_KEY( StaticMethod );
 
 class Methods : public std::vector<CMethod *>
@@ -255,6 +294,20 @@
 	Methods();
 
+	// ムーブコンストラクタ
+	Methods(Methods&& methods);
+
 	// コピーコンストラクタ
-	Methods( const Methods &methods );
+	Methods(const Methods &methods);
+
+	Methods& operator =(Methods&& methods)
+	{
+		std::vector<CMethod *>::operator =(std::move(methods));
+		return *this;
+	}
+
+	Methods& operator =(const Methods &methods)
+	{
+		return *this = Methods(methods);
+	}
 
 	// デストラクタ
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Namespace.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Namespace.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Namespace.h	(revision 828)
@@ -7,4 +7,5 @@
 class NamespaceScopes : public std::vector<std::string>
 {
+	typedef std::vector<std::string> Base;
 	// XMLシリアライズ用
 private:
@@ -17,17 +18,29 @@
 
 public:
-	NamespaceScopes(){}
+	NamespaceScopes() {}
+	NamespaceScopes(NamespaceScopes const& y)
+		: Base(y)
+	{
+	}
+	NamespaceScopes(NamespaceScopes&& y)
+		: Base(std::move(y))
+	{
+	}
 	NamespaceScopes( const std::string &namespaceStr );
 	NamespaceScopes( NamespaceScopes::const_iterator first, NamespaceScopes::const_iterator last )
-		: std::vector<std::string>( first, last )
+		: Base(first, last)
 	{
 	}
 	~NamespaceScopes(){}
 
-	NamespaceScopes operator+ ( const NamespaceScopes &namespaceScopes ) const;
-
 	void append( const NamespaceScopes &namespaceScopes )
 	{
 		insert( end(), namespaceScopes.begin(), namespaceScopes.end() );
+	}
+
+	NamespaceScopes& operator +=(const NamespaceScopes &namespaceScopes)
+	{
+		append(namespaceScopes);
+		return *this;
 	}
 
@@ -77,4 +90,6 @@
 };
 
+NamespaceScopes operator +(const NamespaceScopes &lhs, const NamespaceScopes &rhs);
+
 inline bool operator ==( const NamespaceScopes &lhs, const NamespaceScopes &rhs )
 {
@@ -84,4 +99,5 @@
 class NamespaceScopesCollection : public std::vector<NamespaceScopes>
 {
+	typedef std::vector<NamespaceScopes> Base;
 	// XMLシリアライズ用
 private:
@@ -93,4 +109,16 @@
 
 public:
+	NamespaceScopesCollection() : Base() {}
+	NamespaceScopesCollection(NamespaceScopesCollection&& y) : Base(std::move(y)) {}
+	NamespaceScopesCollection(NamespaceScopesCollection const& y) : Base(y) {}
+	NamespaceScopesCollection& operator =(NamespaceScopesCollection&& y)
+	{
+		Base::operator =(std::move(y));
+		return *this;
+	}
+	NamespaceScopesCollection& operator =(NamespaceScopesCollection const& y)
+	{
+		return operator =(NamespaceScopesCollection(y));
+	}
 	bool IsExist( const NamespaceScopes &namespaceScopes ) const
 	{
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/NamespaceSupporter.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/NamespaceSupporter.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/NamespaceSupporter.h	(revision 828)
@@ -65,4 +65,8 @@
 	// 指定された名前空間が同一エリアと見なされるかどうかをチェック
 	bool IsSameAreaNamespace( const NamespaceScopes &baseNamespaceScopes, const NamespaceScopes &entryNamespaceScopes ) const;
+
+private:
+	NamespaceSupporter(NamespaceSupporter const&);
+	NamespaceSupporter& operator =(NamespaceSupporter const&);
 };
 
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/NativeCode.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/NativeCode.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/NativeCode.h	(revision 828)
@@ -97,4 +97,27 @@
 		}
 	}
+	Schedule(Schedule&& y)
+		: type(std::move(y.type))
+		, offset(std::move(y.offset))
+		, lpValue(std::move(y.lpValue))
+	{
+	}
+	Schedule(Schedule const& y)
+		: type(y.type)
+		, offset(y.offset)
+		, lpValue(y.lpValue)
+	{
+	}
+	Schedule& operator =(Schedule&& y)
+	{
+		type = std::move(y.type);
+		offset = std::move(y.offset);
+		lpValue = std::move(y.lpValue);
+		return *this;
+	}
+	Schedule& operator =(Schedule const& y)
+	{
+		return *this = std::move(Schedule(y));
+	}
 	~Schedule()
 	{
@@ -151,4 +174,27 @@
 	{
 	}
+	SourceLine(SourceLine const& y)
+		: nativeCodePos(y.nativeCodePos)
+		, codeType(y.codeType)
+		, sourceCodePosition(y.sourceCodePosition)
+	{
+	}
+	SourceLine(SourceLine&& y)
+		: nativeCodePos(std::move(y.nativeCodePos))
+		, codeType(std::move(y.codeType))
+		, sourceCodePosition(std::move(y.sourceCodePosition))
+	{
+	}
+	SourceLine& operator =(SourceLine&& y)
+	{
+		nativeCodePos = std::move(y.nativeCodePos);
+		codeType = std::move(y.codeType);
+		sourceCodePosition = std::move(y.sourceCodePosition);
+		return *this;
+	}
+	SourceLine& operator =(SourceLine const& y)
+	{
+		return *this = std::move(SourceLine(y));
+	}
 
 	long GetNativeCodePos() const
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/ObjectModule.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/ObjectModule.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/ObjectModule.h	(revision 828)
@@ -43,4 +43,5 @@
 
 public:
+	ObjectModule() {}
 
 	const std::string &GetName() const
@@ -75,4 +76,8 @@
 	bool ReadString( const std::string &str );
 	bool WriteString( std::string &str ) const;
+
+private:
+	ObjectModule(ObjectModule const&);
+	ObjectModule& operator =(ObjectModule const&);
 };
 typedef std::vector<ObjectModule *> ObjectModules;
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Parameter.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Parameter.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Parameter.h	(revision 828)
@@ -29,7 +29,28 @@
 	Parameter( const Parameter &param, const Type &type );
 	Parameter( const Parameter &param );
+	Parameter(Parameter&& param)
+		: varName(std::move(param.varName))
+		, isRef(std::move(param.isRef))
+		, isArray(std::move(param.isArray))
+		, subscripts(std::move(param.subscripts))
+		, initValue(std::move(param.initValue)) {}
 	Parameter();
 	~Parameter();
 
+	Parameter& operator =(Parameter&& y)
+	{
+		varName = std::move(y.varName);
+		isRef = std::move(y.isRef);
+		isArray = std::move(y.isArray);
+		subscripts = std::move(y.subscripts);
+		initValue = std::move(y.initValue);
+		return *this;
+	}
+
+	Parameter& operator =(Parameter const& y)
+	{
+		return *this = std::move(Parameter(y));
+	}
+	
 	void SetArray( const Subscripts &subscripts ){
 		isArray = true;
@@ -46,5 +67,6 @@
 		return isRef;
 	}
-	bool IsArray(){
+	bool IsArray() const
+	{
 		return isArray;
 	}
@@ -76,4 +98,18 @@
 
 public:
+	Parameters() : std::vector<Parameter *>() {}
+	Parameters(Parameters&& y) : std::vector<Parameter *>(std::move(y)) {}
+	Parameters(Parameters const& y) : std::vector<Parameter *>(y) {}
+
+	Parameters& operator =(Parameters&& y)
+	{
+		std::vector<Parameter *>::operator =(std::move(y));
+		return *this;
+	}
+
+	Parameters& operator =(Parameters const& y)
+	{
+		return *this = std::move(Parameters(y));
+	}
 
 	bool Equals( const Parameters &params, bool isContravariant = false ) const;
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Procedure.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Procedure.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Procedure.h	(revision 828)
@@ -56,4 +56,44 @@
 	{
 	}
+
+	Procedure(Procedure const& y)
+		: RelationalObjectModuleItem(y)
+		, kind(y.kind)
+		, isCdecl(y.isCdecl)
+		, isUsing(y.isUsing)
+		, params(y.params)
+		, returnType(y.returnType)
+		, sourceCodePosition(y.sourceCodePosition)
+	{
+	}
+
+	Procedure(Procedure&& y)
+		: RelationalObjectModuleItem(std::move(y))
+		, kind(std::move(y.kind))
+		, isCdecl(std::move(y.isCdecl))
+		, isUsing(std::move(y.isUsing))
+		, params(std::move(y.params))
+		, returnType(std::move(y.returnType))
+		, sourceCodePosition(std::move(y.sourceCodePosition))
+	{
+	}
+
+	Procedure& operator =(Procedure&& y)
+	{
+		RelationalObjectModuleItem::operator =(std::move(y));
+		kind = std::move(y.kind);
+		isCdecl = std::move(y.isCdecl);
+		isUsing = std::move(y.isUsing);
+		params = std::move(y.params);
+		returnType = std::move(y.returnType);
+		sourceCodePosition = std::move(y.sourceCodePosition);
+		return *this;
+	}
+
+	Procedure& operator =(Procedure const& y)
+	{
+		return *this = std::move(Procedure(y));
+	}
+
 	~Procedure(){
 		foreach( Parameter *pParam, params ){
@@ -393,4 +433,8 @@
 
 	static const UserProc *pGlobalProc;
+
+private:
+	UserProc(UserProc const&);
+	UserProc& operator =(UserProc const&);
 };
 
@@ -418,4 +462,8 @@
 
 	void EnumGlobalProcs( const char *simpleName, const Symbol &localSymbol, std::vector<const UserProc *> &subs );
+
+private:
+	UserProcs(UserProcs const&);
+	UserProcs& operator =(UserProcs const&);
 };
 
@@ -499,7 +547,14 @@
 
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
+
+private:
+	DllProc(DllProc const&);
+	DllProc& operator =(DllProc const&);
 };
 class DllProcs : public Jenga::Common::Hashmap<DllProc>
 {
+public:
+	DllProcs() {}
+
 	// XMLシリアライズ用
 private:
@@ -512,4 +567,7 @@
 			boost::serialization::base_object<Jenga::Common::Hashmap<DllProc>>(*this));
 	}
+
+	DllProcs(DllProcs const&);
+	DllProcs& operator =(DllProcs const&);
 };
 
@@ -540,4 +598,7 @@
 
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
+
+	ProcPointer(ProcPointer const&);
+	ProcPointer& operator =(ProcPointer const&);
 };
 
@@ -569,3 +630,6 @@
 		clear();
 	}
+
+	ProcPointers(ProcPointers const&);
+	ProcPointers& operator =(ProcPointers const&);
 };
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Prototype.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Prototype.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Prototype.h	(revision 828)
@@ -61,4 +61,8 @@
 		isUsing = true;
 	}
+
+private:
+	Prototype(Prototype const&);
+	Prototype& operator =(Prototype const&);
 };
 
@@ -80,4 +84,5 @@
 	{
 	}
+
 	MemberPrototype()
 		: accessibility( Prototype::None )
@@ -85,4 +90,11 @@
 	}
 
+protected:
+	MemberPrototype(MemberPrototype const& y)
+		: accessibility(y.accessibility)
+	{
+	}
+
+public:
 	Prototype::Accessibility GetAccessibility() const
 	{
@@ -109,4 +121,7 @@
 		return ( accessibility == Prototype::Public );
 	}
+
+private:
+	MemberPrototype& operator =(MemberPrototype const &);
 };
 
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/RelationalObjectModuleItem.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/RelationalObjectModuleItem.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/RelationalObjectModuleItem.h	(revision 828)
@@ -20,5 +20,12 @@
 	}
 
-public:
+protected:
+	RelationalObjectModuleItem(RelationalObjectModuleItem&& relationalObjectModuleItem)
+		: Symbol(std::move(relationalObjectModuleItem))
+		, relationalObjectModuleIndex(std::move(relationalObjectModuleItem.relationalObjectModuleIndex))
+		, isNeedResolve(std::move(false))
+	{
+	}
+
 	RelationalObjectModuleItem( const RelationalObjectModuleItem &relationalObjectModuleItem )
 		: Symbol( relationalObjectModuleItem )
@@ -27,4 +34,5 @@
 	{
 	}
+
 	RelationalObjectModuleItem( const Symbol &symbol )
 		: Symbol( symbol )
@@ -33,4 +41,5 @@
 	{
 	}
+
 	RelationalObjectModuleItem()
 		: relationalObjectModuleIndex( -1 )
@@ -39,4 +48,21 @@
 	}
 
+	RelationalObjectModuleItem& operator =(RelationalObjectModuleItem&& y)
+	{
+		Symbol::operator =(std::move(y));
+		relationalObjectModuleIndex = std::move(y.relationalObjectModuleIndex);
+		isNeedResolve = std::move(y.isNeedResolve);
+		return *this;
+	}
+
+	RelationalObjectModuleItem& operator =(RelationalObjectModuleItem const& y)
+	{
+		Symbol::operator =(y);
+		relationalObjectModuleIndex = y.relationalObjectModuleIndex;
+		isNeedResolve = y.isNeedResolve;
+		return *this;
+	}
+
+public:
 	int GetRelationalObjectModuleIndex() const
 	{
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Resolver.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Resolver.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Resolver.h	(revision 828)
@@ -15,4 +15,28 @@
 	}
 
+	ResolveError(ResolveError&& y)
+		: relationalObjectModuleIndex(std::move(y.relationalObjectModuleIndex))
+		, targetItemName(std::move(y.targetItemName))
+	{
+	}
+
+	ResolveError(ResolveError const& y)
+		: relationalObjectModuleIndex(y.relationalObjectModuleIndex)
+		, targetItemName(y.targetItemName)
+	{
+	}
+
+	ResolveError& operator =(ResolveError&& y)
+	{
+		relationalObjectModuleIndex = std::move(y.relationalObjectModuleIndex);
+		targetItemName = std::move(y.targetItemName);
+		return *this;
+	}
+
+	ResolveError& operator =(ResolveError const& y)
+	{
+		return *this = std::move(ResolveError(y));
+	}
+
 	int GetRelationalObjectModuleIndex() const
 	{
@@ -28,4 +52,17 @@
 {
 public:
+	ResolveErrors() {}
+	ResolveErrors(ResolveErrors&& y) : std::vector<ResolveError>(std::move(y)) {}
+	ResolveErrors(ResolveErrors const& y) : std::vector<ResolveError>(y) {}
+	ResolveErrors& operator =(ResolveErrors&& y)
+	{
+		std::vector<ResolveError>::operator =(std::move(y));
+		return *this;
+	}
+	ResolveErrors& operator =(ResolveErrors const& y)
+	{
+		return *this = std::move(ResolveErrors(y));
+	}
+
 	void Add( const ResolveError &resolveError )
 	{
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Source.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Source.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Source.h	(revision 828)
@@ -21,6 +21,27 @@
 	{
 	}
+	IncludedFilesRelation(IncludedFilesRelation const& y)
+		: filePaths(y.filePaths)
+		, lineFileNumbers(y.lineFileNumbers)
+	{
+	}
+	IncludedFilesRelation(IncludedFilesRelation&& y)
+		: filePaths(std::move(y.filePaths))
+		, lineFileNumbers(std::move(y.lineFileNumbers))
+	{
+	}
 	~IncludedFilesRelation()
 	{
+	}
+	IncludedFilesRelation& operator =(IncludedFilesRelation&& y)
+	{
+		filePaths = std::move(y.filePaths);
+		lineFileNumbers = std::move(y.lineFileNumbers);
+		return *this;
+	}
+
+	IncludedFilesRelation& operator =(IncludedFilesRelation const& y)
+	{
+		return *this = std::move(IncludedFilesRelation(y));
 	}
 
@@ -76,4 +97,20 @@
 		buffer[length] = 0;
 	}
+	Text(Text&& text)
+		: length( text.length )
+	{
+		buffer = text.buffer;
+		text.buffer = static_cast<char*>(calloc(1, 1));
+		text.length = 0;
+	}
+	Text& operator =(Text&& y)
+	{
+		SwapImpl(*this, y);
+		return *this;
+	}
+	Text& operator =(Text const& y)
+	{
+		return *this = std::move(Text(y));
+	}
 	~Text(){
 		free( buffer );
@@ -100,4 +137,11 @@
 	static void SlideString(char *buffer, int slide){
 		memmove(buffer+slide, buffer, strlen(buffer)+1);
+	}
+
+protected:
+	static void SwapImpl(Text& lhs, Text& rhs)
+	{
+		std::swap(lhs.buffer, rhs.buffer);
+		std::swap(lhs.length, rhs.length);
 	}
 };
@@ -192,4 +236,9 @@
 	{
 	}
+	BasicSource(BasicSource&& basicSource)
+		: Text(std::move(basicSource))
+		, includedFilesRelation(std::move(basicSource.includedFilesRelation))
+	{
+	}
 	BasicSource( const std::string &source )
 	{
@@ -230,7 +279,14 @@
 	bool GetLineInfo( int sourceCodePos, int &line, std::string &fileName ) const;
 
-	void operator = ( const BasicSource &source ){
+	BasicSource& operator =(const BasicSource &source)
+	{
 		Realloc( source.length );
 		strcpy( buffer, source.buffer );
+		return *this;
+	}
+	BasicSource& operator =(BasicSource&& source)
+	{
+		Text::SwapImpl(*this, source);
+		return *this;
 	}
 
@@ -262,4 +318,18 @@
 		ar & boost::serialization::make_nvp("vector_BasicSource", boost::serialization::base_object<std::vector<BasicSource>>(*this));
 	}
+
+public:
+	BasicSources() {}
+	BasicSources(BasicSources&& y) : std::vector<BasicSource>(std::move(y)) {}
+	BasicSources(BasicSources const& y) : std::vector<BasicSource>(y) {}
+	BasicSources operator =(BasicSources&& y)
+	{
+		std::vector<BasicSource>::operator =(std::move(y));
+		return *this;
+	}
+	BasicSources operator =(BasicSources const& y)
+	{
+		return *this = std::move(BasicSources(y));
+	}
 };
 
@@ -289,4 +359,16 @@
 	{
 	}
+	SourceCodePosition(SourceCodePosition const& y)
+		: relationalObjectModuleIndex(y.relationalObjectModuleIndex)
+		, pos(y.pos)
+	{
+	}
+
+	SourceCodePosition& operator =(SourceCodePosition const& y)
+	{
+		relationalObjectModuleIndex = y.relationalObjectModuleIndex;
+		pos = y.pos;
+		return *this;
+	}
 
 	int GetRelationalObjectModuleIndex() const;
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Symbol.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Symbol.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Symbol.h	(revision 828)
@@ -38,16 +38,31 @@
 
 public:
-	Symbol( const NamespaceScopes &namespaceScopes, const std::string &name )
-		: namespaceScopes( namespaceScopes )
-		, name( name )
+	Symbol(NamespaceScopes namespaceScopes, std::string name)
+		: namespaceScopes(std::move(namespaceScopes))
+		, name(std::move(name))
 	{
 	}
-	Symbol( const Symbol &symbol )
-		: namespaceScopes( symbol.namespaceScopes )
-		, name( symbol.name )
+	Symbol(const Symbol &symbol)
+		: namespaceScopes(symbol.namespaceScopes)
+		, name(symbol.name)
+	{
+	}
+	Symbol(Symbol&& symbol)
+		: namespaceScopes(std::move(symbol.namespaceScopes))
+		, name(std::move(symbol.name))
 	{
 	}
 	Symbol()
 	{
+	}
+	Symbol& operator =(Symbol&& symbol)
+	{
+		namespaceScopes = std::move(symbol.namespaceScopes);
+		name = std::move(symbol.name);
+		return *this;
+	}
+	Symbol& operator =(Symbol const& symbol)
+	{
+		return *this = Symbol(symbol);
 	}
 
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Template.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Template.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Template.h	(revision 828)
@@ -48,4 +48,8 @@
 
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
+
+private:
+	ExpandedTemplateClass(ExpandedTemplateClass const&);
+	ExpandedTemplateClass& operator =(ExpandedTemplateClass const&);
 };
 
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Type.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Type.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Type.h	(revision 828)
@@ -1,2 +1,3 @@
+#include <boost/foreach.hpp>
 #pragma once
 
@@ -66,10 +67,19 @@
 	  index( (LONG_PTR)&objClass ){}
 
-	Type( const Type &type )
-		: basicType( type.basicType )
-		, index( type.index )
-		, actualGenericTypes( type.actualGenericTypes )
-		, formalTypeName( type.formalTypeName )
-		, formalTypeIndex( type.formalTypeIndex )
+	Type(Type&& type)
+		: basicType(std::move(type.basicType))
+		, index(std::move(type.index))
+		, actualGenericTypes(std::move(type.actualGenericTypes))
+		, formalTypeName(std::move(type.formalTypeName))
+		, formalTypeIndex(std::move(type.formalTypeIndex))
+	{
+	}
+
+	Type(Type const& type)
+		: basicType(type.basicType)
+		, index(type.index)
+		, actualGenericTypes(type.actualGenericTypes)
+		, formalTypeName(type.formalTypeName)
+		, formalTypeIndex(type.formalTypeIndex)
 	{
 	}
@@ -77,14 +87,20 @@
 	~Type();
 
-	void operator= ( const Type &type )
-	{
-		basicType = type.basicType;
-		index = type.index;
-		actualGenericTypes = type.actualGenericTypes;
-		formalTypeName = type.formalTypeName;
-		formalTypeIndex = type.formalTypeIndex;
-	}
-
-	__inline int GetBasicType() const
+	Type& operator =(Type&& type)
+	{
+		basicType = std::move(type.basicType);
+		index = std::move(type.index);
+		actualGenericTypes = std::move(type.actualGenericTypes);
+		formalTypeName = std::move(type.formalTypeName);
+		formalTypeIndex = std::move(type.formalTypeIndex);
+		return *this;
+	}
+
+	Type& operator =(Type const& type)
+	{
+		return *this = Type(type);
+	}
+
+	int GetBasicType() const
 	{
 		return basicType;
@@ -253,4 +269,19 @@
 
 public:
+	Types() {}
+	Types(Types&& y) : std::vector<Type>(std::move(y)) {}
+	Types(Types const& y) : std::vector<Type>(y) {}
+
+	Types& operator =(Types&& y)
+	{
+		std::vector<Type>::operator =(std::move(y));
+		return *this;
+	}
+
+	Types& operator =(Types const& y)
+	{
+		return *this = std::move(Types(y));
+	}
+
 	bool IsEquals( const Types &Types ) const;
 };
@@ -281,12 +312,38 @@
 
 public:
-	GenericType( const std::string &name, const Type &type )
-		: name( name )
-		, type( type )
-	{
-	}
+	GenericType( std::string name, Type type )
+		: name(std::move(name))
+		, type(std::move(type))
+	{
+	}
+
 	GenericType()
 	{
 	}
+
+	GenericType(GenericType&& y)
+		: name(std::move(y.name))
+		, type(std::move(y.type))
+	{
+	}
+
+	GenericType(GenericType const& y)
+		: name(y.name)
+		, type(y.type)
+	{
+	}
+
+	GenericType& operator =(GenericType&& y)
+	{
+		name = std::move(y.name);
+		type = std::move(y.type);
+		return *this;
+	}
+
+	GenericType& operator =(GenericType const& y)
+	{
+		return *this = std::move(GenericType(y));
+	}
+
 	~GenericType()
 	{
@@ -329,7 +386,35 @@
 	{
 	}
+
 	BlittableType()
-	{
-	}
+		: basicType()
+		, pClass()
+	{
+	}
+
+	BlittableType(BlittableType&& y)
+		: basicType(std::move(y.basicType))
+		, pClass(std::move(y.pClass))
+	{
+	}
+
+	BlittableType(BlittableType const& y)
+		: basicType(y.basicType)
+		, pClass(y.pClass)
+	{
+	}
+
+	BlittableType& operator =(BlittableType&& y)
+	{
+		basicType = std::move(y.basicType);
+		pClass = std::move(y.pClass);
+		return *this;
+	}
+
+	BlittableType& operator =(BlittableType const& y)
+	{
+		return *this = std::move(BlittableType(y));
+	}
+
 	const Type &GetBasicType() const
 	{
@@ -344,4 +429,5 @@
 	virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
+
 class BlittableTypes : public std::vector<BlittableType>
 {
@@ -358,4 +444,17 @@
 
 public:
+	BlittableTypes() {}
+	BlittableTypes(BlittableTypes&& y) : std::vector<BlittableType>(std::move(y)) {}
+	BlittableTypes(BlittableTypes const& y) : std::vector<BlittableType>(y) {}
+	BlittableTypes& operator =(BlittableTypes&& y)
+	{
+		std::vector<BlittableType>::operator =(std::move(y));
+		return *this;
+	}
+	BlittableTypes& operator =(BlittableTypes const& y)
+	{
+		return *this = std::move(BlittableTypes(y));
+	}
+
 	bool IsExist( Type type ) const
 	{
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/TypeDef.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/TypeDef.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/TypeDef.h	(revision 828)
@@ -42,4 +42,31 @@
 	}
 
+	TypeDef(TypeDef&& y)
+		: RelationalObjectModuleItem(std::move(y))
+		, baseName(std::move(y.baseName))
+		, baseType(std::move(y.baseType))
+	{
+	}
+
+	TypeDef(TypeDef const& y)
+		: RelationalObjectModuleItem(y)
+		, baseName(y.baseName)
+		, baseType(y.baseType)
+	{
+	}
+
+	TypeDef& operator =(TypeDef&& y)
+	{
+		RelationalObjectModuleItem::operator =(std::move(y));
+		baseName = std::move(y.baseName);
+		baseType = std::move(y.baseType);
+		return *this;
+	}
+
+	TypeDef& operator =(TypeDef const& y)
+	{
+		return *this = std::move(TypeDef(y));
+	}
+
 	const std::string &GetBaseName() const
 	{
@@ -69,4 +96,15 @@
 public:
 	TypeDefCollection();
+	TypeDefCollection(TypeDefCollection&& y) : std::vector<TypeDef>(std::move(y)) {}
+	TypeDefCollection(TypeDefCollection const& y) : std::vector<TypeDef>(y) {}
+	TypeDefCollection& operator =(TypeDefCollection&& y)
+	{
+		std::vector<TypeDef>::operator =(std::move(y));
+		return *this;
+	}
+	TypeDefCollection& operator =(TypeDefCollection const& y)
+	{
+		return *this = std::move(TypeDefCollection(y));
+	}
 	~TypeDefCollection();
 
Index: trunk/ab5.0/abdev/ab_common/include/Lexical/Variable.h
===================================================================
--- trunk/ab5.0/abdev/ab_common/include/Lexical/Variable.h	(revision 750)
+++ trunk/ab5.0/abdev/ab_common/include/Lexical/Variable.h	(revision 828)
@@ -64,6 +64,12 @@
 public:
 	Variable( const Symbol &symbol, const Type &type, bool isConst, bool isRef, const std::string &paramStrForConstructor, bool hasInitData );
+	Variable(Variable&& var);
 	Variable( const Variable &var );
 	Variable();
+	Variable& operator =(Variable&& y);
+	Variable& operator =(Variable const& y)
+	{
+		return *this = std::move(Variable(y));
+	}
 
 	void SetArray( const Subscripts &subscripts ){
