1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
// This file is part of Golly.
// See docs/License.html for the copyright notice.
/**
* Basic utility classes for things like fatal errors.
*/
#ifndef UTIL_H
#define UTIL_H
#include <cstdio> // for FILE *
void lifefatal(const char *s) ;
void lifewarning(const char *s) ;
void lifestatus(const char *s) ;
void lifebeginprogress(const char *dlgtitle) ;
bool lifeabortprogress(double fracdone, const char *newmsg) ;
void lifeendprogress() ;
const char *lifegetuserrules() ;
const char *lifegetrulesdir() ;
bool isaborted() ;
FILE *getdebugfile() ;
/**
* Sick of line ending woes. This class takes care of this for us.
*/
class linereader {
public:
linereader(FILE *f) ;
char *fgets(char *buf, int maxlen) ;
void setfile(FILE *f) ;
void setcloseonfree() ;
int close() ;
~linereader() ;
private:
int lastchar ;
int closeonfree ;
FILE *fp ;
} ;
/**
* To substitute your own routines, use the following class.
*/
class lifeerrors {
public:
virtual void fatal(const char *s) = 0 ;
virtual void warning(const char *s) = 0 ;
virtual void status(const char *s) = 0 ;
virtual void beginprogress(const char *dlgtitle) = 0 ;
virtual bool abortprogress(double fracdone, const char *newmsg) = 0 ;
virtual void endprogress() = 0 ;
virtual const char *getuserrules() = 0 ;
virtual const char *getrulesdir() = 0 ;
static void seterrorhandler(lifeerrors *obj) ;
bool aborted ;
} ;
/**
* If a fast popcount routine is available, this macro indicates its
* availability. The popcount should be a 32-bit popcount. The
* __builtin_popcount by gcc and clang works fine on any platform.
* The __popcount intrinsic on Visual Studio does *not* without a
* CPUID check, so we don't do fast popcounts yet on Windows.
*/
#ifdef __GNUC__
#define FASTPOPCOUNT __builtin_popcount
#endif
#ifdef __clang__
#define FASTPOPCOUNT __builtin_popcount
#endif
/**
* A routine to get the number of seconds elapsed since an arbitrary
* point, as a double.
*/
double gollySecondCount() ;
/*
* Performance data. We keep running values here. We can copy this
* to "mark" variables, and then report performance for deltas.
*/
struct hperf {
void clear() {
fastNodeInc = 0 ;
nodesCalculated = 0 ;
depthSum = 0 ;
timeStamp = gollySecondCount() ;
genval = 0 ;
frames = 0 ;
halfNodes = 0 ;
}
void report(hperf&, int verbose) ;
void reportStep(hperf&, hperf&, double genval, int verbose) ;
int fastinc(int depth, int half) {
depthSum += depth ;
if (half)
halfNodes++ ;
if ((++fastNodeInc & reportMask) == 0)
return 1 ;
else
return 0 ;
}
double getReportInterval() {
return reportInterval ;
}
void setReportInterval(double v) {
reportInterval = v ;
}
int fastNodeInc ;
double frames ;
double nodesCalculated ;
double halfNodes ;
double depthSum ;
double timeStamp ;
double genval ;
static int reportMask ;
static double reportInterval ;
} ;
#endif
|
