Remove some excess semi-colons

kazmath.files

@@ -84,3 +84,11 @@ kazmath/ray3.h
 kazmath/ray3.c
 tests/test_ray3.cpp
 tests/test_vec3.cpp
+kazmathxx/vec4.h
+kazmathxx/vec3.h
+kazmathxx/vec2.h
+kazmathxx/quaternion.h
+kazmathxx/plane.h
+kazmathxx/mat4.h
+kazmathxx/mat3.h
+kazmathxx/aabb.h

kazmathxx/mat3.h

@@ -102,11 +102,11 @@ namespace km
 		mat3 result;
 		kmMat3Multiply(&result, &lhs, &rhs);
 		return result;
-	};
+    }
 
 	///< Checks for equality (with a small threshold epsilon)
 	inline const bool operator==(const mat3& lhs, const mat3& rhs)
 	{
 		return kmMat3AreEqual(&lhs,&rhs);
-	};
+    }
 }

kazmathxx/vec2.h

@@ -142,7 +142,7 @@ namespace km
 
             inline const vec2 cross( const vec2& rhs )
             {
-                kmVec2Cross( this, &rhs )
+                kmVec2Cross(this, &rhs);
                 return *this;
             }
 	};
@@ -153,51 +153,51 @@ namespace km
 		vec2 result;
 		kmVec2Add(&result, &lhs, &rhs);
 		return result;
-	};
+    }
 
 	///< Vector subtraction
 	inline const vec2 operator-(const vec2& lhs, const vec2& rhs)
 	{
 		vec2 result;
 		kmVec2Subtract(&result, &lhs, &rhs);
 		return result;
-	};
+    }
 
 	///< Dot product - which is the cosine of the angle between the two vectors multiplied by their lengths
 	inline const float operator*(const vec2& lhs, const vec2& rhs)
 	{
 		return kmVec2Dot(&lhs, &rhs);
-	};
+    }
 
 	///< Multiply with scalar
 	inline const vec2 operator*(const kmScalar lhs, const vec2& rhs)
 	{
 		vec2 result;
 		kmVec2Scale(&result, &rhs, lhs);
 		return result;
-	};
+    }
 
 	///< Multiply with scalar	
 	inline const vec2 operator*(const vec2& lhs, const kmScalar rhs)
 	{
 		vec2 result;
 		kmVec2Scale(&result, &lhs, rhs);
 		return result;
-	};
+    }
 
 	///< Transform through matrix	
 	inline const vec2 operator*(const kmMat3& lhs, const vec2& rhs)
 	{
 		vec2 result;
 		kmVec2Transform(&result, &rhs, &lhs);
 		return result;
-	};
+    }
 
 	///< Checks for equality (with a small threshold epsilon)
     inline const bool operator==(const vec2& lhs, const vec2& rhs)
 	{
 		return (kmVec2AreEqual(&lhs,&rhs) != 0);
-	};
+    }
 } //end of namespace km
 
 #endif

kazmathxx/vec3.h

@@ -182,51 +182,51 @@ namespace km
 		vec3 result;
 		kmVec3Add(&result, &lhs, &rhs);
 		return result;
-	};
+    }
 
 	///< Vector subtraction
 	inline const vec3 operator-(const vec3& lhs, const vec3& rhs)
 	{
 		vec3 result;
 		kmVec3Subtract(&result, &lhs, &rhs);
 		return result;
-	};
+    }
 
 	///< Dot product - which is the cosine of the angle between the two vectors multiplied by their lengths
 	inline const float operator*(const vec3& lhs, const vec3& rhs)
 	{
 		return kmVec3Dot(&lhs, &rhs);
-	};
+    }
 
 	///< Multiply with scalar
 	inline const vec3 operator*(const kmScalar lhs, const vec3& rhs)
 	{
 		vec3 result;
 		kmVec3Scale(&result, &rhs, lhs);
 		return result;
-	};
+    }
 
 	///< Multiply with scalar	
 	inline const vec3 operator*(const vec3& lhs, const kmScalar rhs)
 	{
 		vec3 result;
 		kmVec3Scale(&result, &lhs, rhs);
 		return result;
-	};
+    }
 
 	///< Transform through matrix	
 	inline const vec3 operator*(const kmMat4& lhs, const vec3& rhs)
 	{
 		vec3 result;
 		kmVec3Transform(&result, &rhs, &lhs);
 		return result;
-	};
+    }
 
 	///< Checks for equality (with a small threshold epsilon)
 	inline const bool operator==(const vec3& lhs, const vec3& rhs)
 	{
 		return (kmVec3AreEqual(&lhs,&rhs) != 0);
-	};
+    }
 } //end of namespace km
 
 #endif

kazmathxx/vec4.h

@@ -158,51 +158,51 @@ namespace km
 		vec4 result;
 		kmVec4Add(&result, &lhs, &rhs);
 		return result;
-	};
+    }
 
 	///< Vector subtraction
 	inline const vec4 operator-(const vec4& lhs, const vec4& rhs)
 	{
 		vec4 result;
 		kmVec4Subtract(&result, &lhs, &rhs);
 		return result;
-	};
+    }
 
 	///< Dot product - which is the cosine of the angle between the two vectors multiplied by their lengths
 	inline const float operator*(const vec4& lhs, const vec4& rhs)
 	{
 		return kmVec4Dot(&lhs, &rhs);
-	};
+    }
 
 	///< Multiply with scalar
 	inline const vec4 operator*(const kmScalar lhs, const vec4& rhs)
 	{
 		vec4 result;
 		kmVec4Scale(&result, &rhs, lhs);
 		return result;
-	};
+    }
 
 	///< Multiply with scalar	
 	inline const vec4 operator*(const vec4& lhs, const kmScalar rhs)
 	{
 		vec4 result;
 		kmVec4Scale(&result, &lhs, rhs);
 		return result;
-	};
+    }
 
 	///< Transform through matrix	
 	inline const vec4 operator*(const kmMat4& lhs, const vec4& rhs)
 	{
 		vec4 result;
 		kmVec4Transform(&result, &rhs, &lhs);
 		return result;
-	};
+    }
 
 	///< Checks for equality (with a small threshold epsilon)
 	inline const bool operator==(const vec4& lhs, const vec4& rhs)
 	{
 		return (kmVec4AreEqual(&lhs,&rhs) != 0);
-	};
+    }
 } //end of namespace km
 
 #endif