// STRING_LITERAL_QUOTE and STRING_LITERAL_SINGLE_QUOTE
// Initial quote is already eaten by caller
static Ref
read_STRING_LITERAL(SerdReader* reader, SerdNodeFlags* flags, uint8_t q)
{
Ref ref = push_node(reader, SERD_LITERAL, "", 0);
while (true) {
const uint8_t c = peek_byte(reader);
uint32_t code;
switch (c) {
case '\n': case '\r':
r_err(reader, SERD_ERR_BAD_SYNTAX, "line end in short string\n");
return pop_node(reader, ref);
case '\\':
eat_byte_safe(reader, c);
if (!read_ECHAR(reader, ref, flags) &&
!read_UCHAR(reader, ref, &code)) {
r_err(reader, SERD_ERR_BAD_SYNTAX,
"invalid escape `\\%c'\n", peek_byte(reader));
return pop_node(reader, ref);
}
break;
default:
if (c == q) {
eat_byte_check(reader, q);
return ref;
} else {
read_character(reader, ref, flags, eat_byte_safe(reader, c));
}
}
}
eat_byte_check(reader, q);
return ref;
}
static bool
read_verb(SerdReader* reader, Ref* dest)
{
if (peek_byte(reader) == '<') {
return (*dest = read_IRIREF(reader));
} else {
/* Either a qname, or "a". Read the prefix first, and if it is in fact
"a", produce that instead.
*/
*dest = push_node(reader, SERD_CURIE, "", 0);
SerdNode* node = deref(reader, *dest);
const SerdStatus st = read_PN_PREFIX(reader, *dest);
bool ate_dot = false;
if (!st && node->n_bytes == 1 && node->buf[0] == 'a' &&
is_token_end(peek_byte(reader))) {
pop_node(reader, *dest);
return (*dest = push_node(reader, SERD_URI, NS_RDF "type", 47));
} else if (st > SERD_FAILURE ||
!read_PrefixedName(reader, *dest, false, &ate_dot) ||
ate_dot) {
return (*dest = pop_node(reader, *dest));
} else {
return true;
}
}
return false;
}
static inline SerdStatus
bad_char(SerdReader* reader, Ref dest, const char* fmt, uint8_t c)
{
r_err(reader, SERD_ERR_BAD_SYNTAX, fmt, c);
push_replacement(reader, dest);
// Skip bytes until the next start byte
for (uint8_t b = peek_byte(reader); (b & 0x80);) {
eat_byte_safe(reader, b);
b = peek_byte(reader);
}
return SERD_SUCCESS;
}
Json_Token JSON::Lexer::get_token()
{
unsigned int c = peek_byte();
while (isspace(c))
{
next_byte();
c = peek_byte();
}
switch (c)
{
case ':':
next_byte();
return Colon_token;
case ',':
next_byte();
return Comma_token;
case '{':
next_byte();
return Object_start_token;
case '}':
next_byte();
return Object_stop_token;
case '[':
next_byte();
return Array_start_token;
case ']':
next_byte();
return Array_stop_token;
case '"':
return get_string();
case '-':
case '.':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return get_number(c);
default:
return get_special(c);
}
}
boolean JSON::Lexer::end_of_array()
{
unsigned int c = peek_byte();
while (isspace(c))
{
next_byte();
c = peek_byte();
}
if (c == ']')
return true;
return false;
}
static Ref
read_BLANK_NODE_LABEL(SerdReader* reader, bool* ate_dot)
{
eat_byte_safe(reader, '_');
eat_byte_check(reader, ':');
Ref ref = push_node(reader, SERD_BLANK,
reader->bprefix ? (char*)reader->bprefix : "",
reader->bprefix_len);
uint8_t c = peek_byte(reader); // First: (PN_CHARS | '_' | [0-9])
if (is_digit(c) || c == '_') {
push_byte(reader, ref, eat_byte_safe(reader, c));
} else if (!read_PN_CHARS(reader, ref)) {
r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid name start character\n");
return pop_node(reader, ref);
}
while ((c = peek_byte(reader))) { // Middle: (PN_CHARS | '.')*
if (c == '.') {
push_byte(reader, ref, eat_byte_safe(reader, c));
} else if (!read_PN_CHARS(reader, ref)) {
break;
}
}
SerdNode* n = deref(reader, ref);
if (n->buf[n->n_bytes - 1] == '.' && !read_PN_CHARS(reader, ref)) {
// Ate trailing dot, pop it from stack/node and inform caller
--n->n_bytes;
serd_stack_pop(&reader->stack, 1);
*ate_dot = true;
}
if (reader->syntax == SERD_TURTLE) {
if (is_digit(n->buf[reader->bprefix_len + 1])) {
if ((n->buf[reader->bprefix_len]) == 'b') {
((char*)n->buf)[reader->bprefix_len] = 'B'; // Prevent clash
reader->seen_genid = true;
} else if (reader->seen_genid &&
n->buf[reader->bprefix_len] == 'B') {
r_err(reader, SERD_ERR_ID_CLASH,
"found both `b' and `B' blank IDs, prefix required\n");
return pop_node(reader, ref);
}
}
}
return ref;
}
static bool
read_triples(SerdReader* reader, ReadContext ctx, bool* ate_dot)
{
bool nested = false;
const Ref subject = read_subject(reader, ctx, &nested);
bool ret = false;
if (subject) {
ctx.subject = subject;
if (nested) {
read_ws_star(reader);
ret = true;
if (peek_byte(reader) != '.') {
ret = read_predicateObjectList(reader, ctx, ate_dot);
}
} else {
TRY_RET(read_ws_plus(reader));
ret = read_predicateObjectList(reader, ctx, ate_dot);
}
pop_node(reader, subject);
} else {
ret = false;
}
ctx.subject = ctx.predicate = 0;
return ret;
}
static bool
read_predicateObjectList(SerdReader* reader, ReadContext ctx, bool* ate_dot)
{
uint8_t c;
while (true) {
TRY_THROW(read_verb(reader, &ctx.predicate));
read_ws_star(reader);
TRY_THROW(read_objectList(reader, ctx, ate_dot));
ctx.predicate = pop_node(reader, ctx.predicate);
if (*ate_dot) {
return true;
}
do {
read_ws_star(reader);
switch (c = peek_byte(reader)) {
case 0:
return false;
case '.': case ']':
return true;
case ';':
eat_byte_safe(reader, c);
}
} while (c == ';');
}
pop_node(reader, ctx.predicate);
return true;
except:
pop_node(reader, ctx.predicate);
return false;
}
static bool
read_statement(SerdReader* reader)
{
SerdStatementFlags flags = 0;
ReadContext ctx = { 0, 0, 0, &flags };
read_ws_star(reader);
bool ate_dot = false;
switch (peek_byte(reader)) {
case '\0':
reader->eof = true;
return true;
case '@':
TRY_RET(read_directive(reader));
read_ws_star(reader);
return (eat_byte_check(reader, '.') == '.');
default:
if (!read_triples(reader, ctx, &ate_dot)) {
return false;
} else if (ate_dot) {
return true;
} else {
read_ws_star(reader);
return (eat_byte_check(reader, '.') == '.');
}
break;
}
read_ws_star(reader); // remove?
return true;
}
static SerdStatus
read_utf8_character(SerdReader* reader, Ref dest, uint8_t c)
{
unsigned size = 1;
if ((c & 0xE0) == 0xC0) { // Starts with `110'
size = 2;
} else if ((c & 0xF0) == 0xE0) { // Starts with `1110'
size = 3;
} else if ((c & 0xF8) == 0xF0) { // Starts with `11110'
size = 4;
} else {
return bad_char(reader, dest, "invalid UTF-8 start 0x%X\n", c);
}
char bytes[4];
bytes[0] = c;
// Check character validity
for (unsigned i = 1; i < size; ++i) {
if (((bytes[i] = peek_byte(reader)) & 0x80) == 0) {
return bad_char(reader, dest, "invalid UTF-8 continuation 0x%X\n",
bytes[i]);
}
eat_byte_safe(reader, bytes[i]);
}
// Emit character
for (unsigned i = 0; i < size; ++i) {
push_byte(reader, dest, bytes[i]);
}
return SERD_SUCCESS;
}
/*
* Is the zs chip present?
*/
static int
zs_match(device_t parent, cfdata_t cf, void *aux)
{
struct confargs *ca = aux;
int unit;
void *va;
/*
* This driver only supports its wired-in mappings,
* because the console support depends on those.
*/
if (ca->ca_paddr == zs_physaddr[0]) {
unit = 0;
} else if (ca->ca_paddr == zs_physaddr[1]) {
unit = 1;
} else {
return (0);
}
/* Make sure zs_init() found mappings. */
va = zsaddr[unit];
if (va == NULL)
return (0);
/* This returns -1 on a fault (bus error). */
if (peek_byte(va) == -1)
return (0);
/* Default interrupt priority (always splbio==2) */
if (ca->ca_intpri == -1)
ca->ca_intpri = ZSHARD_PRI;
return (1);
}
bool
msgpack_t::get_byte (u_int8_t *b)
{
bool ret = peek_byte (b);
if (ret) _cp++;
return ret;
}
// Read ECHAR escape, initial \ is already eaten by caller
static inline bool
read_ECHAR(SerdReader* reader, Ref dest, SerdNodeFlags* flags)
{
const uint8_t c = peek_byte(reader);
switch (c) {
case 't':
eat_byte_safe(reader, 't');
push_byte(reader, dest, '\t');
return true;
case 'b':
eat_byte_safe(reader, 'b');
push_byte(reader, dest, '\b');
return true;
case 'n':
*flags |= SERD_HAS_NEWLINE;
eat_byte_safe(reader, 'n');
push_byte(reader, dest, '\n');
return true;
case 'r':
*flags |= SERD_HAS_NEWLINE;
eat_byte_safe(reader, 'r');
push_byte(reader, dest, '\r');
return true;
case 'f':
eat_byte_safe(reader, 'f');
push_byte(reader, dest, '\f');
return true;
case '\\': case '"': case '\'':
push_byte(reader, dest, eat_byte_safe(reader, c));
return true;
default:
return false;
}
}
static bool
read_literal(SerdReader* reader, Ref* dest,
Ref* datatype, Ref* lang, SerdNodeFlags* flags, bool* ate_dot)
{
Ref str = read_String(reader, flags);
if (!str) {
return false;
}
switch (peek_byte(reader)) {
case '@':
eat_byte_safe(reader, '@');
TRY_THROW(*lang = read_LANGTAG(reader));
break;
case '^':
eat_byte_safe(reader, '^');
eat_byte_check(reader, '^');
TRY_THROW(read_iri(reader, datatype, ate_dot));
break;
}
*dest = str;
return true;
except:
pop_node(reader, *datatype);
pop_node(reader, *lang);
pop_node(reader, str);
return false;
}
// [10] comment ::= '#' ( [^#xA #xD] )*
static void
read_comment(SerdReader* reader)
{
eat_byte_safe(reader, '#');
uint8_t c;
while (((c = peek_byte(reader)) != 0xA) && (c != 0xD) && c) {
eat_byte_safe(reader, c);
}
}
static bool
read_directive(SerdReader* reader)
{
eat_byte_safe(reader, '@');
switch (peek_byte(reader)) {
case 'b': return read_base(reader);
case 'p': return read_prefixID(reader);
default: return r_err(reader, SERD_ERR_BAD_SYNTAX, "invalid directive\n");
}
}
static inline uint8_t
eat_byte_check(SerdReader* reader, const uint8_t byte)
{
const uint8_t c = peek_byte(reader);
if (c != byte) {
return r_err(reader, SERD_ERR_BAD_SYNTAX,
"expected `%c', not `%c'\n", byte, c);
}
return eat_byte_safe(reader, byte);
}
static Ref
read_String(SerdReader* reader, SerdNodeFlags* flags)
{
const uint8_t q1 = peek_byte(reader);
eat_byte_safe(reader, q1);
const uint8_t q2 = peek_byte(reader);
if (q2 != q1) { // Short string (not triple quoted)
return read_STRING_LITERAL(reader, flags, q1);
}
eat_byte_safe(reader, q2);
const uint8_t q3 = peek_byte(reader);
if (q3 != q1) { // Empty short string ("" or '')
return push_node(reader, SERD_LITERAL, "", 0);
}
eat_byte_safe(reader, q3);
return read_STRING_LITERAL_LONG(reader, flags, q1);
}
static inline uint8_t
read_HEX(SerdReader* reader)
{
const uint8_t c = peek_byte(reader);
if (is_digit(c) || in_range(c, 'A', 'F') || in_range(c, 'a', 'f')) {
return eat_byte_safe(reader, c);
} else {
return r_err(reader, SERD_ERR_BAD_SYNTAX,
"invalid hexadecimal digit `%c'\n", c);
}
}
static Ref
read_LANGTAG(SerdReader* reader)
{
uint8_t c = peek_byte(reader);
if (!is_alpha(c)) {
return r_err(reader, SERD_ERR_BAD_SYNTAX, "unexpected `%c'\n", c);
}
Ref ref = push_node(reader, SERD_LITERAL, "", 0);
push_byte(reader, ref, eat_byte_safe(reader, c));
while ((c = peek_byte(reader)) && is_alpha(c)) {
push_byte(reader, ref, eat_byte_safe(reader, c));
}
while (peek_byte(reader) == '-') {
push_byte(reader, ref, eat_byte_safe(reader, '-'));
while ((c = peek_byte(reader)) && (is_alpha(c) || is_digit(c))) {
push_byte(reader, ref, eat_byte_safe(reader, c));
}
}
return ref;
}
static bool
read_0_9(SerdReader* reader, Ref str, bool at_least_one)
{
unsigned count = 0;
for (uint8_t c; is_digit((c = peek_byte(reader))); ++count) {
push_byte(reader, str, eat_byte_safe(reader, c));
}
if (at_least_one && count == 0) {
r_err(reader, SERD_ERR_BAD_SYNTAX, "expected digit\n");
}
return count;
}
static bool
read_blank(SerdReader* reader, ReadContext ctx, bool subject, Ref* dest, bool* ate_dot)
{
const SerdStatementFlags old_flags = *ctx.flags;
bool empty;
switch (peek_byte(reader)) {
case '_':
return (*dest = read_BLANK_NODE_LABEL(reader, ate_dot));
case '[':
eat_byte_safe(reader, '[');
if ((empty = peek_delim(reader, ']'))) {
*ctx.flags |= (subject) ? SERD_EMPTY_S : SERD_EMPTY_O;
} else {
*ctx.flags |= (subject) ? SERD_ANON_S_BEGIN : SERD_ANON_O_BEGIN;
if (peek_delim(reader, '=')) {
if (!(*dest = read_blankName(reader)) ||
!eat_delim(reader, ';')) {
return false;
}
}
}
if (!*dest) {
*dest = blank_id(reader);
}
if (ctx.subject) {
TRY_RET(emit_statement(reader, ctx, *dest, 0, 0));
}
ctx.subject = *dest;
if (!empty) {
*ctx.flags &= ~(SERD_LIST_CONT);
if (!subject) {
*ctx.flags |= SERD_ANON_CONT;
}
bool ate_dot_in_list = false;
read_predicateObjectList(reader, ctx, &ate_dot_in_list);
if (ate_dot_in_list) {
return r_err(reader, SERD_ERR_BAD_SYNTAX, "`.' inside blank\n");
}
read_ws_star(reader);
if (reader->end_sink) {
reader->end_sink(reader->handle, deref(reader, *dest));
}
*ctx.flags = old_flags;
}
return (eat_byte_check(reader, ']') == ']');
case '(':
return read_collection(reader, ctx, dest);
default: return false; // never reached
}
}
static bool
read_PN_CHARS_BASE(SerdReader* reader, Ref dest)
{
const uint8_t c = peek_byte(reader);
if ((c & 0x80)) { // Multi-byte character
return !read_utf8_character(reader, dest, eat_byte_safe(reader, c));
}
if (is_alpha(c)) {
push_byte(reader, dest, eat_byte_safe(reader, c));
return true;
}
return false;
}
static SerdStatus
read_PN_LOCAL(SerdReader* reader, Ref dest, bool* ate_dot)
{
uint8_t c = peek_byte(reader);
SerdStatus st;
switch (c) {
case '0': case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9': case ':': case '_':
push_byte(reader, dest, eat_byte_safe(reader, c));
break;
default:
if ((st = read_PLX(reader, dest)) > SERD_FAILURE) {
return st;
} else if (st != SERD_SUCCESS && !read_PN_CHARS_BASE(reader, dest)) {
return SERD_FAILURE;
}
}
while ((c = peek_byte(reader))) { // Middle: (PN_CHARS | '.' | ';')*
if (c == '.' || c == ':') {
push_byte(reader, dest, eat_byte_safe(reader, c));
} else if ((st = read_PLX(reader, dest)) > SERD_FAILURE) {
return st;
} else if (st != SERD_SUCCESS && !read_PN_CHARS(reader, dest)) {
break;
}
}
SerdNode* const n = deref(reader, dest);
if (n->buf[n->n_bytes - 1] == '.') {
// Ate trailing dot, pop it from stack/node and inform caller
--n->n_bytes;
serd_stack_pop(&reader->stack, 1);
*ate_dot = true;
}
return SERD_SUCCESS;
}
// STRING_LITERAL_LONG_QUOTE and STRING_LITERAL_LONG_SINGLE_QUOTE
// Initial triple quotes are already eaten by caller
static Ref
read_STRING_LITERAL_LONG(SerdReader* reader, SerdNodeFlags* flags, uint8_t q)
{
Ref ref = push_node(reader, SERD_LITERAL, "", 0);
while (true) {
const uint8_t c = peek_byte(reader);
uint32_t code;
switch (c) {
case '\\':
eat_byte_safe(reader, c);
if (!read_ECHAR(reader, ref, flags) &&
!read_UCHAR(reader, ref, &code)) {
r_err(reader, SERD_ERR_BAD_SYNTAX,
"invalid escape `\\%c'\n", peek_byte(reader));
return pop_node(reader, ref);
}
break;
default:
if (c == q) {
eat_byte_safe(reader, q);
const uint8_t q2 = eat_byte_safe(reader, peek_byte(reader));
const uint8_t q3 = peek_byte(reader);
if (q2 == q && q3 == q) { // End of string
eat_byte_safe(reader, q3);
return ref;
} else {
*flags |= SERD_HAS_QUOTE;
push_byte(reader, ref, c);
read_character(reader, ref, flags, q2);
}
} else {
read_character(reader, ref, flags, eat_byte_safe(reader, c));
}
}
}
return ref;
}
static void psh(struct MC6809 *cpu, uint16_t *s, uint16_t as) {
unsigned postbyte;
postbyte = byte_immediate(cpu);
NVMA_CYCLE;
NVMA_CYCLE;
peek_byte(cpu, *s);
if (postbyte & 0x80) { push_word(cpu, s, REG_PC); }
if (postbyte & 0x40) { push_word(cpu, s, as); }
if (postbyte & 0x20) { push_word(cpu, s, REG_Y); }
if (postbyte & 0x10) { push_word(cpu, s, REG_X); }
if (postbyte & 0x08) { push_byte(cpu, s, REG_DP); }
if (postbyte & 0x04) { push_byte(cpu, s, RREG_B); }
if (postbyte & 0x02) { push_byte(cpu, s, RREG_A); }
if (postbyte & 0x01) { push_byte(cpu, s, REG_CC); }
}
// [24] ws ::= #x9 | #xA | #xD | #x20 | comment
static inline bool
read_ws(SerdReader* reader)
{
const uint8_t c = peek_byte(reader);
switch (c) {
case 0x9: case 0xA: case 0xD: case 0x20:
eat_byte_safe(reader, c);
return true;
case '#':
read_comment(reader);
return true;
default:
return false;
}
}
static bool
read_iri(SerdReader* reader, Ref* dest, bool* ate_dot)
{
switch (peek_byte(reader)) {
case '<':
*dest = read_IRIREF(reader);
break;
default:
*dest = push_node(reader, SERD_CURIE, "", 0);
if (!read_PrefixedName(reader, *dest, true, ate_dot)) {
*dest = pop_node(reader, *dest);
}
}
return *dest != 0;
}
static SerdStatus
read_PLX(SerdReader* reader, Ref dest)
{
uint8_t c = peek_byte(reader);
switch (c) {
case '%':
if (!read_PERCENT(reader, dest)) {
return SERD_ERR_BAD_SYNTAX;
}
return SERD_SUCCESS;
case '\\':
eat_byte_safe(reader, c);
if (is_alpha(c = peek_byte(reader))) {
// Escapes like \u \n etc. are not supported
return SERD_ERR_BAD_SYNTAX;
} else {
// Allow escaping of pretty much any other character
push_byte(reader, dest, eat_byte_safe(reader, c));
return SERD_SUCCESS;
}
default:
return SERD_FAILURE;
}
}
static void pul(struct MC6809 *cpu, uint16_t *s, uint16_t *as) {
unsigned postbyte;
postbyte = byte_immediate(cpu);
NVMA_CYCLE;
NVMA_CYCLE;
if (postbyte & 0x01) { REG_CC = pull_byte(cpu, s); }
if (postbyte & 0x02) { WREG_A = pull_byte(cpu, s); }
if (postbyte & 0x04) { WREG_B = pull_byte(cpu, s); }
if (postbyte & 0x08) { REG_DP = pull_byte(cpu, s); }
if (postbyte & 0x10) { REG_X = pull_word(cpu, s); }
if (postbyte & 0x20) { REG_Y = pull_word(cpu, s); }
if (postbyte & 0x40) { *as = pull_word(cpu, s); }
if (postbyte & 0x80) { REG_PC = pull_word(cpu, s); }
peek_byte(cpu, *s);
}
