static bool
read_prefixID(SerdReader* reader)
{
bool ret = true;
// `@' is already eaten in read_directive
eat_string(reader, "prefix", 6);
TRY_RET(read_ws_plus(reader));
Ref name = push_node(reader, SERD_LITERAL, "", 0);
if (read_PN_PREFIX(reader, name) > SERD_FAILURE) {
return pop_node(reader, name);
}
if (eat_byte_check(reader, ':') != ':') {
return pop_node(reader, name);
}
read_ws_star(reader);
const Ref uri = read_IRIREF(reader);
if (!uri) {
pop_node(reader, name);
return false;
}
if (reader->prefix_sink) {
ret = !reader->prefix_sink(reader->handle,
deref(reader, name),
deref(reader, uri));
}
pop_node(reader, uri);
pop_node(reader, name);
return ret;
}
static char *
eat_string(int starting_line)
{
int c;
char buffer[500];
char *ptr = buffer;
for (;;) {
/*
* Get the next input character, handling EOF:
*/
c = input();
if (!c) {
unput(c);
report_parse_error("unterminated string found beginning",
starting_line);
return(0);
}
/*
* Deal with special characters ('\\', '"', and '\n'):
*/
if (c=='\\') {
c = eat_escape_code();
if (!c)
continue;
} else if (c == '"') {
*ptr = 0;
return(string_Copy(buffer));
} else if (c == '\n') {
unput(c); /* fix line # reference to right line # */
report_parse_error("carriage return found in string", yylineno);
return(0);
}
/*
* Add the character c to the current string:
*/
*ptr = c;
ptr++;
/*
* If out of buffer space, do a recursive call then
* concatanate the result to the string read in so far to get the
* entire string and return that:
*/
if (ptr>buffer+sizeof(buffer)-20) {
string rest_of_string, result;
rest_of_string = eat_string(starting_line);
if (!rest_of_string)
return(0);
*ptr = 0;
result = string_Concat(buffer, rest_of_string);
free(rest_of_string);
return(result);
}
}
}
static bool
read_base(SerdReader* reader)
{
// `@' is already eaten in read_directive
eat_string(reader, "base", 4);
TRY_RET(read_ws_plus(reader));
Ref uri;
TRY_RET(uri = read_IRIREF(reader));
if (reader->base_sink) {
reader->base_sink(reader->handle, deref(reader, uri));
}
pop_node(reader, uri);
return true;
}
int yylex(void)
{
register int c, last_char;
register char *ptr;
int start_line_no;
int_dictionary_binding *binding;
char varname[MAX_IDENTIFIER_LENGTH+1];
for (;;) {
switch (c = input()) {
/*
* Skip whitespace:
*/
case ' ': case '\t': case '\n':
continue;
/*
* '#' comments out everything up to the and including
* the next <cr>:
*/
case '#':
while ( (c=input()) && (c!='\n') ) ;
if (!c)
unput(c);
continue;
/*
* Handle c-style comments. Note that "/[^*]" is not the start
* of any valid token.
*/
case '/':
start_line_no = yylineno;
/* verify that next character is a '*': */
if ((c=input()) != '*')
return(ERROR);
/* Scan until "*\/" or <EOF>: */
for (last_char=0; ; last_char=c) {
c = input();
if (c == '/' && (last_char=='*'))
break;
if (!c) {
unput(c);
report_parse_error("unterminated c style comment found beginning", start_line_no);
return(ERROR);
}
}
continue;
/*
* The following characters lex as themselves:
* '+', '|', '&', '(', ')', '.', ',' and <EOF>:
*/
case 0: case '+': case '|': case '&': case '(':
case ')': case '.': case ',':
return(c);
/*
* Handle "=[^~=]", "=~", and "==":
*/
case '=':
switch (c = input()) {
case '~':
return(REGEQ);
case '=':
return(EQ);
default:
unput(c);
return('=');
}
/*
* Handle "![^~=]", "!~", and "!=":
*/
case '!':
switch (c = input()) {
case '~':
return(REGNEQ);
case '=':
return(NEQ);
default:
unput(c);
return('!');
}
/*
* Handle identifiers and keywords:
*
* Note that the below set of characters is hard coded from
* is_identifier_char from parser.h.
*/
case 'a': case 'b': case 'c': case 'd': case 'e':
case 'f': case 'g': case 'h': case 'i': case 'j':
case 'k': case 'l': case 'm': case 'n': case 'o':
case 'p': case 'q': case 'r': case 's': case 't':
case 'u': case 'v': case 'w': case 'x': case 'y':
case 'z':
case 'A': case 'B': case 'C': case 'D': case 'E':
case 'F': case 'G': case 'H': case 'I': case 'J':
case 'K': case 'L': case 'M': case 'N': case 'O':
case 'P': case 'Q': case 'R': case 'S': case 'T':
case 'U': case 'V': case 'W': case 'X': case 'Y':
case 'Z':
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
case '_':
/*
* Read in the first MAX_IDENTIFIER_LENGTH characters of the
* identifier into varname null terminated. Eat
* the rest of the characters of the identifier:
*/
for (ptr = varname;;) {
if (ptr<varname+MAX_IDENTIFIER_LENGTH)
*(ptr++) = c;
c = input();
if (!is_identifier_char(c))
break;
}
unput(c);
*ptr = '\0';
/*
* Look up the identifier in the keyword dictionary.
* If its a match, return the keyword's #. In the case
* of show, call handle_show to do more processing.
* If not a match, treat as a variable name.
*/
binding = int_dictionary_Lookup(keyword_dict, varname);
if (!binding) {
yylval.text = string_Copy(varname);
return(VARNAME);
}
if (binding->value == SHOW)
return(handle_show());
else
return(binding->value);
/*
* Handle "${identifier}". Note that $ followed by a
* non-identifier character is not the start of any valid token.
*/
case '$':
c = input();
if (!is_identifier_char(c))
return(ERROR);
/*
* Read in the first MAX_IDENTIFIER_LENGTH characters of the
* identifier into varname null terminated. Eat
* the rest of the characters of the identifier:
*/
for (ptr = varname;;) {
if (ptr<varname+MAX_IDENTIFIER_LENGTH)
*(ptr++) = c;
c = input();
if (!is_identifier_char(c))
break;
}
unput(c);
*ptr = '\0';
yylval.text = string_Copy(varname);
return(VARREF);
/*
* Handle constant strings:
*/
case '"':
yylval.text = eat_string(yylineno);
if (yylval.text)
return(STRING);
else
return(ERROR);
/*
* All other characters do not start valid tokens:
*/
default:
return(ERROR);
}
}
}