boost::optional<task_data> read_task(task_node const& node, error_tag_sink& esink)
{
if (!node.get_value())
return boost::none;
if (node.get_value()->get_type() == value_node_type::pseudo_identifier)
{
pseudo_identifier_value_node const& cvalue = static_cast<pseudo_identifier_value_node const&>(*node.get_value());
std::stringstream ss;
ss << "excepted value of type \"" << read_value_node_impl<task_data>::get_type_name() << "\", but identifier found";
esink.push(error_tag(cvalue.get_token().get_range(), ss.str()));
return read_value_node_impl<task_data>::value_for_pseudo_identifier(cvalue);
}
if (!can_read_value_node<task_data>(*node.get_value()))
{
std::stringstream ss;
ss << "\"" << get_type_by_value_node(*node.get_value()) << "\" is not a valid type for task";
esink.push(error_tag(node.get_value()->get_range(), ss.str()));
return boost::none;
}
return read_value_node<task_data>(*node.get_value(), esink);
}
int ZBarcode_Print(struct zint_symbol *symbol, int rotate_angle)
{
int error_number;
char output[4];
switch(rotate_angle) {
case 0:
case 90:
case 180:
case 270:
break;
default:
strcpy(symbol->errtxt, "Invalid rotation angle");
return ERROR_INVALID_OPTION;
break;
}
if(strlen(symbol->outfile) > 3) {
output[0] = symbol->outfile[strlen(symbol->outfile) - 3];
output[1] = symbol->outfile[strlen(symbol->outfile) - 2];
output[2] = symbol->outfile[strlen(symbol->outfile) - 1];
output[3] = '\0';
to_upper((unsigned char*)output);
#ifndef NO_PNG
if(!(strcmp(output, "PNG"))) {
if(symbol->scale < 1.0) { symbol->text[0] = '\0'; }
error_number = png_handle(symbol, rotate_angle);
} else
#endif
if(!(strcmp(output, "TXT"))) {
error_number = dump_plot(symbol);
} else
if(!(strcmp(output, "EPS"))) {
error_number = ps_plot(symbol);
} else
if(!(strcmp(output, "SVG"))) {
error_number = svg_plot(symbol);
} else
{
strcpy(symbol->errtxt, "Unknown output format");
error_tag(symbol->errtxt, ERROR_INVALID_OPTION);
return ERROR_INVALID_OPTION;
}
} else {
strcpy(symbol->errtxt, "Unknown output format");
error_tag(symbol->errtxt, ERROR_INVALID_OPTION);
return ERROR_INVALID_OPTION;
}
error_tag(symbol->errtxt, error_number);
return error_number;
}
int ZBarcode_Buffer(struct zint_symbol *symbol, int rotate_angle)
{
int error_number;
switch(rotate_angle) {
case 0:
case 90:
case 180:
case 270:
break;
default:
strcpy(symbol->errtxt, "Invalid rotation angle");
return ZERROR_INVALID_OPTION;
break;
}
error_number = bmp_handle(symbol, rotate_angle);
error_tag(symbol->errtxt, error_number);
return error_number;
}
int ZBarcode_Encode(struct zint_symbol *symbol, uint8_t *source, int length)
{
int error_number, error_buffer, i;
error_number = 0;
if(length == 0) {
length = ustrlen(source);
}
if(length == 0) {
strcpy(symbol->errtxt, "No input data");
error_tag(symbol->errtxt, ZERROR_INVALID_DATA);
return ZERROR_INVALID_DATA;
}
if(strcmp(symbol->outfile, "") == 0) {
strcpy(symbol->outfile, "out.png");
}
uint8_t local_source[length + 1];
/* First check the symbology field */
if(symbol->symbology < 1) { strcpy(symbol->errtxt, "Symbology out of range, using Code 128"); symbol->symbology = BARCODE_CODE128; error_number = ZWARN_INVALID_OPTION; }
/* symbol->symbologys 1 to 86 are defined by tbarcode */
if(symbol->symbology == 5) { symbol->symbology = BARCODE_C25MATRIX; }
if((symbol->symbology >= 10) && (symbol->symbology <= 12)) { symbol->symbology = BARCODE_EANX; }
if((symbol->symbology == 14) || (symbol->symbology == 15)) { symbol->symbology = BARCODE_EANX; }
if(symbol->symbology == 17) { symbol->symbology = BARCODE_UPCA; }
if(symbol->symbology == 19) { strcpy(symbol->errtxt, "Codabar 18 not supported, using Codabar"); symbol->symbology = BARCODE_CODABAR; error_number = ZWARN_INVALID_OPTION; }
if(symbol->symbology == 26) { symbol->symbology = BARCODE_UPCA; }
if(symbol->symbology == 27) { strcpy(symbol->errtxt, "UPCD1 not supported"); error_number = ZERROR_INVALID_OPTION; }
if(symbol->symbology == 33) { symbol->symbology = BARCODE_EAN128; }
if((symbol->symbology == 35) || (symbol->symbology == 36)) { symbol->symbology = BARCODE_UPCA; }
if((symbol->symbology == 38) || (symbol->symbology == 39)) { symbol->symbology = BARCODE_UPCE; }
if((symbol->symbology >= 41) && (symbol->symbology <= 45)) { symbol->symbology = BARCODE_POSTNET; }
if(symbol->symbology == 46) { symbol->symbology = BARCODE_PLESSEY; }
if(symbol->symbology == 48) { symbol->symbology = BARCODE_NVE18; }
if(symbol->symbology == 54) { strcpy(symbol->errtxt, "General Parcel Code not supported, using Code 128"); symbol->symbology = BARCODE_CODE128; error_number = ZWARN_INVALID_OPTION; }
if((symbol->symbology == 59) || (symbol->symbology == 61)) { symbol->symbology = BARCODE_CODE128; }
if(symbol->symbology == 62) { symbol->symbology = BARCODE_CODE93; }
if((symbol->symbology == 64) || (symbol->symbology == 65)) { symbol->symbology = BARCODE_AUSPOST; }
if(symbol->symbology == 73) { strcpy(symbol->errtxt, "Codablock E not supported"); error_number = ZERROR_INVALID_OPTION; }
if(symbol->symbology == 78) { symbol->symbology = BARCODE_RSS14; }
if(symbol->symbology == 83) { symbol->symbology = BARCODE_PLANET; }
if(symbol->symbology == 88) { symbol->symbology = BARCODE_EAN128; }
if(symbol->symbology == 91) { strcpy(symbol->errtxt, "Symbology out of range, using Code 128"); symbol->symbology = BARCODE_CODE128; error_number = ZWARN_INVALID_OPTION; }
if((symbol->symbology >= 94) && (symbol->symbology <= 96)) { strcpy(symbol->errtxt, "Symbology out of range, using Code 128"); symbol->symbology = BARCODE_CODE128; error_number = ZWARN_INVALID_OPTION; }
if(symbol->symbology == 100) { symbol->symbology = BARCODE_HIBC_128; }
if(symbol->symbology == 101) { symbol->symbology = BARCODE_HIBC_39; }
if(symbol->symbology == 103) { symbol->symbology = BARCODE_HIBC_DM; }
if(symbol->symbology == 105) { symbol->symbology = BARCODE_HIBC_QR; }
if(symbol->symbology == 107) { symbol->symbology = BARCODE_HIBC_PDF; }
if(symbol->symbology == 109) { symbol->symbology = BARCODE_HIBC_MICPDF; }
if(symbol->symbology == 111) { symbol->symbology = BARCODE_HIBC_BLOCKF; }
if((symbol->symbology >= 113) && (symbol->symbology <= 127)) { strcpy(symbol->errtxt, "Symbology out of range, using Code 128"); symbol->symbology = BARCODE_CODE128; error_number = ZWARN_INVALID_OPTION; }
/* Everything from 128 up is Zint-specific */
if(symbol->symbology >= 143) { strcpy(symbol->errtxt, "Symbology out of range, using Code 128"); symbol->symbology = BARCODE_CODE128; error_number = ZWARN_INVALID_OPTION; }
if((symbol->symbology == BARCODE_CODABLOCKF) || (symbol->symbology == BARCODE_HIBC_BLOCKF)) { strcpy(symbol->errtxt, "Codablock F not supported"); error_number = ZERROR_INVALID_OPTION; }
if(error_number > 4) {
error_tag(symbol->errtxt, error_number);
return error_number;
} else {
error_buffer = error_number;
}
if((symbol->input_mode < 0) || (symbol->input_mode > 2)) { symbol->input_mode = DATA_MODE; }
if(symbol->input_mode == GS1_MODE) {
for(i = 0; i < length; i++) {
if(source[i] == '\0') {
strcpy(symbol->errtxt, "NULL characters not permitted in GS1 mode");
return ZERROR_INVALID_DATA;
}
}
if(gs1_compliant(symbol->symbology) == 1) {
error_number = ugs1_verify(symbol, source, length, local_source);
if(error_number != 0) { return error_number; }
length = ustrlen(local_source);
} else {
strcpy(symbol->errtxt, "Selected symbology does not support GS1 mode");
return ZERROR_INVALID_OPTION;
}
} else {
memcpy(local_source, source, length);
local_source[length] = '\0';
}
switch(symbol->symbology) {
case BARCODE_QRCODE:
case BARCODE_MICROQR:
case BARCODE_GRIDMATRIX:
error_number = extended_charset(symbol, local_source, length);
break;
default:
error_number = reduced_charset(symbol, local_source, length);
break;
}
if((symbol->symbology == BARCODE_CODE128) || (symbol->symbology == BARCODE_CODE128B)) {
for(i = 0; i < length; i++) {
if(local_source[i] == '\0') {
symbol->text[i] = ' ';
} else {
symbol->text[i] = local_source[i];
}
}
}
if(error_number == 0) {
error_number = error_buffer;
}
error_tag(symbol->errtxt, error_number);
/*printf("%s\n",symbol->text);*/
return error_number;
}
token_sp lexer::read_next_token()
{
for (;;)
{
skip_whitespace();
if (eof_char())
return token_sp();
char const* lex_start = pos;
if (is_ascii_whitespace(peek_char()))
{
advance_char();
while (!eof_char() && is_ascii_whitespace(peek_char()))
advance_char();
return make_unique<simple_token>(text_range(lex_start, pos), token_type::whitespace);
}
else if (is_single_line_comment_start())
{
advance_char(2);
for (;;)
{
if (eof_char() || is_single_line_comment_end())
{
advance_char();
break;
}
else
advance_char();
}
}
else if (is_multi_line_comment_start())
{
advance_char(2);
for (;;)
{
if (eof_char())
{
error_sink->push(error_tag(text_range::make_empty(pos), "unterminated comment"));
break;
}
else if (is_multi_line_comment_end())
{
advance_char(2);
break;
}
else
advance_char();
}
}
else if (is_raw_string_literal_start())
{
advance_char(2);
std::string prefix;
std::string value;
for (;;)
{
if (eof_char()
|| peek_char() == ' '
|| peek_char() == ')'
|| peek_char() == '\t'
|| peek_char() == '\v'
|| peek_char() == '\r'
|| peek_char() == '\n')
{
text_range r(lex_start, pos);
error_sink->push(error_tag(r, "expected '(' in raw string literal"));
return make_unique<string_literal_token>(r, std::move(value));
}
else if (peek_char() == '(')
{
advance_char();
break;
}
else
{
prefix += peek_char();
advance_char();
}
}
for (;;)
{
if (eof_char())
{
text_range r(lex_start, pos);
error_sink->push(error_tag(r, "unterminated string"));
return make_unique<string_literal_token>(r, std::move(value));
}
else if (is_raw_string_literal_end(prefix))
{
// as raw-string-literal-end should begins with ')' and std::equals is short-circuited,
// raw-string-literal should be lexed in linear time
advance_char(2 + prefix.size());
return make_unique<string_literal_token>(text_range(lex_start, pos), std::move(value));
}
else
{
value += peek_char();
advance_char();
}
}
}
else if (is_identifier_start(peek_char()))
{
std::string s(1, peek_char());
advance_char();
while (!eof_char() && is_identifier_trail(peek_char()))
{
s += peek_char();
advance_char();
}
return make_identifier_token(text_range(lex_start, pos), std::move(s));
}
else if (is_number(peek_char()))
{
int value = char_to_number(peek_char());
advance_char();
while (!eof_char() && is_number(peek_char()))
{
value = value * 10 + char_to_number(peek_char());
advance_char();
}
return make_unique<integer_literal_token>(text_range(lex_start, pos), value);
}
else if (peek_char() == '\"')
{
advance_char();
std::string value;
for (;;)
{
if (eof_char() || peek_char() == '\n')
{
text_range r(lex_start, pos);
error_sink->push(error_tag(r, "unterminated string"));
return make_unique<string_literal_token>(r, std::move(value));
}
else if (peek_char() == '\"')
{
advance_char();
return make_unique<string_literal_token>(text_range(lex_start, pos), std::move(value));
}
else if (peek_char() == '\\')
{
const char* escape_start = pos;
advance_char();
if (!eof_char())
{
switch (peek_char())
{
case 'a':
value += '\a';
break;
case 'b':
value += '\b';
break;
case 'f':
value += '\f';
break;
case 'n':
value += '\n';
break;
case 'r':
value += '\r';
break;
case 't':
value += '\t';
break;
case 'v':
value += '\v';
break;
case '\\':
value += '\\';
break;
case '\'':
value += '\'';
break;
case '\"':
value += '\"';
break;
default:
error_sink->push(error_tag(text_range(escape_start, pos + 1), "invalid escape character"));
value += '\\';
value += peek_char();
break;
}
advance_char();
}
}
else
{
value += peek_char();
advance_char();
}
}
}
else if (peek_char() == '{')
{
advance_char();
return make_unique<simple_token>(text_range(lex_start, pos), token_type::lbrace);
}
else if (peek_char() == '}')
{
advance_char();
return make_unique<simple_token>(text_range(lex_start, pos), token_type::rbrace);
}
else if (peek_char() == '=')
{
advance_char();
return make_unique<simple_token>(text_range(lex_start, pos), token_type::equals);
}
else if (peek_char() == ';')
{
advance_char();
return make_unique<simple_token>(text_range(lex_start, pos), token_type::semicolon);
}
else if (peek_char() == ',')
{
advance_char();
return make_unique<simple_token>(text_range(lex_start, pos), token_type::comma);
}
else if (peek_char() == ':')
{
advance_char();
return make_unique<simple_token>(text_range(lex_start, pos), token_type::colon);
}
else
{
advance_char();
return make_unique<simple_token>(text_range(lex_start, pos), token_type::unknown);
}
}
}
