[Avida-SVN] r1725 - in development/source: analyze tools
ofria at myxo.css.msu.edu
ofria at myxo.css.msu.edu
Thu Jun 28 14:38:42 PDT 2007
Author: ofria
Date: 2007-06-28 17:38:42 -0400 (Thu, 28 Jun 2007)
New Revision: 1725
Modified:
development/source/analyze/cAnalyze.cc
development/source/analyze/cAnalyze.h
development/source/tools/cFlexVar.h
development/source/tools/cString.h
Log:
Setup cFlexVar to handle assignment and relationship operators (including a macro framework to
semi-easily add more operators, but its hard to get it to be too simple with all of the combinations
of base types needing to be accounted for).
Setup analyze.cfg to automatically be created if it does not exist on startup of analyze mode
(along with a warning message).
Added a "TEST" command to analyze mode. This calls the method cAnalyze::PrintTestInfo(), which developers can fill
out with any test info they want (there is no guaranteed behavior other than it gets called when you run TEST in
analyze mode).
Modified: development/source/analyze/cAnalyze.cc
===================================================================
--- development/source/analyze/cAnalyze.cc 2007-06-28 18:54:06 UTC (rev 1724)
+++ development/source/analyze/cAnalyze.cc 2007-06-28 21:38:42 UTC (rev 1725)
@@ -141,16 +141,29 @@
cInitFile analyze_file(filename);
if (!analyze_file.IsOpen()) {
- cerr << "Error: Cannot load file: \"" << filename << "\"." << endl;
- if (exit_on_error) exit(1);
+ cerr << "Warning: Cannot load file: \"" << filename << "\"." << endl
+ << "...creating it..." << endl;
+ ofstream fp(filename);
+ fp << "################################################################################################" << endl
+ << "# This file is used to setup avida when it is in analysis-only mode, which can be triggered by" << endl
+ << "# running \"avida -a\"." << endl
+ << "# " << endl
+ << "# Please see the documentation in doc/analyze_mode.html for information on how to use analyze" << endl
+ << "# mode, or the file doc/analyze_samples.html for guidelines on writing programs." << endl
+ << "################################################################################################" << endl
+ << endl;
+ fp.close();
+ //if (exit_on_error) exit(1);
}
- analyze_file.Load();
- analyze_file.Compress();
- analyze_file.Close();
-
- LoadCommandList(analyze_file, command_list);
- ProcessCommands(command_list);
-
+ else {
+ analyze_file.Load();
+ analyze_file.Compress();
+ analyze_file.Close();
+
+ LoadCommandList(analyze_file, command_list);
+ ProcessCommands(command_list);
+ }
+
if (!saved_analyze) m_ctx.ClearAnalyzeMode();
}
@@ -7141,6 +7154,40 @@
cout << "::: " << cur_string << '\n';
}
+void cAnalyze::PrintTestInfo(cString cur_string)
+{
+ cFlexVar var1(1), var2(2.0), var3('3'), var4("four");
+ cFlexVar var5(9), var6(9.0), var7('9'), var8("9");
+
+ tArray<cFlexVar> vars(10);
+ vars[0] = "Testing";
+ vars[1] = 1;
+ vars[2] = 2.0;
+ vars[3] = '3';
+ vars[4] = "four";
+ vars[5] = 9;
+ vars[6] = 9.0;
+ vars[7] = '9';
+ vars[8] = "9";
+
+ cout << "AsString: ";
+ for (int i = 0; i < 10; i++) cout << i << ":" << vars[i].AsString() << " ";
+ cout << endl;
+
+ cout << "AsInt: ";
+ for (int i = 0; i < 10; i++) cout << i << ":" << vars[i].AsInt() << " ";
+ cout << endl;
+
+ for (int i = 0; i < 10; i++) {
+ for (int j = i+1; j < 10; j++) {
+ cout << " vars[" << i << "] <= vars[" << j << "] ? " << (vars[i] <= vars[j]);
+ cout << " vars[" << j << "] <= vars[" << i << "] ? " << (vars[j] <= vars[i]);
+ cout << endl;
+ }
+ }
+
+}
+
void cAnalyze::IncludeFile(cString cur_string)
{
while (cur_string.GetSize() > 0) {
@@ -8009,13 +8056,14 @@
AddLibraryDef("RECALCULATE", &cAnalyze::BatchRecalculate);
AddLibraryDef("RENAME", &cAnalyze::BatchRename);
AddLibraryDef("STATUS", &cAnalyze::PrintStatus);
+ AddLibraryDef("ECHO", &cAnalyze::PrintDebug);
AddLibraryDef("DEBUG", &cAnalyze::PrintDebug);
- AddLibraryDef("ECHO", &cAnalyze::PrintDebug);
+ AddLibraryDef("TEST", &cAnalyze::PrintTestInfo);
AddLibraryDef("INCLUDE", &cAnalyze::IncludeFile);
AddLibraryDef("RUN", &cAnalyze::IncludeFile);
AddLibraryDef("SYSTEM", &cAnalyze::CommandSystem);
AddLibraryDef("INTERACTIVE", &cAnalyze::CommandInteractive);
-
+
// Functions...
AddLibraryDef("FUNCTION", &cAnalyze::FunctionCreate);
Modified: development/source/analyze/cAnalyze.h
===================================================================
--- development/source/analyze/cAnalyze.h 2007-06-28 18:54:06 UTC (rev 1724)
+++ development/source/analyze/cAnalyze.h 2007-06-28 21:38:42 UTC (rev 1725)
@@ -275,6 +275,7 @@
void BatchRename(cString cur_string);
void PrintStatus(cString cur_string);
void PrintDebug(cString cur_string);
+ void PrintTestInfo(cString cur_string);
void IncludeFile(cString cur_string);
void CommandSystem(cString cur_string);
void CommandInteractive(cString cur_string);
Modified: development/source/tools/cFlexVar.h
===================================================================
--- development/source/tools/cFlexVar.h 2007-06-28 18:54:06 UTC (rev 1724)
+++ development/source/tools/cFlexVar.h 2007-06-28 21:38:42 UTC (rev 1725)
@@ -30,6 +30,19 @@
cString AsString() const { cString out_str; SetString(out_str); return out_str; }
virtual eFlexType GetType() const { return TYPE_NONE; }
+
+#define ABSTRACT_FLEX_VAR_BASE_OP(OP, RETURN_TYPE) \
+ virtual RETURN_TYPE operator OP (int in_var) const = 0; \
+ virtual RETURN_TYPE operator OP (char in_var) const = 0; \
+ virtual RETURN_TYPE operator OP (double in_var) const = 0; \
+ virtual RETURN_TYPE operator OP (const cString & in_var) const = 0;
+
+ ABSTRACT_FLEX_VAR_BASE_OP(==, bool)
+ ABSTRACT_FLEX_VAR_BASE_OP(!=, bool)
+ ABSTRACT_FLEX_VAR_BASE_OP(<, bool)
+ ABSTRACT_FLEX_VAR_BASE_OP(>, bool)
+ ABSTRACT_FLEX_VAR_BASE_OP(<=, bool)
+ ABSTRACT_FLEX_VAR_BASE_OP(>=, bool)
};
class cFlexVar_Int : public cFlexVar_Base {
@@ -45,6 +58,19 @@
void SetString(cString & in_str) const { in_str.Set("%d", value); }
eFlexType GetType() const { return TYPE_INT; }
+
+#define CREATE_FLEX_VAR_INT_MATH_OP(OP, RETURN_TYPE) \
+ RETURN_TYPE operator OP (int in_var) const { return value OP in_var; } \
+ RETURN_TYPE operator OP (char in_var) const { return value OP (int) in_var; } \
+ RETURN_TYPE operator OP (double in_var) const { return ((double) value) OP in_var; } \
+ RETURN_TYPE operator OP (const cString & in_var) const { return ((double) value) OP in_var.AsDouble(); }
+
+ CREATE_FLEX_VAR_INT_MATH_OP(==, bool);
+ CREATE_FLEX_VAR_INT_MATH_OP(!=, bool);
+ CREATE_FLEX_VAR_INT_MATH_OP(<, bool);
+ CREATE_FLEX_VAR_INT_MATH_OP(>, bool);
+ CREATE_FLEX_VAR_INT_MATH_OP(<=, bool);
+ CREATE_FLEX_VAR_INT_MATH_OP(>=, bool);
};
class cFlexVar_Char : public cFlexVar_Base {
@@ -60,6 +86,19 @@
void SetString(cString & in_str) const { in_str.Set("%c", value); }
eFlexType GetType() const { return TYPE_CHAR; }
+
+#define CREATE_FLEX_VAR_CHAR_MATH_OP(OP, RETURN_TYPE) \
+ RETURN_TYPE operator OP (int in_var) const { return ((int) value) OP in_var; } \
+ RETURN_TYPE operator OP (char in_var) const { return value OP in_var; } \
+ RETURN_TYPE operator OP (double in_var) const { return ((double) value) OP in_var; } \
+ RETURN_TYPE operator OP (const cString & in_var) const { return cString(&value, 1) OP in_var; }
+
+ CREATE_FLEX_VAR_CHAR_MATH_OP(==, bool);
+ CREATE_FLEX_VAR_CHAR_MATH_OP(!=, bool);
+ CREATE_FLEX_VAR_CHAR_MATH_OP(<, bool);
+ CREATE_FLEX_VAR_CHAR_MATH_OP(>, bool);
+ CREATE_FLEX_VAR_CHAR_MATH_OP(<=, bool);
+ CREATE_FLEX_VAR_CHAR_MATH_OP(>=, bool);
};
class cFlexVar_Double : public cFlexVar_Base {
@@ -75,6 +114,19 @@
void SetString(cString & in_str) const { in_str.Set("%f", value); }
eFlexType GetType() const { return TYPE_DOUBLE; }
+
+#define CREATE_FLEX_VAR_DOUBLE_MATH_OP(OP, RETURN_TYPE) \
+ RETURN_TYPE operator OP (int in_var) const { return value OP (double) in_var; } \
+ RETURN_TYPE operator OP (char in_var) const { return value OP (double) in_var; } \
+ RETURN_TYPE operator OP (double in_var) const { return value OP in_var; } \
+ RETURN_TYPE operator OP (const cString & in_var) const { return value OP in_var.AsDouble(); }
+
+ CREATE_FLEX_VAR_DOUBLE_MATH_OP(==, bool);
+ CREATE_FLEX_VAR_DOUBLE_MATH_OP(!=, bool);
+ CREATE_FLEX_VAR_DOUBLE_MATH_OP(<, bool);
+ CREATE_FLEX_VAR_DOUBLE_MATH_OP(>, bool);
+ CREATE_FLEX_VAR_DOUBLE_MATH_OP(<=, bool);
+ CREATE_FLEX_VAR_DOUBLE_MATH_OP(>=, bool);
};
class cFlexVar_String : public cFlexVar_Base {
@@ -90,31 +142,84 @@
void SetString(cString & in_str) const { in_str = value; }
eFlexType GetType() const { return TYPE_STRING; }
+
+#define CREATE_FLEX_VAR_STRING_MATH_OP(OP, RETURN_TYPE) \
+ RETURN_TYPE operator OP (int in_var) const { return value.AsDouble() OP (double) in_var; } \
+ RETURN_TYPE operator OP (char in_var) const { return value OP cString(&in_var, 1); } \
+ RETURN_TYPE operator OP (double in_var) const { return value.AsDouble() OP in_var; } \
+ RETURN_TYPE operator OP (const cString & in_var) const { return value OP in_var; }
+
+ CREATE_FLEX_VAR_STRING_MATH_OP(==, bool);
+ CREATE_FLEX_VAR_STRING_MATH_OP(!=, bool);
+ CREATE_FLEX_VAR_STRING_MATH_OP(<, bool);
+ CREATE_FLEX_VAR_STRING_MATH_OP(>, bool);
+ CREATE_FLEX_VAR_STRING_MATH_OP(<=, bool);
+ CREATE_FLEX_VAR_STRING_MATH_OP(>=, bool);
};
cFlexVar_Base * var;
public:
+ // Setup constructors to be able to build this variable from whatever input we need.
cFlexVar(const cFlexVar & in_var) : var(NULL) {
- const eFlexType type = in_var.GetType();
- if (type == TYPE_INT) var = new cFlexVar_Int( in_var.AsInt() );
- else if (type == TYPE_CHAR) var = new cFlexVar_Char( in_var.AsChar() );
- else if (type == TYPE_DOUBLE) var = new cFlexVar_Double( in_var.AsDouble() );
- else if (type == TYPE_STRING) var = new cFlexVar_String( in_var.AsString() );
+ if (in_var.GetType() == TYPE_INT) var = new cFlexVar_Int( in_var.AsInt() );
+ else if (in_var.GetType() == TYPE_CHAR) var = new cFlexVar_Char( in_var.AsChar() );
+ else if (in_var.GetType() == TYPE_DOUBLE) var = new cFlexVar_Double( in_var.AsDouble() );
+ else if (in_var.GetType() == TYPE_STRING) var = new cFlexVar_String( in_var.AsString() );
}
- cFlexVar(int in_value) : var(new cFlexVar_Int(in_value)) { ; }
+ cFlexVar(int in_value = 0) : var(new cFlexVar_Int(in_value)) { ; }
cFlexVar(char in_value) : var(new cFlexVar_Char(in_value)) { ; }
cFlexVar(double in_value) : var(new cFlexVar_Double(in_value)) { ; }
cFlexVar(const cString & in_value) : var(new cFlexVar_String(in_value)) { ; }
~cFlexVar() { delete var; }
-
+
+ // Setup accessors to get this variable as any type we might need.
int AsInt() const { return var->AsInt(); }
char AsChar() const { return var->AsChar(); }
double AsDouble() const { return var->AsDouble(); }
cString AsString() const { return var->AsString(); }
void SetString(cString & in_str) const { var->SetString(in_str); }
+ // Setup an accessor to determine the native type of this variable.
eFlexType GetType() const { return var->GetType(); }
+
+ // Setup assignment operators...
+ cFlexVar & operator=(const cFlexVar & in_var) {
+ delete var;
+ if (in_var.GetType() == TYPE_INT) var = new cFlexVar_Int( in_var.AsInt() );
+ else if (in_var.GetType() == TYPE_CHAR) var = new cFlexVar_Char( in_var.AsChar() );
+ else if (in_var.GetType() == TYPE_DOUBLE) var = new cFlexVar_Double( in_var.AsDouble() );
+ else if (in_var.GetType() == TYPE_STRING) var = new cFlexVar_String( in_var.AsString() );
+ return *this;
+ }
+ cFlexVar & operator=(int in_value) { delete var; var = new cFlexVar_Int(in_value); return *this; }
+ cFlexVar & operator=(char in_value) { delete var; var = new cFlexVar_Char(in_value); return *this; }
+ cFlexVar & operator=(double in_value) { delete var; var = new cFlexVar_Double(in_value); return *this; }
+ cFlexVar & operator=(const cString & in_value) { delete var; var = new cFlexVar_String(in_value); return *this; }
+ cFlexVar & operator=(char * in_value) { delete var; var = new cFlexVar_String(in_value); return *this; }
+
+ // The following macro will forward all of the commands with the associated operator to the internal class.
+#define FORWARD_FLEX_VAR_OP(OP, RETURN_TYPE) \
+ RETURN_TYPE operator OP(int in_var) const { return (*var) OP in_var; } \
+ RETURN_TYPE operator OP(char in_var) const { return (*var) OP in_var; } \
+ RETURN_TYPE operator OP(double in_var) const { return (*var) OP in_var; } \
+ RETURN_TYPE operator OP(const cString & in_var) const { return (*var) OP in_var; } \
+ RETURN_TYPE operator OP(const cFlexVar & in_var) const { \
+ const eFlexType type = in_var.GetType(); \
+ if (type == TYPE_INT) return (*var) OP in_var.AsInt(); \
+ else if (type == TYPE_CHAR) return (*var) OP in_var.AsChar(); \
+ else if (type == TYPE_DOUBLE) return (*var) OP in_var.AsDouble(); \
+ else /* if (type == TYPE_STRING) */ return (*var) OP in_var.AsString(); \
+ }
+
+ FORWARD_FLEX_VAR_OP(==, bool)
+ FORWARD_FLEX_VAR_OP(!=, bool)
+ FORWARD_FLEX_VAR_OP(<, bool)
+ FORWARD_FLEX_VAR_OP(>, bool)
+ FORWARD_FLEX_VAR_OP(<=, bool)
+ FORWARD_FLEX_VAR_OP(>=, bool)
+
};
+
#endif
Modified: development/source/tools/cString.h
===================================================================
--- development/source/tools/cString.h 2007-06-28 18:54:06 UTC (rev 1724)
+++ development/source/tools/cString.h 2007-06-28 21:38:42 UTC (rev 1725)
@@ -152,6 +152,12 @@
assert( in != NULL ); // NULL input string
assert( value != NULL ); // Memory Allocation Error: Out of Memory
}
+ cString(const char* in = "", int in_size) : value(new cStringData(in_size, in))
+ {
+ assert(in_size >= 0);
+ assert( in != NULL ); // NULL input string
+ assert( value != NULL ); // Memory Allocation Error: Out of Memory
+ }
explicit cString(const int size) : value(new cStringData(size))
{
assert( value != NULL ); // Memory Allocation Error: Out of Memory
More information about the Avida-cvs
mailing list