65 * know the version and are considered fully initialized.
66 */
67 class JDK_Version VALUE_OBJ_CLASS_SPEC {
68 friend class VMStructs;
69 friend class Universe;
70 friend void JDK_Version_init();
71 private:
72
73 static JDK_Version _current;
74 static const char* _runtime_name;
75 static const char* _runtime_version;
76
77 // In this class, we promote the minor version of release to be the
78 // major version for releases >= 5 in anticipation of the JDK doing the
79 // same thing. For example, we represent "1.5.0" as major version 5 (we
80 // drop the leading 1 and use 5 as the 'major').
81
82 uint8_t _major;
83 uint8_t _minor;
84 uint8_t _security;
85 uint8_t _update;
86 uint8_t _special;
87 uint8_t _build;
88
89 // If partially initialized, the above fields are invalid and we know
90 // that we're less than major version 6.
91 bool _partially_initialized;
92
93 bool _thread_park_blocker;
94 bool _post_vm_init_hook_enabled;
95
96 bool is_valid() const {
97 return (_major != 0 || _partially_initialized);
98 }
99
100 // initializes or partially initializes the _current static field
101 static void initialize();
102
103 // Completes initialization for a pre-JDK6 version.
104 static void fully_initialize(uint8_t major, uint8_t minor = 0,
105 uint8_t security = 0, uint8_t update = 0);
106
107 public:
108
109 // Returns true if the the current version has only been partially initialized
110 static bool is_partially_initialized() {
111 return _current._partially_initialized;
112 }
113
114 JDK_Version() : _major(0), _minor(0), _security(0), _update(0),
115 _special(0), _build(0), _partially_initialized(false),
116 _thread_park_blocker(false), _post_vm_init_hook_enabled(false)
117 {}
118
119 JDK_Version(uint8_t major, uint8_t minor = 0, uint8_t security = 0,
120 uint8_t update = 0, uint8_t special = 0, uint8_t build = 0,
121 bool thread_park_blocker = false, bool post_vm_init_hook_enabled = false) :
122 _major(major), _minor(minor), _security(security), _update(update),
123 _special(special), _build(build), _partially_initialized(false),
124 _thread_park_blocker(thread_park_blocker),
125 _post_vm_init_hook_enabled(post_vm_init_hook_enabled)
126 {}
127
128 // Returns the current running JDK version
129 static JDK_Version current() { return _current; }
130
131 // Factory methods for convenience
132 static JDK_Version jdk(uint8_t m) {
133 return JDK_Version(m);
134 }
135
136 static JDK_Version jdk_update(uint8_t major, uint8_t update_number) {
137 return JDK_Version(major, 0, 0, update_number);
138 }
139
140 uint8_t major_version() const { return _major; }
141 uint8_t minor_version() const { return _minor; }
142 uint8_t security_version() const { return _security; }
143 uint8_t update_version() const { return _update; }
144 uint8_t special_update_version() const { return _special; }
145 uint8_t build_number() const { return _build; }
146
147 bool supports_thread_park_blocker() const {
148 return _thread_park_blocker;
149 }
150 bool post_vm_init_hook_enabled() const {
151 return _post_vm_init_hook_enabled;
152 }
153
154 // Performs a full ordering comparison using all fields (update, build, etc.)
155 int compare(const JDK_Version& other) const;
156
157 /**
158 * Performs comparison using only the major version, returning negative
159 * if the major version of 'this' is less than the parameter, 0 if it is
160 * equal, and a positive value if it is greater.
161 */
162 int compare_major(int version) const {
163 if (_partially_initialized) {
164 if (version >= 6) {
165 return -1;
166 } else {
167 assert(false, "Can't make this comparison during init time");
168 return -1; // conservative
169 }
170 } else {
171 return major_version() - version;
172 }
173 }
174
|
65 * know the version and are considered fully initialized.
66 */
67 class JDK_Version VALUE_OBJ_CLASS_SPEC {
68 friend class VMStructs;
69 friend class Universe;
70 friend void JDK_Version_init();
71 private:
72
73 static JDK_Version _current;
74 static const char* _runtime_name;
75 static const char* _runtime_version;
76
77 // In this class, we promote the minor version of release to be the
78 // major version for releases >= 5 in anticipation of the JDK doing the
79 // same thing. For example, we represent "1.5.0" as major version 5 (we
80 // drop the leading 1 and use 5 as the 'major').
81
82 uint8_t _major;
83 uint8_t _minor;
84 uint8_t _security;
85 uint8_t _patch;
86 uint8_t _build;
87
88 // If partially initialized, the above fields are invalid and we know
89 // that we're less than major version 6.
90 bool _partially_initialized;
91
92 bool _thread_park_blocker;
93 bool _post_vm_init_hook_enabled;
94
95 bool is_valid() const {
96 return (_major != 0 || _partially_initialized);
97 }
98
99 // initializes or partially initializes the _current static field
100 static void initialize();
101
102 public:
103
104 // Returns true if the the current version has only been partially initialized
105 static bool is_partially_initialized() {
106 return _current._partially_initialized;
107 }
108
109 JDK_Version() : _major(0), _minor(0), _security(0), _patch(0), _build(0),
110 _partially_initialized(false),
111 _thread_park_blocker(false), _post_vm_init_hook_enabled(false)
112 {}
113
114 JDK_Version(uint8_t major, uint8_t minor = 0, uint8_t security = 0,
115 uint8_t patch = 0, uint8_t build = 0,
116 bool thread_park_blocker = false, bool post_vm_init_hook_enabled = false) :
117 _major(major), _minor(minor), _security(security), _patch(patch),
118 _build(build), _partially_initialized(false),
119 _thread_park_blocker(thread_park_blocker),
120 _post_vm_init_hook_enabled(post_vm_init_hook_enabled)
121 {}
122
123 // Returns the current running JDK version
124 static JDK_Version current() { return _current; }
125
126 // Factory methods for convenience
127 static JDK_Version jdk(uint8_t m) {
128 return JDK_Version(m);
129 }
130
131 uint8_t major_version() const { return _major; }
132 uint8_t minor_version() const { return _minor; }
133 uint8_t security_version() const { return _security; }
134 uint8_t patch_version() const { return _patch; }
135 uint8_t build_number() const { return _build; }
136
137 bool supports_thread_park_blocker() const {
138 return _thread_park_blocker;
139 }
140 bool post_vm_init_hook_enabled() const {
141 return _post_vm_init_hook_enabled;
142 }
143
144 // Performs a full ordering comparison using all fields (patch, build, etc.)
145 int compare(const JDK_Version& other) const;
146
147 /**
148 * Performs comparison using only the major version, returning negative
149 * if the major version of 'this' is less than the parameter, 0 if it is
150 * equal, and a positive value if it is greater.
151 */
152 int compare_major(int version) const {
153 if (_partially_initialized) {
154 if (version >= 6) {
155 return -1;
156 } else {
157 assert(false, "Can't make this comparison during init time");
158 return -1; // conservative
159 }
160 } else {
161 return major_version() - version;
162 }
163 }
164
|