Fix warnings: unused variables, shadowing variable names, constant conditional expressions, integer conversions, inability to generate copy-ctor and/or assignment operator, etc.

src/ifcconvert/ColladaSerializer.cpp

@@ -128,7 +128,7 @@ void ColladaSerializer::ColladaExporter::ColladaGeometries::write(const std::str
 		lines.setMaterial(materials[it->first].name());
 		lines.setCount((unsigned long)it->second.size());
 		int offset = 0;
-		lines.getInputList().push_back(COLLADASW::Input(COLLADASW::InputSemantic::VERTEX, "#" + mesh_id + COLLADASW::LibraryGeometries::VERTICES_ID_SUFFIX, 0));
+		lines.getInputList().push_back(COLLADASW::Input(COLLADASW::InputSemantic::VERTEX, "#" + mesh_id + COLLADASW::LibraryGeometries::VERTICES_ID_SUFFIX, offset++));
 		lines.prepareToAppendValues();
 		lines.appendValues(it->second);
 		lines.finish();

src/ifcconvert/ColladaSerializer.h

@@ -22,6 +22,10 @@
 #ifndef COLLADASERIALIZER_H
 #define COLLADASERIALIZER_H
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4201 4512)
+#endif
 #include <COLLADASWStreamWriter.h>
 #include <COLLADASWPrimitves.h>
 #include <COLLADASWLibraryGeometries.h>
@@ -34,6 +38,9 @@
 #include <COLLADASWLibraryMaterials.h>
 #include <COLLADASWBaseInputElement.h>
 #include <COLLADASWAsset.h>
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
 
 #include "../ifcgeom/IfcGeomIterator.h"
 
@@ -41,12 +48,15 @@
 
 class ColladaSerializer : public GeometrySerializer
 {
+	// TODO The vast amount of implement details of ColladaSerializer could be hidden to the cpp file.
 private:
 	class ColladaExporter
 	{
 	private:
 		class ColladaGeometries : public COLLADASW::LibraryGeometries
 		{
+			ColladaGeometries(const ColladaGeometries&); //N/A
+			ColladaGeometries& operator =(const ColladaGeometries&); //N/A
 		public:
 			explicit ColladaGeometries(COLLADASW::StreamWriter& stream)
 				: COLLADASW::LibraryGeometries(&stream)
@@ -58,6 +68,9 @@ private:
 		class ColladaScene : public COLLADASW::LibraryVisualScenes
 		{
 		private:
+			ColladaScene(const ColladaScene&); //N/A
+			ColladaScene& operator =(const ColladaScene&); //N/A
+
 			const std::string scene_id;
 			bool scene_opened;
 		public:
@@ -71,9 +84,13 @@ private:
 		};
 		class ColladaMaterials : public COLLADASW::LibraryMaterials
 		{
+			ColladaMaterials(const ColladaMaterials&); //N/A
+			ColladaMaterials& operator =(const ColladaMaterials&); //N/A
 		private:
 			class ColladaEffects : public COLLADASW::LibraryEffects
 			{
+				ColladaEffects(const ColladaEffects&); //N/A
+				ColladaEffects& operator =(const ColladaEffects&); //N/A
 			public:
 				explicit ColladaEffects(COLLADASW::StreamWriter& stream)
 					: COLLADASW::LibraryEffects(&stream)

src/ifcconvert/IfcConvert.cpp

@@ -198,9 +198,7 @@ int main(int argc, char** argv) {
 	std::set<std::string> entities;
 	for (std::vector<std::string>::const_iterator it = entity_vector.begin(); it != entity_vector.end(); ++it) {
 		std::string lowercase_type = *it;
-		for (std::string::iterator c = lowercase_type.begin(); c != lowercase_type.end(); ++c) {
-			*c = tolower(*c);
-		}
+		std::transform(lowercase_type.begin(), lowercase_type.end(), lowercase_type.begin(), ::tolower);
 		entities.insert(lowercase_type);
 	}
 	
@@ -217,9 +215,7 @@ int main(int argc, char** argv) {
 	}
 
 	std::string output_extension = output_filename.substr(output_filename.size()-4);
-	for (std::string::iterator c = output_extension.begin(); c != output_extension.end(); ++c) {
-		*c = tolower(*c);
-	}
+	std::transform(output_extension.begin(), output_extension.end(), output_extension.begin(), ::tolower);
 
 	// If no entities are specified these are the defaults to skip from output
 	if (entity_vector.empty()) {

src/ifcconvert/OpenCascadeBasedSerializer.h

@@ -25,8 +25,10 @@
 #include "../ifcconvert/GeometrySerializer.h"
 
 class OpenCascadeBasedSerializer : public GeometrySerializer {
+	OpenCascadeBasedSerializer(const OpenCascadeBasedSerializer&); //N/A
+	OpenCascadeBasedSerializer& operator =(const OpenCascadeBasedSerializer&); //N/A
 protected:
-	const std::string& out_filename;
+	const std::string out_filename;
 	const char* getSymbolForUnitMagnitude(float mag);
 public:
 	explicit OpenCascadeBasedSerializer(const std::string& out_filename)

src/ifcconvert/SvgSerializer.cpp

@@ -178,7 +178,7 @@ void SvgSerializer::write(const IfcGeom::BRepElement<double>* o) {
 	typedef IfcSchema::IfcRelAggregates decomposition_element;
 #endif
 
-	while (true) {
+	for (;;) {
 		// Iterate over the decomposing element to find the parent IfcBuildingStorey
 		decomposition_element::list::ptr decomposes = obdef->Decomposes();
 		if (!decomposes->size()) {

src/ifcconvert/XmlSerializer.cpp

@@ -1,3 +1,22 @@
+/********************************************************************************
+*                                                                              *
+* This file is part of IfcOpenShell.                                           *
+*                                                                              *
+* IfcOpenShell is free software: you can redistribute it and/or modify         *
+* it under the terms of the Lesser GNU General Public License as published by  *
+* the Free Software Foundation, either version 3.0 of the License, or          *
+* (at your option) any later version.                                          *
+*                                                                              *
+* IfcOpenShell is distributed in the hope that it will be useful,              *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+* Lesser GNU General Public License for more details.                          *
+*                                                                              *
+* You should have received a copy of the Lesser GNU General Public License     *
+* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+*                                                                              *
+********************************************************************************/
+
 #include <map>
 
 #include <boost/property_tree/ptree.hpp>
@@ -7,6 +26,8 @@
 
 #include "XmlSerializer.h"
 
+#include <algorithm>
+
 using boost::property_tree::ptree;
 using namespace IfcSchema;
 
@@ -58,7 +79,8 @@ boost::optional<std::string> format_attribute(const Argument* argument, IfcUtil:
 					unit_name = unit->Name();
 				}
 
-				for (std::string::iterator c = unit_name.begin(); c != unit_name.end(); ++c) *c = tolower(*c);
+				// TODO add toLower() and toUpper() string helper functions for the project
+				std::transform(unit_name.begin(), unit_name.end(), unit_name.begin(), ::tolower);
 
 				value = unit_name;
 			}

src/ifcgeom/IfcGeomFaces.cpp

@@ -101,7 +101,6 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 	IfcSchema::IfcFaceBound::list::ptr bounds = l->Bounds();
 
 	Handle(Geom_Surface) face_surface;
-	bool reversed_face_surface = false;
 	const bool is_face_surface = l->is(IfcSchema::Type::IfcFaceSurface);
 
 	if (is_face_surface) {
@@ -237,9 +236,9 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 					// If the wires are reversed the face needs to be reversed as well in order
 					// to maintain the counter-clock-wise ordering of the bounding wire's vertices.
 					bool all_reversed = true;
-					TopoDS_Iterator it(outer_face_bound, false);
-					for (; it.More(); it.Next()) {
-						const TopoDS_Wire& w = TopoDS::Wire(it.Value());
+					TopoDS_Iterator jt(outer_face_bound, false);
+					for (; jt.More(); jt.Next()) {
+						const TopoDS_Wire& w = TopoDS::Wire(jt.Value());
 						if ((w.Orientation() != TopAbs_REVERSED) == same_sense) {
 							all_reversed = false;
 						}
@@ -856,7 +855,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeProfileDef* l, TopoDS
 	builder.MakeCompound(compound);
 
 	IfcSchema::IfcProfileDef::list::ptr profiles = l->Profiles();
-	bool first = true;
+	//bool first = true;
 	for (IfcSchema::IfcProfileDef::list::it it = profiles->begin(); it != profiles->end(); ++it) {
 		TopoDS_Face f;
 		if (convert_face(*it, f)) {

src/ifcgeom/IfcGeomFunctions.cpp

@@ -208,12 +208,11 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 				? BRepBuilderAPI_GTransform(opening_shape_unlocated,opening_shape_gtrsf,true).Shape()
 				: opening_shape_unlocated.Moved(opening_shape_gtrsf.Trsf());
 					
-			double opening_volume, original_shape_volume;
+			double opening_volume;
 			if ( Logger::Verbosity() >= Logger::LOG_WARNING ) {
 				opening_volume = shape_volume(opening_shape);
 				if ( opening_volume <= ALMOST_ZERO )
 					Logger::Message(Logger::LOG_WARNING,"Empty opening for:",entity->entity);
-				original_shape_volume = shape_volume(entity_shape);
 			}
 
 			if (entity_shape.ShapeType() == TopAbs_COMPSOLID) {
@@ -235,9 +234,9 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 						BRepCheck_Analyzer analyser(brep_cut_result);
 						bool is_valid = analyser.IsValid() != 0;
 						if (is_valid) {
-							TopExp_Explorer exp(brep_cut_result, TopAbs_SOLID);
-							for (; exp.More(); exp.Next()) {
-								builder.Add(compound, exp.Current());
+							TopExp_Explorer exp2(brep_cut_result, TopAbs_SOLID);
+							for (; exp2.More(); exp2.Next()) {
+								builder.Add(compound, exp2.Current());
 								added = true;
 							}
 						}
@@ -272,7 +271,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 						entity_shape = brep_cut_result;
 						if ( Logger::Verbosity() >= Logger::LOG_WARNING ) {
 							const double volume_after_subtraction = shape_volume(entity_shape);
-					
+							double original_shape_volume = shape_volume(entity_shape);
 							if ( ALMOST_THE_SAME(original_shape_volume,volume_after_subtraction) )
 								Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",entity->entity);
 						}
@@ -615,11 +614,11 @@ IfcSchema::IfcProductDefinitionShape* IfcGeom::tesselate(TopoDS_Shape& shape, do
 				IfcSchema::IfcFaceOuterBound* bound = new IfcSchema::IfcFaceOuterBound(loop, face.Orientation() != TopAbs_REVERSED);
 				IfcSchema::IfcFaceBound::list::ptr bounds (new IfcSchema::IfcFaceBound::list);
 				bounds->push(bound);
-				IfcSchema::IfcFace* face = new IfcSchema::IfcFace(bounds);
+				IfcSchema::IfcFace* face2 = new IfcSchema::IfcFace(bounds);
 				es->push(loop);
 				es->push(bound);
-				es->push(face);
-				faces->push(face);
+				es->push(face2);
+				faces->push(face2);
 			}
 		}
 	}
@@ -703,7 +702,6 @@ bool IfcGeom::Kernel::fill_nonmanifold_wires_with_planar_faces(TopoDS_Shape& sha
 	// Now loop over all the vertices that are part of the wire(s) to be filled
 	for (int i = 1; i <= num_verts; ++i) {
 		first = current = TopoDS::Vertex(vertex_to_edges.FindKey(i));
-		const bool isSame = first.IsSame(current);
 		// We keep track of the vertices we already used
 		if (visited.find(vertex_to_edges.FindIndex(current)) != visited.end()) {
 			continue;
@@ -711,7 +709,7 @@ bool IfcGeom::Kernel::fill_nonmanifold_wires_with_planar_faces(TopoDS_Shape& sha
 		// Given these vertices, try to find closed loops and create new
 		// wires out of them.
 		BRepBuilderAPI_MakeWire w;
-		while (true) {
+		for (;;) {
 			visited.insert(vertex_to_edges.FindIndex(current));
 			// Find the edge that the current vertex is part of and points
 			// away from the previous vertex (null for the first vertex).
@@ -822,7 +820,7 @@ void IfcGeom::Kernel::remove_redundant_points_from_loop(TColgp_SequenceOfPnt& po
 	if (tol <= 0.) tol = getValue(GV_POINT_EQUALITY_TOLERANCE);
 	tol *= tol;
 
-	while (true) {
+	for (;;) {
 		bool removed = false;
 		int n = polygon.Length() - (closed ? 0 : 1);
 		for (int i = 1; i <= n; ++i) {

src/ifcgeom/IfcGeomHelpers.cpp

@@ -287,7 +287,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcObjectPlacement* l, gp_Trsf& t
 		return false; 		
 	}
 	IfcSchema::IfcLocalPlacement* current = (IfcSchema::IfcLocalPlacement*)l;
-	while (1) {
+	for (;;) {
 		gp_Trsf trsf2;
 		IfcSchema::IfcAxis2Placement* relplacement = current->RelativePlacement();
 		if ( relplacement->is(IfcSchema::Type::IfcAxis2Placement3D) ) {

src/ifcgeom/IfcGeomIterator.h

@@ -182,9 +182,7 @@ namespace IfcGeom {
 				}
 				if (context->hasContextType()) {
 					std::string context_type_lc = context->ContextType();
-					for (std::string::iterator c = context_type_lc.begin(); c != context_type_lc.end(); ++c) {
-						*c = tolower(*c);
-					}
+					std::transform(context_type_lc.begin(), context_type_lc.end(), context_type_lc.begin(), ::tolower);
 					if (context_types.find(context_type_lc) != context_types.end()) {
 						filtered_contexts->push(context);
 					}
@@ -287,7 +285,7 @@ namespace IfcGeom {
 		}
 
 		BRepElement<P>* create_shape_model_for_next_entity() {
-			while ( true ) {
+			for (;;) {
 				IfcSchema::IfcRepresentation* representation;
 
 				// Have we reached the end of our list of representations?
@@ -320,16 +318,16 @@ namespace IfcGeom {
 
 						// Filter the products based on the set of entities being included or excluded for
 						// processing. The set is iterated over te able to filter on subtypes.
-						for ( IfcSchema::IfcProduct::list::it it = unfiltered_products->begin(); it != unfiltered_products->end(); ++it ) {
+						for ( IfcSchema::IfcProduct::list::it jt = unfiltered_products->begin(); jt != unfiltered_products->end(); ++jt ) {
 							bool found = false;
-							for (std::set<IfcSchema::Type::Enum>::const_iterator jt = entities_to_include_or_exclude.begin(); jt != entities_to_include_or_exclude.end(); ++jt) {
-								if ((*it)->is(*jt)) {
+							for (std::set<IfcSchema::Type::Enum>::const_iterator kt = entities_to_include_or_exclude.begin(); kt != entities_to_include_or_exclude.end(); ++kt) {
+								if ((*jt)->is(*kt)) {
 									found = true;
 									break;
 								}
 							}
 							if (found == include_entities_in_processing) {
-								ifcproducts->push(*it);
+								ifcproducts->push(*jt);
 							}
 						}
 

src/ifcgeom/IfcGeomRepresentation.h

@@ -41,6 +41,8 @@ namespace IfcGeom {
 	namespace Representation {
 
 		class Representation {
+			Representation(const Representation&); //N/A
+			Representation& operator =(const Representation&); //N/A
 		protected:
 			const ElementSettings _settings;
 		public:
@@ -116,11 +118,11 @@ namespace IfcGeom {
 					: Representation(shape_model.settings())
 					, _id(shape_model.getId())
 			{
-				for ( IfcGeom::IfcRepresentationShapeItems::const_iterator it = shape_model.begin(); it != shape_model.end(); ++ it ) {
+				for ( IfcGeom::IfcRepresentationShapeItems::const_iterator iit = shape_model.begin(); iit != shape_model.end(); ++ iit ) {
 
 					int surface_style_id = -1;
-					if (it->hasStyle()) {
-						Material adapter(&it->Style());
+					if (iit->hasStyle()) {
+						Material adapter(&iit->Style());
 						std::vector<Material>::const_iterator jt = std::find(_materials.begin(), _materials.end(), adapter);
 						if (jt == _materials.end()) {
 							surface_style_id = (int)_materials.size();
@@ -132,17 +134,17 @@ namespace IfcGeom {
 
 					if (settings().apply_default_materials() && surface_style_id == -1) {
 						Material material(IfcGeom::get_default_style(settings().element_type()));
-						std::vector<Material>::const_iterator it = std::find(_materials.begin(), _materials.end(), material);
-						if (it == _materials.end()) {
+						std::vector<Material>::const_iterator mit = std::find(_materials.begin(), _materials.end(), material);
+						if (mit == _materials.end()) {
 							surface_style_id = (int)_materials.size();
 							_materials.push_back(material);
 						} else {
-							surface_style_id = (int)(it - _materials.begin());
+							surface_style_id = (int)(mit - _materials.begin());
 						}
 					}
 
-					const TopoDS_Shape& s = it->Shape();
-					const gp_GTrsf& trsf = it->Placement();
+					const TopoDS_Shape& s = iit->Shape();
+					const gp_GTrsf& trsf = iit->Placement();
 
 					// Triangulate the shape
 					try {
@@ -233,11 +235,11 @@ namespace IfcGeom {
 								addEdge(dict[n2], dict[n3], edgecount, edges_temp);
 								addEdge(dict[n3], dict[n1], edgecount, edges_temp);
 							}
-							for ( std::vector<std::pair<int,int> >::const_iterator it = edges_temp.begin(); it != edges_temp.end(); ++it ) {
-								if (edgecount[*it] == 1) {
+							for ( std::vector<std::pair<int,int> >::const_iterator jt = edges_temp.begin(); jt != edges_temp.end(); ++jt ) {
+								if (edgecount[*jt] == 1) {
 									// non manifold edge, face boundary
-									_edges.push_back(it->first);
-									_edges.push_back(it->second);
+									_edges.push_back(jt->first);
+									_edges.push_back(jt->second);
 								}
 							}
 						}
@@ -247,8 +249,8 @@ namespace IfcGeom {
 						// Edges are only emitted if there are no faces. A mixed representation of faces
 						// and loose edges is discouraged by the standard. An alternative would be to use
 						// TopExp::MapShapesAndAncestors() to find edges that do not belong to any face.
-						for (TopExp_Explorer exp(s, TopAbs_EDGE); exp.More(); exp.Next()) {
-							BRepAdaptor_Curve crv(TopoDS::Edge(exp.Current()));
+						for (TopExp_Explorer texp(s, TopAbs_EDGE); texp.More(); texp.Next()) {
+							BRepAdaptor_Curve crv(TopoDS::Edge(texp.Current()));
 							GCPnts_QuasiUniformDeflection tessellater(crv, settings().deflection_tolerance());
 							int n = tessellater.NbPoints();
 							int start = (int)_verts.size() / 3;

src/ifcgeom/IfcGeomShapes.cpp

@@ -627,9 +627,9 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCurveBoundedPlane* l, TopoDS_S
 	BRepBuilderAPI_MakeFace mf (outer);
 	mf.Add(outer);
 
-	IfcSchema::IfcCurve::list::ptr inner = l->InnerBoundaries();
+	IfcSchema::IfcCurve::list::ptr boundaries = l->InnerBoundaries();
 
-	for (IfcSchema::IfcCurve::list::it it = inner->begin(); it != inner->end(); ++it) {
+	for (IfcSchema::IfcCurve::list::it it = boundaries->begin(); it != boundaries->end(); ++it) {
 		TopoDS_Wire inner;
 		convert_wire(*it, inner);
 		
@@ -762,8 +762,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSweptDiskSolid* l, TopoDS_Shap
 			// Subtraction of pipes with small radii is unstable.
 			hasInnerRadius = false;
 		} else {
-			Handle(Geom_Circle) circle = new Geom_Circle(directrix, r2);
-			section2 = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(circle));
+			Handle(Geom_Circle) circle2 = new Geom_Circle(directrix, r2);
+			section2 = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(circle2));
 		}
 	}
 

src/ifcgeom/IfcGeomWires.cpp

@@ -184,8 +184,6 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire&
 	bool trim_cartesian = l->MasterRepresentation() == IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN;
 	IfcEntityList::ptr trims1 = l->Trim1();
 	IfcEntityList::ptr trims2 = l->Trim2();
-	bool trimmed1 = false;
-	bool trimmed2 = false;
 	unsigned sense_agreement = l->SenseAgreement() ? 0 : 1;
 	double flts[2];
 	gp_Pnt pnts[2];
@@ -411,9 +409,9 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeLoop* l, TopoDS_Wire& resu
 		TopoDS_Wire w;
 		if (convert_wire(*it, w)) {
 			if (!(*it)->Orientation()) w.Reverse();
-			TopoDS_Iterator it(w, false);
-			for (; it.More(); it.Next()) {
-				const TopoDS_Edge& e = TopoDS::Edge(it.Value());
+			TopoDS_Iterator topoit(w, false);
+			for (; topoit.More(); topoit.Next()) {
+				const TopoDS_Edge& e = TopoDS::Edge(topoit.Value());
 				mw.Add(e);
 			}
 			// mw.Add(w);

src/ifcgeomserver/IfcGeomServer.cpp

@@ -238,9 +238,9 @@ protected:
 		}
 		{ std::vector<float> diffuse_color_array;
 		for (std::vector<IfcGeom::Material>::const_iterator it = geom->geometry().materials().begin(); it != geom->geometry().materials().end(); ++it) {
-			const IfcGeom::Material& m = *it;
-			if (m.hasDiffuse()) {
-				const double* color = m.diffuse();
+			const IfcGeom::Material& mat = *it;
+			if (mat.hasDiffuse()) {
+				const double* color = mat.diffuse();
 				diffuse_color_array.push_back(static_cast<float>(color[0]));
 				diffuse_color_array.push_back(static_cast<float>(color[1]));
 				diffuse_color_array.push_back(static_cast<float>(color[2]));
@@ -249,8 +249,8 @@ protected:
 				diffuse_color_array.push_back(0.f);
 				diffuse_color_array.push_back(0.f);
 			}
-			if (m.hasTransparency()) {
-				diffuse_color_array.push_back(static_cast<float>(1. - m.transparency()));
+			if (mat.hasTransparency()) {
+				diffuse_color_array.push_back(static_cast<float>(1. - mat.transparency()));
 			} else {
 				diffuse_color_array.push_back(1.f);
 			}
@@ -283,10 +283,6 @@ public:
 };
 
 int main (int argc, char** argv) {
-	if (sizeof(float) != 4 || sizeof(int32_t) != 4) {
-		return 1;
-	}
-
 	// Redirect stdout to this stream, so that involuntary 
 	// writes to stdout do not interfere with our protocol.
 	std::ostringstream oss;
@@ -308,7 +304,7 @@ int main (int argc, char** argv) {
 	Hello().write(std::cout);
 
 	int exit_code = 0;
-	while (1) {
+	for (;;) {
 		const int32_t msg_type = sread<int32_t>(std::cin);
 		switch (msg_type) {
 		case IFC_MODEL: {

src/ifcparse/Ifc2x3-latebound.cpp

@@ -4250,7 +4250,7 @@ std::pair<Type::Enum, unsigned> Type::GetInverseAttribute(Enum t, const std::str
 	if (inverse_map.empty()) ::InitInverseMap();
 	inverse_map_t::const_iterator it;
 	inverse_map_t::mapped_type::const_iterator jt;
-    while (true) {
+	for (;;) {
         it = inverse_map.find(t);
         if (it != inverse_map.end()) {
 			jt = it->second.find(a);
@@ -4270,7 +4270,7 @@ std::set<std::string> Type::GetInverseAttributeNames(Enum t) {
 
 	std::set<std::string> return_value;
 
-    while (true) {
+	for (;;) {
         it = inverse_map.find(t);
         if (it != inverse_map.end()) {
 			for (jt = it->second.begin(); jt != it->second.end(); ++jt) {

src/ifcparse/IfcCharacterDecoder.cpp

@@ -130,7 +130,7 @@ IfcCharacterDecoder::operator std::string() {
 #ifdef HAVE_ICU
 	unsigned int old_hex = 0; // for compatibility_mode
 #endif  
-	while ( current_char = file->Peek() ) {
+	while ( (current_char = file->Peek()) != 0 ) {
 		if ( EXPECTS_CHARACTER(parse_state) ) {
 #ifdef HAVE_ICU
 			if ( previous_codepage != codepage ) {
@@ -227,7 +227,7 @@ void IfcCharacterDecoder::dryRun() {
 	unsigned int parse_state = 0;
 	char current_char;
 	unsigned int hex_count = 0;
-	while ( current_char = file->Peek() ) {
+	while ((current_char = file->Peek()) != 0) {
 		if ( EXPECTS_CHARACTER(parse_state) ) {
 			parse_state = 0;
 		} else if ( current_char == '\'' && ! parse_state ) {
@@ -340,8 +340,8 @@ IfcCharacterEncoder::operator std::string() {
 			oss << "\\X" << num_bytes_str << "\\";
 		}
 		if ( within_spf_range ) {
-			oss.put(ch);
-			if ( ch == '\\' || ch == '\'' ) oss.put(ch);
+			oss.put((char)ch);
+			if ( ch == '\\' || ch == '\'' ) oss.put((char)ch);
 		} else {
 			oss << std::hex << std::setw(num_bytes*2) << std::uppercase << std::setfill('0') << (int) ch;
 		}

src/ifcparse/IfcGlobalId.cpp

@@ -38,7 +38,7 @@ std::string base64(unsigned v, int l) {
 		r.push_back(chars[v%64]);
 		v /= 64;
 	}
-	while ( r.size() != l ) r.push_back('0');
+	while ( (int)r.size() != l ) r.push_back('0');
 	std::reverse(r.begin(),r.end());
 	return r;
 }
@@ -70,7 +70,7 @@ std::string compress(unsigned char* v) {
 
 // Expands the base64 representation into a UUID byte array
 void expand(const std::string& s, std::vector<unsigned char>& v) {
-	v.push_back(from_base64(s.substr(0,2)));
+	v.push_back((unsigned char)from_base64(s.substr(0,2)));
 	for( unsigned i = 0; i < 5; ++i ) {
 		unsigned d = from_base64(s.substr(2+4*i,4));
 		for ( unsigned j = 0; j < 3; ++ j ) {

src/ifcparse/IfcHierarchyHelper.cpp

@@ -290,7 +290,7 @@ void IfcHierarchyHelper::addBox(IfcSchema::IfcShapeRepresentation* rep, double w
 	IfcSchema::IfcAxis2Placement2D* place, IfcSchema::IfcAxis2Placement3D* place2, 
 	IfcSchema::IfcDirection* dir, IfcSchema::IfcRepresentationContext* context) 
 {
-	if (false) {
+	if (false) { // TODO What's this?
 		IfcSchema::IfcRectangleProfileDef* profile = new IfcSchema::IfcRectangleProfileDef(
 			IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, boost::none, place ? place : addPlacement2d(), w, d);
 		IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(profile, 
@@ -303,10 +303,10 @@ void IfcHierarchyHelper::addBox(IfcSchema::IfcShapeRepresentation* rep, double w
 		rep->setItems(items);
 	} else {
 		std::vector<std::pair<double, double> > points;
-		points.push_back(std::pair<double, double>(-w/2, -d/2));
-		points.push_back(std::pair<double, double>(w/2, -d/2));
-		points.push_back(std::pair<double, double>(w/2, d/2));
-		points.push_back(std::pair<double, double>(-w/2, d/2));
+		points.push_back(std::make_pair(-w/2, -d/2));
+		points.push_back(std::make_pair(w/2, -d/2));
+		points.push_back(std::make_pair(w/2, d/2));
+		points.push_back(std::make_pair(-w/2, d/2));
 		// The call to addExtrudedPolyline() closes the polyline
 		addExtrudedPolyline(rep, points, h, place, place2, dir, context);
 	}

src/ifcparse/IfcLateBoundEntity.cpp

@@ -87,35 +87,35 @@ unsigned int IfcParse::IfcLateBoundEntity::getArgumentCount() const {
 	return IfcSchema::Type::GetAttributeCount(_type);
 }
 IfcUtil::ArgumentType IfcParse::IfcLateBoundEntity::getArgumentType(unsigned int i) const {
-	return IfcSchema::Type::GetAttributeDerived(_type, i)
+	return IfcSchema::Type::GetAttributeDerived(_type, (unsigned char)i)
 		? IfcUtil::Argument_DERIVED
-		: IfcSchema::Type::GetAttributeType(_type,i);
+		: IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 }
 IfcSchema::Type::Enum IfcParse::IfcLateBoundEntity::getArgumentEntity(unsigned int i) const {
-	return IfcSchema::Type::GetAttributeEntity(_type, i);
+	return IfcSchema::Type::GetAttributeEntity(_type, (unsigned char)i);
 }
 Argument* IfcParse::IfcLateBoundEntity::getArgument(unsigned int i) const {
 	return entity->getArgument(i);
 }
 const char* IfcParse::IfcLateBoundEntity::getArgumentName(unsigned int i) const {
-	return IfcSchema::Type::GetAttributeName(_type,i).c_str();
+	return IfcSchema::Type::GetAttributeName(_type, (unsigned char)i).c_str();
 }
 bool IfcParse::IfcLateBoundEntity::getArgumentOptionality(unsigned int i) const {
-	return IfcSchema::Type::GetAttributeOptional(_type, i);
+	return IfcSchema::Type::GetAttributeOptional(_type, (unsigned char)i);
 }
 
 void IfcParse::IfcLateBoundEntity::invalid_argument(unsigned int i, const std::string& t) {
-	const std::string arg_name = IfcSchema::Type::GetAttributeName(_type,i);
+	const std::string arg_name = IfcSchema::Type::GetAttributeName(_type, (unsigned char)i);
 	throw IfcException(t + " is not a valid type for '" + arg_name + "'");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsNull(unsigned int i) {
-	bool is_optional = IfcSchema::Type::GetAttributeOptional(_type, i);
+	bool is_optional = IfcSchema::Type::GetAttributeOptional(_type, (unsigned char)i);
 	if (is_optional) {
 		writable_entity()->setArgument(i);
 	} else invalid_argument(i,"NULL");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsInt(unsigned int i, int v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_INT) {
 		writable_entity()->setArgument(i,v);	
 	} else if ( (arg_type == Argument_BOOL) && ( (v == 0) || (v == 1) ) ) {
@@ -123,23 +123,23 @@ void IfcParse::IfcLateBoundEntity::setArgumentAsInt(unsigned int i, int v) {
 	} else invalid_argument(i,"INTEGER");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsBool(unsigned int i, bool v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_BOOL) {
 		writable_entity()->setArgument(i,v);	
 	} else invalid_argument(i,"BOOLEAN");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsDouble(unsigned int i, double v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_DOUBLE) {
 		writable_entity()->setArgument(i,v);	
 	} else invalid_argument(i,"REAL");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsString(unsigned int i, const std::string& a) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_STRING) {
 		writable_entity()->setArgument(i,a);
 	} else if (arg_type == Argument_ENUMERATION) {
-		std::pair<const char*, int> enum_data = IfcSchema::Type::GetEnumerationIndex(IfcSchema::Type::GetAttributeEntity(_type, i), a);
+		std::pair<const char*, int> enum_data = IfcSchema::Type::GetEnumerationIndex(IfcSchema::Type::GetAttributeEntity(_type, (unsigned char)i), a);
 		writable_entity()->setArgument(i, enum_data.second, enum_data.first);
 	} else if (arg_type == Argument_BINARY) {
 		if (valid_binary_string(a)) {
@@ -151,19 +151,19 @@ void IfcParse::IfcLateBoundEntity::setArgumentAsString(unsigned int i, const std
 	} else invalid_argument(i,"STRING");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsAggregateOfInt(unsigned int i, const std::vector<int>& v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_AGGREGATE_OF_INT) {
 		writable_entity()->setArgument(i,v);	
 	} else invalid_argument(i,"AGGREGATE OF INT");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsAggregateOfDouble(unsigned int i, const std::vector<double>& v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_AGGREGATE_OF_DOUBLE) {
 		writable_entity()->setArgument(i,v);	
 	} else invalid_argument(i,"AGGREGATE OF DOUBLE");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsAggregateOfString(unsigned int i, const std::vector<std::string>& v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_AGGREGATE_OF_STRING) {
 		writable_entity()->setArgument(i,v);	
 	} else if (arg_type == Argument_AGGREGATE_OF_BINARY) {
@@ -180,31 +180,31 @@ void IfcParse::IfcLateBoundEntity::setArgumentAsAggregateOfString(unsigned int i
 	} else invalid_argument(i,"AGGREGATE OF STRING");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsEntityInstance(unsigned int i, IfcParse::IfcLateBoundEntity* v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_ENTITY_INSTANCE) {
 		writable_entity()->setArgument(i,v);	
 	} else invalid_argument(i,"ENTITY INSTANCE");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsAggregateOfEntityInstance(unsigned int i, IfcEntityList::ptr v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_AGGREGATE_OF_ENTITY_INSTANCE) {
 		writable_entity()->setArgument(i,v);	
 	} else invalid_argument(i,"AGGREGATE OF ENTITY INSTANCE");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsAggregateOfAggregateOfInt(unsigned int i, const std::vector< std::vector<int> >& v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_AGGREGATE_OF_AGGREGATE_OF_INT) {
 		writable_entity()->setArgument(i,v);	
 	} else invalid_argument(i,"AGGREGATE OF AGGREGATE OF INT");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsAggregateOfAggregateOfDouble(unsigned int i, const std::vector< std::vector<double> >& v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE) {
 		writable_entity()->setArgument(i,v);	
 	} else invalid_argument(i,"AGGREGATE OF AGGREGATE OF DOUBLE");
 }
 void IfcParse::IfcLateBoundEntity::setArgumentAsAggregateOfAggregateOfEntityInstance(unsigned int i, IfcEntityListList::ptr v) {
-	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type,i);
+	IfcUtil::ArgumentType arg_type = IfcSchema::Type::GetAttributeType(_type, (unsigned char)i);
 	if (arg_type == Argument_AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE) {
 		writable_entity()->setArgument(i,v);	
 	} else invalid_argument(i,"AGGREGATE OF AGGREGATE OF ENTITY INSTANCE");
@@ -230,7 +230,7 @@ bool IfcParse::IfcLateBoundEntity::is_valid() {
 			const Argument& arg = *getArgument(i);
 			is_null = arg.isNull();
 		} catch(IfcException) {}
-		if (!IfcSchema::Type::GetAttributeOptional(_type,i) && is_null) {
+		if (!IfcSchema::Type::GetAttributeOptional(_type, (unsigned char)i) && is_null) {
 			if (!valid) {
 				oss << ", ";
 			}

src/ifcparse/IfcParse.cpp

@@ -308,7 +308,7 @@ Token IfcSpfLexer::Next() {
 	while ( ! stream->eof ) {
 
 		// Read character and increment pointer if not starting a new token
-		char c = stream->Peek();
+		c = stream->Peek();
 		if ( len && (c == '(' || c == ')' || c == '=' || c == ',' || c == ';' || c == '/') ) break;
 		stream->Inc();
 		len ++;
@@ -363,7 +363,7 @@ bool TokenFunc::startsWith(const Token& t, char c) {
 }
 
 bool TokenFunc::isOperator(const Token& t, char op) {
-	return (!t.first) && (!op || op == t.second);
+	return (!t.first) && (!op || (unsigned)op == t.second);
 }
 
 bool TokenFunc::isIdentifier(const Token& t) {
@@ -394,8 +394,8 @@ bool TokenFunc::isInt(const Token& t) {
 	const std::string str = asString(t);
 	const char* start = str.c_str();
 	char* end;
-	long result = strtol(start,&end,10);
-	return ((end - start) == str.length());
+	/*long result =*/ strtol(start,&end,10);
+	return ((end - start) == (ptrdiff_t)str.length());
 }
 
 bool TokenFunc::isBool(const Token& t) {
@@ -412,11 +412,11 @@ bool TokenFunc::isFloat(const Token& t) {
 	const char* start = str.c_str();
 	char* end;
 #ifdef _MSC_VER
-	double result = _strtod_l(start,&end,locale);
+	/*double result =*/ _strtod_l(start,&end,locale);
 #else
 	double result = strtod_l(start,&end,locale);
 #endif
-	return ((end - start) == str.length());
+	return ((end - start) == (ptrdiff_t)str.length());
 }
 
 int TokenFunc::asInt(const Token& t) {
@@ -508,8 +508,7 @@ EntityArgument::EntityArgument(const Token& t) {
 // Aditionally, stores the ids (i.e. #[\d]+) in a vector
 //
 void ArgumentList::read(IfcSpfLexer* t, std::vector<unsigned int>& ids) {
-	IfcParse::IfcFile* file = t->file;
-	
+	//IfcParse::IfcFile* file = t->file;
 	Token next = t->Next();
 	while( next.second || next.first ) {
 		if ( TokenFunc::isOperator(next,',') ) {
@@ -517,9 +516,9 @@ void ArgumentList::read(IfcSpfLexer* t, std::vector<unsigned int>& ids) {
 		} else if ( TokenFunc::isOperator(next,')') ) {
 			break;
 		} else if ( TokenFunc::isOperator(next,'(') ) {
-			ArgumentList* list = new ArgumentList();
-			list->read(t, ids);
-			push(list);
+			ArgumentList* alist = new ArgumentList();
+			alist->read(t, ids);
+			push(alist);
 		} else {
 			if ( TokenFunc::isIdentifier(next) ) {
 				ids.push_back(TokenFunc::asInt(next));
@@ -640,7 +639,7 @@ ArgumentList::operator IfcEntityListList::ptr() const {
 	for ( it = list.begin(); it != list.end(); ++ it ) {
 		const Argument* arg = *it;
 		const ArgumentList* arg_list;
-		if ((arg_list = dynamic_cast<const ArgumentList*>(arg))) {
+		if ((arg_list = dynamic_cast<const ArgumentList*>(arg)) != 0) {
 			IfcEntityList::ptr e = *arg_list;
 			l->push(e);
 		}
@@ -1070,9 +1069,9 @@ void IfcFile::addEntities(IfcEntityList::ptr es) {
 IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* entity) {
 	// If this instance has been inserted before, return
 	// a reference to the copy that was created from it.
-	entity_entity_map_t::iterator it = entity_file_map.find(entity);
-	if (it != entity_file_map.end()) {
-		return it->second;
+	entity_entity_map_t::iterator mit = entity_file_map.find(entity);
+	if (mit != entity_file_map.end()) {
+		return mit->second;
 	}
 
 	// Obtain all forward references by a depth-first 
@@ -1272,8 +1271,8 @@ void IfcFile::removeEntity(IfcUtil::IfcBaseClass* entity) {
 	// moment, inversely related instances affected by the removal of the
 	// entity being deleted are not deleted themselves.
 	if (references) {
-		for (IfcEntityList::it it = references->begin(); it != references->end(); ++it) {
-			IfcUtil::IfcBaseEntity* related_instance = (IfcUtil::IfcBaseEntity*) *it;
+		for (IfcEntityList::it iit = references->begin(); iit != references->end(); ++iit) {
+			IfcUtil::IfcBaseEntity* related_instance = (IfcUtil::IfcBaseEntity*) *iit;
 			for (unsigned i = 0; i < related_instance->getArgumentCount(); ++i) {
 				Argument* attr = related_instance->getArgument(i);
 				if (attr->isNull()) continue;
@@ -1495,21 +1494,21 @@ std::pair<IfcSchema::IfcNamedUnit*, double> IfcFile::getUnit(IfcSchema::IfcUnitE
 				if (named_unit->UnitType() != type) {
 					continue;
 				}
-				IfcSchema::IfcSIUnit* unit = 0;
+				IfcSchema::IfcSIUnit* siunit = 0;
 				if (named_unit->is(IfcSchema::Type::IfcConversionBasedUnit)) {
 					IfcSchema::IfcConversionBasedUnit* u = (IfcSchema::IfcConversionBasedUnit*)named_unit;
 					IfcSchema::IfcMeasureWithUnit* mu = u->ConversionFactor();
 					return_value.second *= static_cast<double>(*mu->ValueComponent()->entity->getArgument(0));
 					return_value.first = named_unit;
 					if (mu->UnitComponent()->is(IfcSchema::Type::IfcSIUnit)) {
-						unit = (IfcSchema::IfcSIUnit*) mu->UnitComponent();
+						siunit = (IfcSchema::IfcSIUnit*) mu->UnitComponent();
 					}
 				} else if (named_unit->is(IfcSchema::Type::IfcSIUnit)) {
-					return_value.first = unit = (IfcSchema::IfcSIUnit*) named_unit;
+					return_value.first = siunit = (IfcSchema::IfcSIUnit*) named_unit;
 				}
-				if (unit) {
-					if (unit->hasPrefix()) {
-						return_value.second *= IfcSIPrefixToValue(unit->Prefix());
+				if (siunit) {
+					if (siunit->hasPrefix()) {
+						return_value.second *= IfcSIPrefixToValue(siunit->Prefix());
 					}
 				}
 			}

src/ifcparse/IfcSpfHeader.h

@@ -29,6 +29,9 @@ class HeaderEntity : public IfcAbstractEntity {
 private:	
 	ArgumentList* _list;
 	const char * const _datatype;
+
+	HeaderEntity(const HeaderEntity&); //N/A
+	HeaderEntity& operator =(const HeaderEntity&); //N/A
 protected:
 	HeaderEntity(const char * const datatype, IfcSpfLexer* lexer) 
 		: _datatype(datatype), _list(0)

src/ifcparse/IfcWrite.cpp

@@ -104,7 +104,6 @@ std::string IfcWritableEntity::toString(bool upper) const {
 	ss << dt << "(";
 	for (std::map<int,Argument*>::const_iterator it = args.begin(); it != args.end(); ++ it) {
 		if ( it != args.begin() ) ss << ",";
-		const Argument* a = it->second;
 		ss << it->second->toString(upper);
 	}
 	ss << ")";
@@ -140,7 +139,6 @@ void IfcWritableEntity::setArgument(int i) {
 }
 
 void IfcWritableEntity::setArgument(int i, Argument* a) {
-	IfcWrite::IfcWriteArgument* wa = new IfcWrite::IfcWriteArgument(this);
 	IfcUtil::ArgumentType attr_type = a->type();
 	switch(attr_type) {
 	case IfcUtil::Argument_NULL:
@@ -182,7 +180,7 @@ void IfcWritableEntity::setArgument(int i, Argument* a) {
 		this->setArgument(i, attr_value); }
 		break;
 	case IfcUtil::Argument_ENUMERATION: {
-		IfcSchema::Type::Enum ty = IfcSchema::Type::GetAttributeEntity(_type, i);
+		IfcSchema::Type::Enum ty = IfcSchema::Type::GetAttributeEntity(_type, (unsigned char)i);
 		std::string enum_literal = a->toString();
 		// Remove leading and trailing '.'
 		enum_literal = enum_literal.substr(1, enum_literal.size() - 2);
@@ -312,6 +310,9 @@ public:
 
 class StringBuilderVisitor : public boost::static_visitor<void> {
 private:
+	StringBuilderVisitor(const StringBuilderVisitor&); //N/A
+	StringBuilderVisitor& operator =(const StringBuilderVisitor&); //N/A
+
 	std::ostringstream& data;
 	template <typename T> void serialize(const std::vector<T>& i) {
 		data << "(";

src/ifcwrap/IfcPython.i

@@ -36,6 +36,15 @@
 # include <time.h>
 # include <wchar.h>
 #endif
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable : 4127 4244 4702 4510 4512 4610)
+# if _MSC_VER > 1800
+#  pragma warning(disable : 4456 4459)
+# endif
+#endif
+// TODO add '# pragma warning(pop)' to the very end of the file
 %}
 
 %include "std_string.i"