remove inline functions from Expr

src/sql/Expr.cpp

@@ -5,16 +5,6 @@
 
 namespace hsql {
 
-    char* substr(const char* source, int from, int to) {
-        int len = to-from;
-        char* copy = new char[len+1];
-        strncpy(copy, source+from, len);
-        copy[len] = '\0';
-        return copy;
-    }
-
-
-
     Expr::Expr(ExprType type) :
         type(type),
         expr(NULL),
@@ -38,8 +28,6 @@ namespace hsql {
         return e;
     }
 
-
-
     Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) {
         Expr* e = new Expr(kExprOperator);
         e->op_type = op;
@@ -58,8 +46,6 @@ namespace hsql {
         return e;
     }
 
-
-
     Expr* Expr::makeLiteral(int64_t val) {
         Expr* e = new Expr(kExprLiteralInt);
         e->ival = val;
@@ -106,4 +92,40 @@ namespace hsql {
         return e;
     }
 
-} // namespace hsql
+    bool Expr::isType(ExprType e_type) {
+        return e_type == type;
+    }
+
+    bool Expr::isLiteral() {
+        return isType(kExprLiteralInt) || isType(kExprLiteralFloat) || isType(kExprLiteralString) || isType(kExprPlaceholder);
+    }
+
+    bool Expr::hasAlias() {
+        return alias != NULL;
+    }
+
+    bool Expr::hasTable() {
+        return table != NULL;
+    }
+
+    char* Expr::getName() {
+        if (alias != NULL) return alias;
+        else return name;
+    }
+
+    bool Expr::isSimpleOp() {
+        return op_type == SIMPLE_OP;
+    }
+
+    bool Expr::isSimpleOp(char op) {
+        return isSimpleOp() && op_char == op;
+    }
+    
+    char* substr(const char* source, int from, int to) {
+        int len = to-from;
+        char* copy = new char[len+1];
+        strncpy(copy, source+from, len);
+        copy[len] = '\0';
+        return copy;
+    }
+} // namespace hsql

src/sql/Expr.h

@@ -6,12 +6,11 @@
 
 namespace hsql {
 
-// Helper function
+    // Helper function used by the lexer.
+    // TODO: move to more appropriate place.
     char* substr(const char* source, int from, int to);
 
-
+    enum ExprType {
-
-    typedef enum {
         kExprLiteralFloat,
         kExprLiteralString,
         kExprLiteralInt,
@@ -20,27 +19,21 @@ namespace hsql {
         kExprColumnRef,
         kExprFunctionRef,
         kExprOperator
-    } ExprType;
+    };
-
 
     typedef struct Expr Expr;
 
-    /**
+    // Represents SQL expressions (i.e. literals, operators, column_refs).
-     * Represents SQL expressions (i.e. literals, operators, column_refs)
+    // TODO: When destructing a placeholder expression, we might need to alter the placeholder_list.
-     *
-     * TODO: When destructing a placeholder expression, we might need to alter the placeholder_list
-     */
     struct Expr {
-        /**
+        // Operator types. These are important for expressions of type kExprOperator.
-         * Operator types. These are important for expressions of type kExprOperator
+        // Trivial types are those that can be described by a single character e.g:
-         * Trivial types are those that can be described by a single character e.g:
+        // + - * / < > = %
-         * + - * / < > = %
+        // Non-trivial are: <> <= >= LIKE ISNULL NOT
-         * Non-trivial are:
+        enum OperatorType {
-         * <> <= >= LIKE ISNULL NOT
-         */
-        typedef enum {
             SIMPLE_OP,
-            // Binary
+
+            // Binary operators.
             NOT_EQUALS,
             LESS_EQ,
             GREATER_EQ,
@@ -48,18 +41,20 @@ namespace hsql {
             NOT_LIKE,
             AND,
             OR,
-            // Unary
+
+            // Unary operators.
             NOT,
             UMINUS,
             ISNULL
-        } OperatorType;
+        };
 
 
 
         Expr(ExprType type);
 
         // Interesting side-effect:
-        // Making the destructor virtual used to cause segmentation faults
+        // Making the destructor virtual used to cause segmentation faults.
+        // TODO: inspect.
         ~Expr();
 
         ExprType type;
@@ -77,47 +72,41 @@ namespace hsql {
         char op_char;
         bool distinct;
 
+        // Convenience accessor methods.
 
-        /**
+        bool isType(ExprType e_type);
-         * Convenience accessor methods
+
-         */
+        bool isLiteral();
-        inline bool isType(ExprType e_type) {
+
-            return e_type == type;
+        bool hasAlias();
-        }
+
-        inline bool isLiteral() {
+        bool hasTable();
-            return isType(kExprLiteralInt) || isType(kExprLiteralFloat) || isType(kExprLiteralString) || isType(kExprPlaceholder);
+
-        }
+        char* getName();
-        inline bool hasAlias() {
+
-            return alias != NULL;
+        bool isSimpleOp();
-        }
+
-        inline bool hasTable() {
+        bool isSimpleOp(char op);
-            return table != NULL;
-        }
-        inline char* getName() {
-            if (alias != NULL) return alias;
-            else return name;
-        }
-        inline bool isSimpleOp() {
-            return op_type == SIMPLE_OP;
-        }
-        inline bool isSimpleOp(char op) {
-            return isSimpleOp() && op_char == op;
-        }
 
 
-        /**
+        // Static constructors.
-         * Static expression constructors
+
-         */
         static Expr* makeOpUnary(OperatorType op, Expr* expr);
+
         static Expr* makeOpBinary(Expr* expr1, char op, Expr* expr2);
+
         static Expr* makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2);
 
         static Expr* makeLiteral(int64_t val);
+
         static Expr* makeLiteral(double val);
+
         static Expr* makeLiteral(char* val);
 
         static Expr* makeColumnRef(char* name);
+
         static Expr* makeColumnRef(char* table, char* name);
+
         static Expr* makeFunctionRef(char* func_name, Expr* expr, bool distinct);
 
         static Expr* makePlaceholder(int id);