mirror of
https://github.com/openjdk/jdk.git
synced 2025-09-20 19:14:38 +02:00
8137167: JEP165: Compiler Control: Implementation task
Compiler Control JEP Reviewed-by: roland, twisti, zmajo, simonis
This commit is contained in:
Nils Eliasson
parent
857b7eb968
commit
5a5faf94bf
66 changed files with 3965 additions and 307 deletions
956
hotspot/src/share/vm/utilities/json.cpp
Normal file
956
hotspot/src/share/vm/utilities/json.cpp
Normal file
|
|
@ -0,0 +1,956 @@
|
|||
/*
|
||||
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* This is not really json in the state it is now.
|
||||
* Some differences:
|
||||
* - Double quotes around the key in an object is not enforced.
|
||||
* i.e you can write: { foo : "bar" } instead of { "foo" : "bar" }.
|
||||
* - Comments are allowed.
|
||||
* - The last element in an object or array can have an ending comma.
|
||||
*/
|
||||
|
||||
#include "precompiled.hpp"
|
||||
#include "utilities/json.hpp"
|
||||
#include "utilities/ostream.hpp"
|
||||
#include <math.h>
|
||||
|
||||
const char* strchrnul_(const char *s, int c) {
|
||||
const char* tmp = strchr(s, c);
|
||||
return tmp == NULL ? s + strlen(s) : tmp;
|
||||
}
|
||||
|
||||
JSON::JSON(const char* text, bool silent, outputStream* st)
|
||||
: start(text), pos(text), mark(text),
|
||||
level(0), line(1), column(0), silent(silent), _valid(true), _st(st)
|
||||
{
|
||||
}
|
||||
|
||||
void JSON::parse() {
|
||||
assert(start != NULL, "Need something to parse");
|
||||
if (start == NULL) {
|
||||
_valid = false;
|
||||
error(INTERNAL_ERROR, "JSON parser was called with a string that was NULL.");
|
||||
} else {
|
||||
_valid = parse_json_value();
|
||||
}
|
||||
}
|
||||
|
||||
bool JSON::valid() {
|
||||
return _valid;
|
||||
}
|
||||
|
||||
bool JSON::parse_json_value() {
|
||||
int c;
|
||||
|
||||
c = skip_to_token();
|
||||
if (c == -1) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Must start with object or array
|
||||
if (level == 0) {
|
||||
|
||||
switch (c) {
|
||||
case '{':
|
||||
if (parse_json_object() == false) {
|
||||
return false;
|
||||
}
|
||||
c = skip_to_token();
|
||||
if (c > 0) {
|
||||
mark_pos();
|
||||
error(SYNTAX_ERROR, "Only one top level object/array is allowed.");
|
||||
return false;
|
||||
} else if (c < 0) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
|
||||
case '[':
|
||||
if (parse_json_array() == false) {
|
||||
return false;
|
||||
}
|
||||
c = skip_to_token();
|
||||
if (c > 0) {
|
||||
mark_pos();
|
||||
error(SYNTAX_ERROR, "Only one top level object/array is allowed.");
|
||||
return false;
|
||||
} else if (c < 0) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
|
||||
case 0:
|
||||
error(SYNTAX_ERROR, "EOS was encountered before any json declarations");
|
||||
return false;
|
||||
|
||||
default:
|
||||
error(SYNTAX_ERROR, "Json must start with an object or an array.");
|
||||
return false;
|
||||
}
|
||||
} else { // level > 0
|
||||
switch (c) {
|
||||
case '{':
|
||||
return parse_json_object();
|
||||
|
||||
case '[':
|
||||
return parse_json_array();
|
||||
|
||||
case '"':
|
||||
return parse_json_string();
|
||||
|
||||
case '-': case '0':
|
||||
case '1': case '2': case '3':
|
||||
case '4': case '5': case '6':
|
||||
case '7': case '8': case '9':
|
||||
return parse_json_number();
|
||||
|
||||
case 't':
|
||||
return parse_json_symbol("true", JSON_TRUE);
|
||||
|
||||
case 'f':
|
||||
return parse_json_symbol("false", JSON_FALSE);
|
||||
|
||||
case 'n':
|
||||
return parse_json_symbol("null", JSON_NULL);
|
||||
|
||||
case 0:
|
||||
error(SYNTAX_ERROR, "EOS was encountered when expecting a json value.");
|
||||
return false;
|
||||
|
||||
default:
|
||||
error(SYNTAX_ERROR, "Could not parse as a json value (did you forget to quote your strings?).");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Should only be called when we actually have the start of an object
|
||||
// Otherwise it is an internal error
|
||||
bool JSON::parse_json_object() {
|
||||
NOT_PRODUCT(const char* prev_pos);
|
||||
int c;
|
||||
|
||||
mark_pos();
|
||||
// Check that we are not called in error
|
||||
if (expect_any("{", "object start", INTERNAL_ERROR) <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!callback(JSON_OBJECT_BEGIN, NULL, level++)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
mark_pos();
|
||||
c = skip_to_token();
|
||||
if (c == 0) {
|
||||
error(SYNTAX_ERROR, "EOS when expecting an object key or object end");
|
||||
return false;
|
||||
} else if (c < 0) {
|
||||
return false;
|
||||
} else if (c == '}') {
|
||||
// We got here from either empty object "{}" or ending comma "{a:1,}"
|
||||
next();
|
||||
break;
|
||||
}
|
||||
|
||||
NOT_PRODUCT(prev_pos = pos);
|
||||
if (parse_json_key() == false) {
|
||||
return false;
|
||||
}
|
||||
assert(pos > prev_pos, "parsing stalled");
|
||||
|
||||
skip_to_token();
|
||||
mark_pos();
|
||||
if (expect_any(":", "object key-value separator") <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
skip_to_token();
|
||||
mark_pos();
|
||||
NOT_PRODUCT(prev_pos = pos);
|
||||
if (parse_json_value() == false) {
|
||||
return false;
|
||||
}
|
||||
assert(pos > prev_pos, "parsing stalled");
|
||||
|
||||
c = skip_to_token();
|
||||
mark_pos();
|
||||
if (expect_any(",}", "value separator or object end") <= 0) {
|
||||
return false;
|
||||
}
|
||||
if (c == '}') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
assert(c == '}', "array parsing ended without object end token ('}')");
|
||||
return callback(JSON_OBJECT_END, NULL, --level);
|
||||
}
|
||||
|
||||
// Should only be called when we actually have the start of an array
|
||||
// Otherwise it is an internal error
|
||||
bool JSON::parse_json_array() {
|
||||
NOT_PRODUCT(const char* prev_pos);
|
||||
int c;
|
||||
|
||||
mark_pos();
|
||||
// Check that we are not called in error
|
||||
if (expect_any("[", "array start character", INTERNAL_ERROR) <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!callback(JSON_ARRAY_BEGIN, NULL, level++)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
mark_pos();
|
||||
c = skip_to_token();
|
||||
if (c == 0) {
|
||||
error(SYNTAX_ERROR, "EOS when expecting a json value or array end");
|
||||
return false;
|
||||
} else if (c < 0) {
|
||||
return false;
|
||||
} else if (c == ']') {
|
||||
// We got here from either empty array "[]" or ending comma "[1,]"
|
||||
next();
|
||||
break;
|
||||
}
|
||||
|
||||
mark_pos();
|
||||
NOT_PRODUCT(prev_pos = pos);
|
||||
if (parse_json_value() == false) {
|
||||
return false;
|
||||
}
|
||||
assert(pos > prev_pos, "parsing stalled");
|
||||
|
||||
c = skip_to_token();
|
||||
mark_pos();
|
||||
if (expect_any(",]", "value separator or array end") <= 0) {
|
||||
return false;
|
||||
}
|
||||
if (c == ']') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
assert(c == ']', "array parsing ended without array end token (']')");
|
||||
return callback(JSON_ARRAY_END, NULL, --level);
|
||||
}
|
||||
|
||||
bool JSON::parse_json_string(bool key) {
|
||||
const char* end;
|
||||
JSON_VAL v;
|
||||
|
||||
mark_pos();
|
||||
if (expect_any("\"", "string start character", INTERNAL_ERROR) <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
end = strchr(pos, '"'); // TODO: escapes
|
||||
if (end == NULL) {
|
||||
error(SYNTAX_ERROR, "String started here never ended. Expected \'\"\' before EOS.");
|
||||
return false;
|
||||
}
|
||||
|
||||
v.str.start = pos;
|
||||
v.str.length = end - pos;
|
||||
skip(end - pos);
|
||||
|
||||
if (expect_any("\"", "string end character", INTERNAL_ERROR) <= 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (key == true) {
|
||||
return callback(JSON_KEY, &v, level);
|
||||
} else {
|
||||
return callback(JSON_STRING, &v, level);
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: hotspot equivalents?
|
||||
static bool is_alpha(u_char c) {
|
||||
return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
|
||||
}
|
||||
static bool is_numeric(u_char c) {
|
||||
return (c >= '0' && c <= '9');
|
||||
}
|
||||
static bool is_alnum(u_char c) {
|
||||
return is_alpha(c) || is_numeric(c);
|
||||
}
|
||||
static bool is_word(u_char c) {
|
||||
return c == '_' || is_alnum(c);
|
||||
}
|
||||
|
||||
// Allow object keys to be without quotation,
|
||||
// but then restrict to ([a-zA-Z0-9_])+
|
||||
bool JSON::parse_json_key() {
|
||||
const char* begin;
|
||||
JSON_VAL v;
|
||||
u_char c;
|
||||
|
||||
mark_pos();
|
||||
c = peek();
|
||||
if (c == '"') {
|
||||
return parse_json_string(true);
|
||||
}
|
||||
|
||||
begin = pos;
|
||||
c = peek();
|
||||
if (c == 0) {
|
||||
error(SYNTAX_ERROR, "Got EOS when expecting an object key.");
|
||||
return false;
|
||||
} else if (is_word(c) == false) {
|
||||
error(SYNTAX_ERROR, "Expected an object key, which can be a double-quoted (\") string or a simple string (only alphanumeric characters and underscore, separated by whitespace) that doesn't need to be quoted.");
|
||||
return false;
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
c = peek();
|
||||
// Allow the key to be delimited by control characters and the object key-value separator ':'
|
||||
if (c <= ' ' || c == ':') {
|
||||
break;
|
||||
} else if (is_word(c) == false) {
|
||||
error(SYNTAX_ERROR, "Object key need to be quoted, or consist entirely of alphanumeric characters and underscores.");
|
||||
return false;
|
||||
}
|
||||
next();
|
||||
}
|
||||
|
||||
v.str.start = begin;
|
||||
v.str.length = pos - begin;
|
||||
return callback(JSON_KEY, &v, level);
|
||||
}
|
||||
|
||||
bool JSON::parse_json_number() {
|
||||
double double_value;
|
||||
int tokens, read;
|
||||
JSON_VAL v;
|
||||
|
||||
mark_pos();
|
||||
|
||||
// Parsing number - for simplicity ints are limited to 2**53
|
||||
// sscanf as a double and check if part is 0.
|
||||
tokens = sscanf(pos, "%lf%n", &double_value, &read);
|
||||
assert(tokens <= 1, "scanf implementation that counts as a token, parsing json numbers will always fail");
|
||||
if (tokens == 1) {
|
||||
assert(read > 0, "sanity");
|
||||
|
||||
if (floor(double_value) == double_value) {
|
||||
// No exponent - treat as an int
|
||||
v.int_value = (int)double_value;
|
||||
if (!callback(JSON_NUMBER_INT, &v, level)) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
v.double_value = double_value;
|
||||
if (!callback(JSON_NUMBER_FLOAT, &v, level)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
skip(read);
|
||||
return true;
|
||||
}
|
||||
|
||||
error(SYNTAX_ERROR, "Couldn't parse json number (note that exponents are not supported).");
|
||||
return false;
|
||||
}
|
||||
|
||||
bool JSON::parse_json_symbol(const char* name, JSON_TYPE symbol) {
|
||||
if (expect_string(name, "maybe you forgot to quote your strings?") == false) {
|
||||
mark_pos();
|
||||
return false;
|
||||
}
|
||||
return callback(symbol, NULL, level);
|
||||
}
|
||||
|
||||
void JSON::mark_pos() {
|
||||
assert((mark == start || *(mark - 1)) != 0, "buffer overrun");
|
||||
assert(mark <= pos, "mark runahead");
|
||||
|
||||
u_char c;
|
||||
|
||||
while (mark < pos) {
|
||||
c = *mark;
|
||||
assert(c != 0, "pos buffer overrun?");
|
||||
if (c != 0) {
|
||||
mark++;
|
||||
column++;
|
||||
}
|
||||
if (c == '\n') {
|
||||
line++;
|
||||
column = 0;
|
||||
}
|
||||
}
|
||||
|
||||
assert(mark <= pos, "mark runahead");
|
||||
}
|
||||
|
||||
u_char JSON::next() {
|
||||
assert((pos == start || *(pos - 1)) != 0, "buffer overrun");
|
||||
|
||||
u_char c = *pos;
|
||||
if (c != 0) {
|
||||
pos++;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
u_char JSON::peek() {
|
||||
return *pos;
|
||||
}
|
||||
|
||||
// Peek ahead i chars (0 is same as peek())
|
||||
u_char JSON::peek(size_t i) {
|
||||
u_char c;
|
||||
const char* p;
|
||||
|
||||
p = pos;
|
||||
c = *p;
|
||||
while (i > 0 && c != 0) {
|
||||
i--;
|
||||
p++;
|
||||
c = *p;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check that one of the expected characters is next in the stream.
|
||||
* If not, it is an error.
|
||||
* Returns 0 if EOS is encountered.
|
||||
* Returns -1 if the next character was not one of the expected.
|
||||
* Otherwise consumes and returns the expected character that was encountered.
|
||||
*/
|
||||
int JSON::expect_any(const char* valid_chars, const char* error_msg, JSON_ERROR e) {
|
||||
size_t len;
|
||||
u_char c;
|
||||
|
||||
len = strlen(valid_chars);
|
||||
assert(len > 0, "need non-empty string");
|
||||
|
||||
c = peek();
|
||||
if (c == 0) {
|
||||
error(e, "Got EOS when expecting %s (%s\'%s\').", error_msg, len > 1 ? "one of " : "", valid_chars);
|
||||
return 0;
|
||||
}
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
if (c == valid_chars[i]) {
|
||||
return next();
|
||||
}
|
||||
}
|
||||
error(e, "Expected %s (%s\'%s\').", error_msg, len > 1 ? "one of " : "", valid_chars);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check that the expected string is next in the stream.
|
||||
* If not, it is an error.
|
||||
* Consumes the expected characters if they are present.
|
||||
* Returns true if the expected characters were present, otherwise false.
|
||||
*/
|
||||
bool JSON::expect_string(const char* expected_string, const char* error_msg, JSON_ERROR e) {
|
||||
u_char c, expected_char;
|
||||
size_t len;
|
||||
|
||||
assert(expected_string != NULL, "need non-null string");
|
||||
len = strlen(expected_string);
|
||||
assert(len > 0, "need non-empty string");
|
||||
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
expected_char = expected_string[i];
|
||||
assert(expected_char > ' ', "not sane for control characters");
|
||||
if (expected_char <= ' ') {
|
||||
error(INTERNAL_ERROR, "expect got a control char");
|
||||
}
|
||||
c = pos[i];
|
||||
if (c == 0) {
|
||||
error(e, "EOS encountered when expecting %s (\"%s\")", error_msg, expected_string);
|
||||
return false;
|
||||
} else if (c != expected_char) {
|
||||
error(e, "Expected \"%s\" (%s)", expected_string, error_msg);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
skip(len);
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Skip i characters.
|
||||
* Returns number of characters skipped.
|
||||
*/
|
||||
size_t JSON::skip(size_t i) {
|
||||
u_char c;
|
||||
size_t j;
|
||||
|
||||
c = peek();
|
||||
for (j = i; c != 0 && j > 0; j--) {
|
||||
c = next();
|
||||
}
|
||||
return i - j;
|
||||
}
|
||||
|
||||
/*
|
||||
* Skip whitespace and comments.
|
||||
* Returns the first token after whitespace/comments without consuming it
|
||||
* Returns 0 if EOS is encountered.
|
||||
* Returns -1 if there is an error
|
||||
*/
|
||||
int JSON::skip_to_token() {
|
||||
for (;;) {
|
||||
int c = peek(0);
|
||||
if (c == '/') {
|
||||
u_char c2 = peek(1);
|
||||
if (c2 == '/') {
|
||||
c = skip_line_comment();
|
||||
} else if (c2 == '*') {
|
||||
c = skip_block_comment();
|
||||
if (c < 0) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
// Fall through to keep checking if there
|
||||
// are more whitespace / comments to skip
|
||||
}
|
||||
if (c == 0 || c > ' ') {
|
||||
return c;
|
||||
}
|
||||
next();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Skip to, and return the wanted char without consuming it
|
||||
* Returns 0 if EOS is encountered.
|
||||
*/
|
||||
u_char JSON::skip_to(u_char want) {
|
||||
// We want the bookkeeping done in next().
|
||||
// Otherwise strchr could have been used.
|
||||
u_char c;
|
||||
for(;;) {
|
||||
c = peek();
|
||||
if (c == 0 || c == want) {
|
||||
return c;
|
||||
}
|
||||
next();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Should only be called when we actually have a line comment to skip.
|
||||
* Otherwise it is an internal error.
|
||||
*
|
||||
* Will return the first token after the line comment without consuming it.
|
||||
* Returns 0 if EOS is encoutered.
|
||||
*/
|
||||
u_char JSON::skip_line_comment() {
|
||||
u_char c;
|
||||
|
||||
// Check that we are not called in error
|
||||
expect_any("/", "line comment start", INTERNAL_ERROR);
|
||||
expect_any("/", "line comment start", INTERNAL_ERROR);
|
||||
|
||||
c = skip_to('\n');
|
||||
if (c == 0) {
|
||||
return 0;
|
||||
}
|
||||
next();
|
||||
return next();
|
||||
}
|
||||
|
||||
/*
|
||||
* Should only be called when we actually have a block comment to skip.
|
||||
* Otherwise it is an internal error.
|
||||
*
|
||||
* Returns the first token after the block comment without consuming it.
|
||||
* Returns -1 if EOS is encountered in the middle of a comment.
|
||||
*/
|
||||
int JSON::skip_block_comment() {
|
||||
const char* current;
|
||||
|
||||
// Check that we are not called in error.
|
||||
if (peek() != '/' || peek(1) != '*') {
|
||||
// Let expect handle EOS.
|
||||
expect_string("/*", "block comment start", INTERNAL_ERROR);
|
||||
return 0;
|
||||
}
|
||||
|
||||
current = pos;
|
||||
for (;;) {
|
||||
current = strchrnul_(current, '*');
|
||||
|
||||
if (current[0] == 0 || current[1] == 0) {
|
||||
// Advance error marker to start of block comment
|
||||
mark_pos();
|
||||
error(SYNTAX_ERROR, "Block comment started here never ended. Expected \"*/\" before EOS.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (current[1] == '/') {
|
||||
pos = current;
|
||||
if (expect_string("*/", "block comment end", INTERNAL_ERROR) == false) {
|
||||
return -1;
|
||||
}
|
||||
// Found block comment end
|
||||
return peek();
|
||||
}
|
||||
current++;
|
||||
}
|
||||
}
|
||||
|
||||
const char* JSON::strerror(JSON_ERROR e) {
|
||||
switch (e) {
|
||||
case SYNTAX_ERROR:
|
||||
return "Syntax error";
|
||||
case INTERNAL_ERROR:
|
||||
return "Internal error";
|
||||
case KEY_ERROR:
|
||||
return "Key error";
|
||||
case VALUE_ERROR:
|
||||
return "Value error";
|
||||
default:
|
||||
ShouldNotReachHere();
|
||||
return "Unknown error";
|
||||
}
|
||||
}
|
||||
|
||||
void JSON::error(JSON_ERROR e, const char* format, ...) {
|
||||
_valid = false;
|
||||
|
||||
if (!silent) {
|
||||
const char* line_start;
|
||||
const char* tmp;
|
||||
size_t line_length;
|
||||
va_list args;
|
||||
u_char c;
|
||||
|
||||
_st->print("%s on line %u byte %u: ", JSON::strerror(e), line, column + 1);
|
||||
va_start(args, format);
|
||||
_st->vprint(format, args);
|
||||
_st->cr();
|
||||
va_end(args);
|
||||
|
||||
line_start = mark - column;
|
||||
assert(line_start >= start, "out of bounds");
|
||||
assert(line_start <= mark, "out of bounds");
|
||||
assert(line_start == start || line_start[-1] == '\n', "line counting error");
|
||||
|
||||
c = *pos;
|
||||
if (c == 0) {
|
||||
_st->print(" Got ");
|
||||
_st->print_cr("EOS.");
|
||||
}
|
||||
tmp = mark;
|
||||
c = *tmp;
|
||||
if (c > ' ') {
|
||||
_st->print(" At ");
|
||||
_st->print("'");
|
||||
while (c > ' ') {
|
||||
_st->print("%c", c);
|
||||
tmp++;
|
||||
c = *tmp;
|
||||
}
|
||||
_st->print_cr("'.");
|
||||
}
|
||||
|
||||
// Skip to newline or EOS
|
||||
tmp = strchrnul_(mark, '\n');
|
||||
line_length = tmp - line_start;
|
||||
|
||||
_st->print_cr("%s", line_start);
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef PRODUCT
|
||||
void JSONTest::test(const char* text, bool should_pass) {
|
||||
JSONTest json(text);
|
||||
if (should_pass) {
|
||||
assert(json.valid() == true, "failed on a valid json string");
|
||||
if (VerboseInternalVMTests) {
|
||||
tty->print_cr("-- json test passed as expected --");
|
||||
}
|
||||
} else {
|
||||
assert(json.valid() == false, "succeeded on an invalid json string");
|
||||
if (VerboseInternalVMTests) {
|
||||
tty->print_cr("-- json test failed as expected --");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
JSONTest::JSONTest(const char* text) : JSON(text, !VerboseInternalVMTests, tty) {
|
||||
prev = JSON_NONE;
|
||||
parse();
|
||||
}
|
||||
|
||||
bool JSONTest::test() {
|
||||
JSONTest::test("{}", true);
|
||||
JSONTest::test("[]", true);
|
||||
JSONTest::test(" { } ", true);
|
||||
JSONTest::test(" [ ] ", true);
|
||||
|
||||
JSONTest::test("\"error\"", false);
|
||||
JSONTest::test("error", false);
|
||||
JSONTest::test("1", false);
|
||||
JSONTest::test("1.2", false);
|
||||
JSONTest::test("true", false);
|
||||
JSONTest::test("false", false);
|
||||
JSONTest::test("null", false);
|
||||
|
||||
JSONTest::test("[ 1 ]", true);
|
||||
JSONTest::test("[ 1, ]", true);
|
||||
JSONTest::test("[ true ]", true);
|
||||
JSONTest::test("[ true, ]", true);
|
||||
JSONTest::test("[ false ]", true);
|
||||
JSONTest::test("[ false, ]", true);
|
||||
JSONTest::test("[ null ]", true);
|
||||
JSONTest::test("[ null, ]", true);
|
||||
JSONTest::test("[ \"\" ]", true);
|
||||
JSONTest::test("[ \"\", ]", true);
|
||||
JSONTest::test("[ \"elem1\" ]", true);
|
||||
JSONTest::test("[ \"elem1\", ]", true);
|
||||
JSONTest::test("[ \"elem1\", ]", true);
|
||||
JSONTest::test("[ \"elem1\" ]", true);
|
||||
JSONTest::test("[ \"elem1\", \"elem2\" ]", true);
|
||||
JSONTest::test("[ \"elem1\", \"elem2\", ]", true);
|
||||
|
||||
|
||||
JSONTest::test("[ \"elem1\" ] { }", false);
|
||||
JSONTest::test("[ elem1, \"elem2\" ]", false);
|
||||
JSONTest::test("[ \"elem1\"", false);
|
||||
JSONTest::test("[ \"elem1 ]", false);
|
||||
JSONTest::test("[ \"elem1\", \"elem2\"", false);
|
||||
JSONTest::test("[ truefoo ]", false);
|
||||
JSONTest::test("[ falsefoo ]", false);
|
||||
JSONTest::test("[ nullfoo ]", false);
|
||||
|
||||
JSONTest::test("{ key : 1 }", true);
|
||||
JSONTest::test("{ key : 1, }", true);
|
||||
JSONTest::test("{ key : 1.2 }", true);
|
||||
JSONTest::test("{ key : true }", true);
|
||||
JSONTest::test("{ key : true, }", true);
|
||||
JSONTest::test("{ key : false }", true);
|
||||
JSONTest::test("{ key : false, }", true);
|
||||
JSONTest::test("{ key : null }", true);
|
||||
JSONTest::test("{ key : null, }", true);
|
||||
JSONTest::test("{ \"\" : \"\" }", true);
|
||||
JSONTest::test("{ \"\" : \"\", }", true);
|
||||
JSONTest::test("{ \"key1\" : \"val1\" }", true);
|
||||
JSONTest::test("{ \"key1\" : \"val1\", }", true);
|
||||
JSONTest::test("{ \"key1\" : \"val1\", \"key2\" : \"val2\" }", true);
|
||||
JSONTest::test("{ \"key1\" : \"val1\", \"key2\" : \"val2\", }", true);
|
||||
|
||||
JSONTest::test("{ \"key\" : \"val\" } [ \"error\" ]", false);
|
||||
JSONTest::test("{ \"key\" : \"val\" ", false);
|
||||
|
||||
JSONTest::test("/**/ { }", true);
|
||||
JSONTest::test("/* */ { }", true);
|
||||
JSONTest::test("/*foo*/ { }", true);
|
||||
JSONTest::test("/* *foo */ { }", true);
|
||||
JSONTest::test("/* *foo* */ { }", true);
|
||||
JSONTest::test("/* /*foo */ { }", true);
|
||||
JSONTest::test("{ } /* foo */", true);
|
||||
JSONTest::test("{ } /* foo */ ", true);
|
||||
JSONTest::test("{ } //", true);
|
||||
JSONTest::test("{ } // ", true);
|
||||
JSONTest::test("{ } // foo", true);
|
||||
|
||||
JSONTest::test("/* * / { }", false);
|
||||
JSONTest::test("/ * */ { }", false);
|
||||
JSONTest::test("// { }", false);
|
||||
JSONTest::test("/* { } */", false);
|
||||
JSONTest::test("/* { } */ ", false);
|
||||
JSONTest::test("/* { } ", false);
|
||||
JSONTest::test("{ } /* ", false);
|
||||
JSONTest::test("/* { } *", false);
|
||||
JSONTest::test("{ /* } */", false);
|
||||
JSONTest::test("[ /* ] */", false);
|
||||
JSONTest::test("{ key : \"val\", /* } */", false);
|
||||
JSONTest::test("[ \"val\", /* ] */", false);
|
||||
|
||||
JSONTest::test("/* comment */{ key1 : { \"key2\" : { \"key3\" : [ \"elem1\", \"elem2\", { \"key4\" : null }, 3 , 2 , 1 , 0 , -1 , -2 , -3 , true, false, null, ] }, \"key5\" : true }, \"key6\" : [ \"☃\" ], key7 : \"val\",}", true);
|
||||
JSONTest::test("/* comment */ { \"key1\" : { \"key2\" : { \"key3\" : [ \"elem1\", \"elem2\", { \"key4\" : null }, 3 , 2 , 1 , 0 , -1 , -2 , -3 , true, false, null, ] }, \"key5\" : true }, \"key6\" : [ \"☃\" ], key7 : \"val\",}", true);
|
||||
JSONTest::test("/*comment*/{\"ff1 fsd\":{\"☃\":{\"☃\":[\"☃\",\"☃\"]},\"☃\":true},\"☃\":[\"☃\"],\"foo\":\"☃\",}", true);
|
||||
JSONTest::test("/* comment */ { key1 error : { \"☃\" : { \"☃\" : [ \"☃\", \"☃\" ] }, \"☃\" : true }, \"baz\" : [ \"☃\" ], foo : \"☃\",}", false); // first key needs to be quoted since it contains a space
|
||||
|
||||
|
||||
JSONTest::test("[\n]", true);
|
||||
|
||||
JSONTest::test(
|
||||
"[" "\n"
|
||||
" {"
|
||||
" // pattern to match against class+method+signature" "\n"
|
||||
" // leading and trailing wildcard (*) allowed" "\n"
|
||||
" match: \"foo.bar.*\"," "\n"
|
||||
" " "\n"
|
||||
" // override defaults for specified compiler" "\n"
|
||||
" // we may differentiate between levels too. TBD." "\n"
|
||||
" c1: {" "\n"
|
||||
" //override c1 presets " "\n"
|
||||
" array_bounds_check_removal: false" "\n"
|
||||
" }," "\n"
|
||||
"" "\n"
|
||||
" c2: {" "\n"
|
||||
" // control inlining of method" "\n"
|
||||
" // + force inline, - dont inline" "\n"
|
||||
" inline : [ \"+java.util.*\", \"-com.sun.*\"]," "\n"
|
||||
" }," "\n"
|
||||
"" "\n"
|
||||
" // directives outside a specific preset applies to all compilers" "\n"
|
||||
" inline : [ \"+java.util.*\", \"-com.sun.*\"]," "\n"
|
||||
" print_assembly: true," "\n"
|
||||
" verify_oopmaps: true," "\n"
|
||||
" max_loop_unrolling: 5" "\n"
|
||||
" }," "\n"
|
||||
" {" "\n"
|
||||
" // matching several patterns require an array" "\n"
|
||||
" match: [\"baz.*\",\"frob*\"]," "\n"
|
||||
"" "\n"
|
||||
" // only enable c1 for this directive" "\n"
|
||||
" // all enabled by default. Command disables all not listed" "\n"
|
||||
" enable: \"c1\"," "\n"
|
||||
"" "\n"
|
||||
" // applies to all compilers" "\n"
|
||||
" // + force inline, - dont inline" "\n"
|
||||
" inline : [ \"+java.util.*\", \"-com.sun.*\"]," "\n"
|
||||
" print_inlining: true," "\n"
|
||||
"" "\n"
|
||||
" // force matching compiles to be blocking/syncronous" "\n"
|
||||
" blocking_compile: true" "\n"
|
||||
" }," "\n"
|
||||
"]" "\n", true);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void JSONTest::log(uint indent, const char* format, ...) {
|
||||
if (VerboseInternalVMTests) {
|
||||
if (prev != JSON_KEY) {
|
||||
for (uint i = 0; i < indent; i++) {
|
||||
_st->print(" ");
|
||||
}
|
||||
}
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
_st->vprint(format, args);
|
||||
va_end(args);
|
||||
}
|
||||
}
|
||||
|
||||
bool JSONTest::callback(JSON_TYPE t, JSON_VAL* v, uint rlevel) {
|
||||
switch (t) {
|
||||
case JSON_OBJECT_BEGIN:
|
||||
log(rlevel, "{\n");
|
||||
prev = JSON_NONE; // Only care about JSON_KEY, to indent correctly
|
||||
return true;
|
||||
|
||||
case JSON_OBJECT_END:
|
||||
log(rlevel, "},\n");
|
||||
prev = JSON_NONE;
|
||||
return true;
|
||||
|
||||
case JSON_ARRAY_BEGIN:
|
||||
log(rlevel, "[\n");
|
||||
prev = JSON_NONE;
|
||||
return true;
|
||||
|
||||
case JSON_ARRAY_END:
|
||||
log(rlevel, "],\n");
|
||||
prev = JSON_NONE;
|
||||
return true;
|
||||
|
||||
case JSON_KEY:
|
||||
if (VerboseInternalVMTests) {
|
||||
for (uint i = 0; i < rlevel; i++) {
|
||||
_st->print(" ");
|
||||
}
|
||||
_st->print("<key>");
|
||||
for (size_t i = 0; i < v->str.length; i++) {
|
||||
u_char c = v->str.start[i];
|
||||
assert(c != 0, "string overrun");
|
||||
if (c == 0) {
|
||||
return false;
|
||||
}
|
||||
_st->print("%c", c);
|
||||
}
|
||||
_st->print(" : ");
|
||||
}
|
||||
prev = JSON_KEY;
|
||||
return true;
|
||||
|
||||
case JSON_STRING:
|
||||
if (VerboseInternalVMTests) {
|
||||
if (prev != JSON_KEY) {
|
||||
for (uint i = 0; i < rlevel; i++) {
|
||||
_st->print(" ");
|
||||
}
|
||||
}
|
||||
_st->print("<str>");
|
||||
for (size_t i = 0; i < v->str.length; i++) {
|
||||
u_char c = v->str.start[i];
|
||||
assert(c != 0, "string overrun");
|
||||
if (c == 0) {
|
||||
return false;
|
||||
}
|
||||
_st->print("%c", c);
|
||||
}
|
||||
_st->print(",\n");
|
||||
}
|
||||
prev = JSON_NONE;
|
||||
return true;
|
||||
|
||||
case JSON_NUMBER_INT:
|
||||
log(rlevel, "<int>%" PRId64 ",\n", v->int_value);
|
||||
prev = JSON_NONE;
|
||||
return true;
|
||||
|
||||
case JSON_NUMBER_FLOAT:
|
||||
log(rlevel, "<double>%lf,\n", v->double_value);
|
||||
prev = JSON_NONE;
|
||||
return true;
|
||||
|
||||
case JSON_TRUE:
|
||||
log(rlevel, "<true>,\n");
|
||||
prev = JSON_NONE;
|
||||
return true;
|
||||
|
||||
case JSON_FALSE:
|
||||
log(rlevel, "<false>,\n");
|
||||
prev = JSON_NONE;
|
||||
return true;
|
||||
|
||||
case JSON_NULL:
|
||||
log(rlevel, "<null>,\n");
|
||||
prev = JSON_NONE;
|
||||
return true;
|
||||
|
||||
default:
|
||||
error(INTERNAL_ERROR, "unknown JSON type");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue