/**
* gnutls_x509_crq_get_challenge_password - This function will get the challenge password
* @crq: should contain a gnutls_x509_crq_t structure
* @pass: will hold a null terminated password
* @sizeof_pass: Initially holds the size of @pass.
*
* This function will return the challenge password in the
* request.
*
* Returns 0 on success.
*
**/
int
gnutls_x509_crq_get_challenge_password (gnutls_x509_crq_t crq,
char *pass, size_t * sizeof_pass)
{
if (crq == NULL)
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
return parse_attribute (crq->crq, "certificationRequestInfo.attributes",
"1.2.840.113549.1.9.7", 0, 0, pass, sizeof_pass);
}
/**
* gnutls_x509_crq_get_attribute_by_oid - This function will get an attribute of the request
* @crq: should contain a gnutls_x509_crq_t structure
* @oid: holds an Object Identified in null terminated string
* @indx: In case multiple same OIDs exist in the attribute list, this specifies
* which to send. Use zero to get the first one.
* @buf: a pointer to a structure to hold the attribute data (may be null)
* @sizeof_buf: initially holds the size of @buf
*
* This function will return the attribute in the certificate request specified
* by the given Object ID. The attribute will be DER encoded.
*
* Returns 0 on success.
*
**/
int
gnutls_x509_crq_get_attribute_by_oid (gnutls_x509_crq_t crq,
const char *oid, int indx, void *buf,
size_t * sizeof_buf)
{
if (crq == NULL)
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
return parse_attribute (crq->crq, "certificationRequestInfo.attributes",
oid, indx, 1, buf, sizeof_buf);
}
tree
xml_html_parser::parse_opening () {
s += 1;
string name= parse_name ();
tree t= tuple ("begin", name);
while (true) {
skip_space ();
if (!s || s[0] == '>' || test (s, "/>")) break;
tree attr= parse_attribute ();
if (attr == tuple ("attr")) break;
t << attr;
}
if (test (s, "/>")) { t[0]= "tag"; s += 2; }
else if (test (s, ">")) s += 1;
return t;
}
/***********************************************************************//**
* @brief Parse element start segment string
*
* @param[in] segment Segment string.
*
* @exception GException::xml_syntax_error
* XML syntax error.
*
* Parse the segment string and set class members based on the information
* that is found. The method also performs syntax checking. It does not
* require brackets to be set.
***************************************************************************/
void GXmlElement::parse_start(const std::string& segment)
{
// Initialize position check
std::size_t pos_start = 0;
// Get length of segment
int n = segment.length();
// Throw an error is segment is empty
if (n < 1) {
throw GException::xml_syntax_error(G_PARSE_START, segment,
"no element name specified");
}
// If string starts with brackets then check that the brackets are
// valid comment brackets
if (segment[0] == '<') {
if (n < 2 || (segment.compare(0,1,"<") != 0) ||
(segment.compare(n-1,1,">") != 0)) {
throw GException::xml_syntax_error(G_PARSE_START, segment,
"invalid tag brackets");
}
pos_start = 1;
} // endif: there were brackets
// Extract element name
std::size_t pos = segment.find_first_of("\x20\x09\x0d\x0a>", 1);
if (pos == pos_start) {
throw GException::xml_syntax_error(G_PARSE_START, segment,
"no whitespace allowed before element name");
}
if (pos == std::string::npos) {
if (pos_start == 1) {
throw GException::xml_syntax_error(G_PARSE_START, segment,
"element name not found");
}
}
m_name = segment.substr(pos_start, pos-pos_start);
// Extract attributes
while (pos != std::string::npos) {
parse_attribute(&pos, segment);
}
// Return
return;
}
static void parse_schema_decl(fb_parser_t *P)
{
switch(P->token->id) {
case tok_kw_namespace:
next(P);
parse_namespace(P);
break;
case tok_kw_file_extension:
next(P);
parse_file_extension(P, &P->schema.file_extension);
break;
case tok_kw_file_identifier:
next(P);
parse_file_identifier(P, &P->schema.file_identifier);
break;
case tok_kw_root_type:
next(P);
parse_root_type(P, &P->schema.root_type);
break;
case tok_kw_attribute:
next(P);
parse_attribute(P, fb_add_attribute(P));
break;
case tok_kw_struct:
next(P);
parse_compound_type(P, fb_add_struct(P));
break;
case tok_kw_table:
next(P);
parse_compound_type(P, fb_add_table(P));
break;
case tok_kw_enum:
next(P);
parse_enum_decl(P, fb_add_enum(P));
break;
case tok_kw_union:
next(P);
parse_union_decl(P, fb_add_union(P));
break;
case '{':
error_tok(P, P->token, "JSON objects are not supported by this implementation");
break;
default:
error_tok(P, P->token, "unexpected token in schema definition");
break;
}
}
void fill_auth(struct fetion_account_data *sip, const gchar *hdr, struct sip_auth *auth)
{
gchar *tmp;
if(!hdr)
{
purple_debug_error("fetion", "fill_auth: hdr==NULL\n");
return;
}
auth->type = 1;
auth->cnonce = gencnonce();
auth->domain = g_strdup("fetion.com.cn");
if((tmp = parse_attribute("nonce=\"", hdr)))
auth->nonce = g_ascii_strup(tmp,32);
purple_debug(PURPLE_DEBUG_MISC, "fetion", "nonce: %s domain: %s\n", auth->nonce ? auth->nonce : "(null)", auth->domain ? auth->domain : "(null)");
if(auth->domain)
auth->digest_session_key = fetion_cipher_digest_calculate_response(
sip->username, auth->domain, sip->password, auth->nonce, auth->cnonce);
}
int sdp_parse(str *body, GQueue *sessions) {
char *b, *end, *value, *line_end, *next_line;
struct sdp_session *session = NULL;
struct sdp_media *media = NULL;
const char *errstr;
struct sdp_attributes *attrs;
struct sdp_attribute *attr;
str *adj_s;
GQueue *attr_queue;
b = body->s;
end = str_end(body);
while (b && b < end - 1) {
#ifdef TERMINATE_SDP_AT_BLANK_LINE
if (b[0] == '\n' || b[0] == '\r') {
body->len = b - body->s;
break;
}
#endif
errstr = "Missing '=' sign";
if (b[1] != '=')
goto error;
value = &b[2];
line_end = memchr(value, '\n', end - value);
if (!line_end) {
/* assume missing LF at end of body */
line_end = end;
next_line = NULL;
}
else {
next_line = line_end + 1;
if (line_end[-1] == '\r')
line_end--;
}
switch (b[0]) {
case 'v':
errstr = "Error in v= line";
if (line_end != value + 1)
goto error;
if (value[0] != '0')
goto error;
session = g_slice_alloc0(sizeof(*session));
g_queue_init(&session->media_streams);
attrs_init(&session->attributes);
g_queue_push_tail(sessions, session);
media = NULL;
session->s.s = b;
session->rr = session->rs = -1;
break;
case 'o':
errstr = "o= line found within media section";
if (media)
goto error;
errstr = "Error parsing o= line";
if (parse_origin(value, line_end, &session->origin))
goto error;
break;
case 'm':
media = g_slice_alloc0(sizeof(*media));
media->session = session;
attrs_init(&media->attributes);
errstr = "Error parsing m= line";
if (parse_media(value, line_end, media))
goto error;
g_queue_push_tail(&session->media_streams, media);
media->s.s = b;
media->rr = media->rs = -1;
break;
case 'c':
errstr = "Error parsing c= line";
if (parse_connection(value, line_end,
media ? &media->connection : &session->connection))
goto error;
break;
case 'a':
attr = g_slice_alloc0(sizeof(*attr));
attr->full_line.s = b;
attr->full_line.len = next_line ? (next_line - b) : (line_end - b);
attr->line_value.s = value;
attr->line_value.len = line_end - value;
if (parse_attribute(attr)) {
g_slice_free1(sizeof(*attr), attr);
break;
}
attrs = media ? &media->attributes : &session->attributes;
g_queue_push_tail(&attrs->list, attr);
/* g_hash_table_insert(attrs->name_hash, &attr->name, attr); */
if (!g_hash_table_lookup(attrs->id_hash, &attr->attr))
g_hash_table_insert(attrs->id_hash, &attr->attr, attr);
/* if (attr->key.s)
g_hash_table_insert(attrs->name_hash, &attr->key, attr); */
/* attr_queue = g_hash_table_lookup(attrs->name_lists_hash, &attr->name);
if (!attr_queue)
g_hash_table_insert(attrs->name_lists_hash, &attr->name,
(attr_queue = g_queue_new()));
g_queue_push_tail(attr_queue, attr); */
attr_queue = g_hash_table_lookup(attrs->id_lists_hash, &attr->attr);
if (!attr_queue)
g_hash_table_insert(attrs->id_lists_hash, &attr->attr,
(attr_queue = g_queue_new()));
g_queue_push_tail(attr_queue, attr);
break;
case 'b':
/* RR:0 */
if (line_end - value < 4)
break;
if (!memcmp(value, "RR:", 3))
*(media ? &media->rr : &session->rr) =
(line_end - value == 4 && value[3] == '0') ? 0 : 1;
else if (!memcmp(value, "RS:", 3))
*(media ? &media->rs : &session->rs) =
(line_end - value == 4 && value[3] == '0') ? 0 : 1;
break;
case 's':
case 'i':
case 'u':
case 'e':
case 'p':
case 't':
case 'r':
case 'z':
case 'k':
break;
default:
errstr = "Unknown SDP line type found";
goto error;
}
errstr = "SDP doesn't start with a session definition";
if (!session)
goto error;
adj_s = media ? &media->s : &session->s;
adj_s->len = (next_line ? : end) - adj_s->s;
b = next_line;
}
return 0;
error:
ilog(LOG_WARNING, "Error parsing SDP at offset %li: %s", (long) (b - body->s), errstr);
sdp_free(sessions);
return -1;
}
struct array
html_get_attribute(const struct array *tag, enum html_attr attribute)
{
size_t i = 0;
if (
!tag || !tag->data ||
NUM_HTML_ATTR == attribute || HTML_ATTR_UNKNOWN == attribute
)
goto not_found;
/**
<tag-name>([<space>][<attr>[<space>]'='[<space>]'"'<value>'"'])*
*/
/* skip <tag-name> */
while (i < tag->size && !is_ascii_space(tag->data[i]))
i++;
while (i < tag->size) {
struct array value, attr;
/* skip <space> */
while (i < tag->size && is_ascii_space(tag->data[i]))
i++;
attr = array_init(&tag->data[i], tag->size - i);
/* skip <attr> */
while (i < tag->size) {
const unsigned char c = tag->data[i];
if ('=' == c || is_ascii_space(c))
break;
i++;
}
/* skip <space> */
while (i < tag->size && is_ascii_space(tag->data[i]))
i++;
if (i < tag->size && '=' == tag->data[i]) {
bool quoted = FALSE;
size_t start;
i++;
/* skip <space> */
while (i < tag->size && is_ascii_space(tag->data[i]))
i++;
if (i < tag->size && '"' == tag->data[i]) {
i++;
quoted = TRUE;
}
start = i;
/* skip <value> */
while (i < tag->size) {
const unsigned char c = tag->data[i];
if (quoted) {
if ('"' == c)
break;
} else if (is_ascii_space(c)) {
break;
}
i++;
}
value = array_init(&tag->data[start], i - start);
} else {
value = array_init(&tag->data[i], 0);
}
if (attribute == parse_attribute(attr))
return value;
}
not_found:
return zero_array;
}
/*
* Parse an element node. Check if there is a token for an element tag; if not
* output the element as a string, else ouput the token. After that, call
* attribute parsing functions
* Returns: 1, add an end tag (element node has no children)
* 0, do not add an end tag (it has children)
* -1, an error occurred
*/
static int parse_element(xmlNodePtr node, simple_binary_t **sibxml)
{
Octstr *name,
*outos;
size_t i;
unsigned char status_bits,
si_hex;
int add_end_tag;
xmlAttrPtr attribute;
name = octstr_create((char *)node->name);
outos = NULL;
if (octstr_len(name) == 0) {
octstr_destroy(name);
return -1;
}
i = 0;
while (i < NUMBER_OF_ELEMENTS) {
if (octstr_compare(name, octstr_imm(si_elements[i].name)) == 0)
break;
++i;
}
status_bits = 0x00;
si_hex = 0x00;
add_end_tag = 0;
if (i != NUMBER_OF_ELEMENTS) {
si_hex = si_elements[i].token;
if ((status_bits = element_check_content(node)) > 0) {
si_hex = si_hex | status_bits;
if ((status_bits & WBXML_CONTENT_BIT) == WBXML_CONTENT_BIT)
add_end_tag = 1;
}
output_char(si_hex, sibxml);
} else {
warning(0, "unknown tag %s in SI source", octstr_get_cstr(name));
si_hex = WBXML_LITERAL;
if ((status_bits = element_check_content(node)) > 0) {
si_hex = si_hex | status_bits;
/* If this node has children, the end tag must be added after
them. */
if ((status_bits & WBXML_CONTENT_BIT) == WBXML_CONTENT_BIT)
add_end_tag = 1;
}
output_char(si_hex, sibxml);
output_octet_string(outos = octstr_duplicate(name), sibxml);
}
if (node->properties != NULL) {
attribute = node->properties;
while (attribute != NULL) {
parse_attribute(attribute, sibxml);
attribute = attribute->next;
}
parse_end(sibxml);
}
octstr_destroy(outos);
octstr_destroy(name);
return add_end_tag;
}
char *parse_attributes_group(xmlNode *attr_group_node) {
xmlNode *it = 0;
char *operator_value = 0;
char *operator_type = 0;
xmlAttrPtr attr = 0;
char *attr_group_str;
char *res;
attr_group_str = malloc(MAX_POLICY_LENGTH * sizeof(*attr_group_str));
assert(attr_group_str);
strcpy(attr_group_str, "");
if (strcmp((char*)(attr_group_node->parent->name), ATTRIBUTES_GROUP) == 0) {
for (attr = attr_group_node->parent->properties; attr ; attr = attr->next) {
if (strcmp((char *)attr->name, XML_ATTR_OPERATOR_TYPE) == 0) {
operator_type = (char*)attr->children->content;
} else if (strcmp((char *)attr->name, XML_ATTR_OPERATOR_VALUE) == 0) {
operator_value = (char*)attr->children->content;
} else {
printf ("Attribute %s is not a valid one\n", attr->name);
exit(3);
}
}
}
if (operator_type && strcmp(operator_type, COMPOSITION_TYPE) == 0) {
strcat(attr_group_str, operator_value);
strcat(attr_group_str, " of (");
} else {
strcat(attr_group_str, "( ");
}
for (it = attr_group_node; it; it = it->next) {
if (it->type == XML_ELEMENT_NODE) {
if (strcmp((char *)it->name, ATTRIBUTES_GROUP) == 0) {
res = parse_attributes_group(it->children);
} else if (strcmp((char *)it->name, ATTRIBUTE_ELEMENT) == 0) {
res = parse_attribute(it->children);
} else {
printf("BAD FORMAT\n");
exit(1);
}
strcat(attr_group_str, res);
free(res);
/* Print the operator */
if (it->next && it->next->next) {
if (operator_type && strcmp(operator_type, LOGICAL_TYPE) == 0) {
strcat(attr_group_str, " ");
strcat(attr_group_str, operator_value);
strcat(attr_group_str, " ");
} else {
strcat(attr_group_str, ", ");
}
}
}
}
strcat(attr_group_str, " )");
return attr_group_str;
}
bool
AsxParserInternal::move_next ()
{
clear_current_element ();
bool is_element_close = false;
AsxToken *tok = next_non_whitespace_token ();
if (tok->get_type () == TOKEN_EOF)
return false;
if (tok->get_type () == TOKEN_DATA)
return handle_char_data ();
if (tok->get_type () != TOKEN_OPEN_ELEMENT) {
raise_error (ASXPARSER_ERROR_INVALID_TOKEN, "Invalid char data found.");
return false;
}
tok = next_non_whitespace_token ();
if (tok->get_type () == TOKEN_SLASH) {
is_element_close = true;
tok = next_non_whitespace_token ();
}
if (tok->get_type () != TOKEN_NAME) {
raise_error (ASXPARSER_ERROR_INVALID_TOKEN, "Invalid element formation, no name found.");
return false;
}
if (is_element_close) {
char *close = g_strdup (tokenizer->get_current ()->get_value ());
tok = next_non_whitespace_token ();
if (tok->get_type () != TOKEN_CLOSE_ELEMENT) {
raise_error (ASXPARSER_ERROR_INVALID_TOKEN, "Invalid closing element found.");
g_free (close);
return false;
}
bool res = handle_element_close (close);
g_free (close);
return res;
}
set_current_element (tok->get_value ());
bool is_self_closing = false;
tok = next_non_whitespace_token ();
while (tok->get_type () != TOKEN_EOF && tok->get_type () != TOKEN_CLOSE_ELEMENT) {
if (tok->get_type () == TOKEN_SLASH) {
tok = next_non_whitespace_token ();
if (tok->get_type () != TOKEN_CLOSE_ELEMENT) {
raise_error (ASXPARSER_ERROR_INVALID_TOKEN, "Invalid / character found in element.\n");
return false;
}
is_self_closing = true;
break;
}
if (tok->get_type () == TOKEN_NAME) {
if (!parse_attribute ())
return false;
}
tok = next_non_whitespace_token ();
}
handle_element_open ();
if (is_self_closing)
handle_element_close (current_element);
return true;
}
bool Allegro_reader::parse()
{
int voice = 0;
int key = 60;
double loud = 100.0;
double pitch = 60.0;
double dur = 1.0;
double time = 0.0;
readline();
bool valid = false; // ignore blank lines
while (line_parser_flag) {
bool time_flag = false;
bool next_flag = false;
double next;
bool voice_flag = false;
bool loud_flag = false;
bool dur_flag = false;
bool new_pitch_flag = false; // "P" syntax
double new_pitch = 0.0;
bool new_key_flag = false; // "K" syntax
int new_key = 0;
bool new_note_flag = false; // "A"-"G" syntax
int new_note = 0;
Parameters_ptr attributes = NULL;
line_parser.get_nonspace_quoted(field);
char pk = line_parser.peek();
if (pk && !isspace(pk)) {
line_parser.get_nonspace_quoted(field + strlen(field));
}
while (field[0]) {
// print "field", "|";field;"|", "|";line_parser.string;"|", line_parser.pos
char first = toupper(field[0]);
if (strchr("ABCDEFGKLPUSIQHW-", first)) {
valid = true; // it's a note or event
}
if (first == 'V') {
if (voice_flag) {
parse_error(field, 0, "Voice specified twice");
} else {
voice = parse_int(field);
}
voice_flag = true;
} else if (first == 'T') {
if (time_flag) {
parse_error(field, 0, "Time specified twice");
} else {
time = parse_dur(field, 0.0);
}
time_flag = true;
} else if (first == 'N') {
if (next_flag) {
parse_error(field, 0, "Next specified twice");
} else {
next = parse_dur(field, time);
}
next_flag = true;
} else if (first == 'K') {
if (new_key_flag) {
parse_error(field, 0, "Key specified twice");
} else {
new_key = parse_key(field);
new_key_flag = true;
}
} else if (first == 'L') {
if (loud_flag) {
parse_error(field, 0, "Loudness specified twice");
} else {
loud = parse_loud(field);
}
loud_flag = true;
} else if (first == 'P') {
if (new_note_flag || new_pitch_flag) {
parse_error(field, 0, "Pitch specified twice");
} else {
new_pitch = parse_pitch(field);
new_pitch_flag = true;
}
} else if (first == 'U') {
if (dur_flag) {
parse_error(field, 0, "Dur specified twice");
} else {
dur = parse_dur(field, time);
dur_flag = true;
}
} else if (strchr("SIQHW", first)) {
if (dur_flag) {
parse_error(field, 0, "Dur specified twice");
} else {
// prepend 'U' to field, copy EOS too
memmove(field + 1, field, strlen(field) + 1);
field[0] = 'U';
dur = parse_dur(field, time);
dur_flag = true;
}
} else if (strchr("ABCDEFG", first)) {
if (new_note_flag || new_pitch_flag) {
parse_error(field, 0, "Pitch specified twice");
} else {
// prepend 'K' to field, copy EOS too
memmove(field + 1, field, strlen(field) + 1);
field[0] = 'K';
new_note = parse_key(field);
new_note_flag = true;
}
} else if (first == '-') {
Parameter parm;
if (parse_attribute(field, &parm)) { // enter attribute-value pair
attributes = new Parameters(attributes);
attributes->parm = parm;
parm.s = NULL; // protect string from deletion by destructor
}
} else {
parse_error(field, 0, "Unknown field");
}
if (error_flag) {
field[0] = 0; // exit the loop
} else {
line_parser.get_nonspace_quoted(field);
pk = line_parser.peek();
if (pk && !isspace(pk)) {
line_parser.get_nonspace_quoted(field + strlen(field));
}
}
}
// a case analysis:
// Key < 128 counts as both key and pitch
// A-G implies pitch AND key unless key given too
// K60 P60 -- both are specified, use 'em
// K60 P60 C4 -- overconstrained, an error
// K60 C4 -- overconstrained
// K60 -- OK, pitch is 60
// C4 P60 -- over constrained
// P60 -- OK, key is from before, pitch is 60
// C4 -- OK, key is 60, pitch is 60
// <nothing> -- OK, key and pitch from before
// K200 with P60 ok, pitch is 60
// K200 with neither P60 nor C4 uses
// pitch from before
// figure out what the key/instance is:
if (new_key_flag) { // it was directly specified
key = new_key;
if (key < 128 && new_note_flag) {
parse_error("", 0, "Pitch specified twice");
}
} else if (new_note_flag) { // "A"-"G" used
key = new_note;
}
if (new_pitch_flag) {
pitch = new_pitch;
} else if (key < 128) {
pitch = key;
}
// now we've acquired new parameters
// if (it is a note, then enter the note
if (valid) {
// change tempo or beat
process_attributes(attributes, time);
// if there's a duration or pitch, make a note:
if (new_pitch_flag || dur_flag || new_note_flag) {
new_key_flag = false;
new_pitch_flag = false;
Allegro_note_ptr note_ptr = new Allegro_note;
note_ptr->chan = voice;
note_ptr->time = time;
note_ptr->dur = dur;
note_ptr->key = key;
note_ptr->pitch = pitch;
note_ptr->loud = loud;
note_ptr->parameters = attributes;
seq.add_event(note_ptr); // sort later
} else {
int update_key = -1;
// key or pitch must appear explicitly; otherwise
// update applies to channel
if (new_key_flag || new_pitch_flag) {
update_key = key;
}
if (loud_flag) {
Allegro_update_ptr new_upd = new Allegro_update;
new_upd->chan = voice;
new_upd->time = time;
new_upd->key = update_key;
new_upd->parameter.set_attr(symbol_table.insert_string("loudr"));
new_upd->parameter.r = pitch;
seq.add_event(new_upd);
}
if (attributes) {
while (attributes) {
Allegro_update_ptr new_upd = new Allegro_update;
new_upd->chan = voice;
new_upd->time = time;
new_upd->key = update_key;
new_upd->parameter = attributes->parm;
seq.add_event(new_upd);
Parameters_ptr p = attributes;
attributes = attributes->next;
delete p;
}
}
}
if (next_flag) {
time = time + next;
} else if (dur_flag) {
time = time + dur;
}
}
readline();
}
//print "Finished reading score"
if (!error_flag) {
seq.convert_to_seconds(); // make sure format is correct
// seq.notes.sort('event_greater_than');
}
// print "parse returns error_flag", error_flag
return error_flag;
}
xmlResult parse_buffer(GNode *parent, gchar *text, guint length)
{
gchar *p;
gchar start_tag[512];
gchar tag_name[512];
gchar body[65536];
gchar *content;
gint content_length;
gint body_length;
GNode *node;
gboolean no_end_tag;
gchar *special_str;
g_assert(text != NULL);
#ifdef XML_TRACE
LOG(LOG_DEBUG, "IN : parse_buffer()");
#endif
body_length = 0;
p = text;
while((p - text) < length){
if(*p == '<'){
if(body_length != 0){
((NODE_DATA *)(parent->data))->content = encoded_to_special(body);
body[0] = '\0';
body_length = 0;
}
no_end_tag = FALSE;
get_start_tag(p, start_tag);
// <xxx/>の場合には対応するエンドタグがない
if(start_tag[strlen(start_tag) - 1] == '/'){
start_tag[strlen(start_tag) - 1] = '\0';
no_end_tag = TRUE;
}
get_tag_name(start_tag, tag_name);
// 宣言部分
if(start_tag[0] == '?'){
if(start_tag[strlen(start_tag) - 1] == '?'){
start_tag[strlen(start_tag) - 1] = '\0';
}
parse_declaration(parent, &start_tag[1]);
skip_start_tag(&p, tag_name);
continue;
}
node = xml_add_child(parent, tag_name, NULL);
parse_attribute(node, start_tag);
if(no_end_tag == FALSE){
get_content(p, tag_name, &content, &content_length);
parse_buffer(node, content, content_length);
skip_end_tag(&p, tag_name);
} else {
skip_start_tag(&p, tag_name);
}
} else if (*p == '\n') {
p++;
} else {
body[body_length] = *p;
body_length ++;
body[body_length] = '\0';
p++;
}
}
if(body_length != 0){
special_str = encoded_to_special(body);
((NODE_DATA *)(parent->data))->content =
iconv_convert(
((NODE_DATA *)(parent->data))->doc->encoding,
"UTF-8",
special_str);
g_free(special_str);
}
#ifdef XML_TRACE
LOG(LOG_DEBUG, "OUT : parse_buffer()");
#endif
return XML_OK;
}
#include "assert.h"
#include "stdlib.h"
#include "stdio.h"
#include "allegro.h"
#include "string.h"
#include "ctype.h"
//#include "memory.h"
#include "trace.h"
#include "strparse.h"
#ifndef EXPERIMENTAL_NOTE_TRACK
#include "allegrord.h"
#endif /* EXPERIMENTAL_NOTE_TRACK */
#define streql(s1, s2) (strcmp(s1, s2) == 0)
#define field_max 80
//Note that this is an #ifdef, not an #ifndef
#ifdef EXPERIMENTAL_NOTE_TRACK
class Alg_reader {
public:
FILE *file;
int line_no;
String_parse line_parser;
bool line_parser_flag;
char field[field_max];
bool error_flag;
Alg_seq_ptr seq;
double tsnum;
double tsden;
Alg_reader(FILE *a_file, Alg_seq_ptr new_seq);
void readline();
Alg_parameters_ptr process_attributes(Alg_parameters_ptr attributes, double time);
bool parse();
long parse_chan(char *field);
long parse_int(char *field);
int find_real_in(char *field, int n);
double parse_real(char *field);
void parse_error(char *field, long offset, char *message);
double parse_dur(char *field, double base);
double parse_after_dur(double dur, char *field, int n, double base);
double parse_loud(char *field);
long parse_key(char *field);
double parse_pitch(char *field);
long parse_after_key(int key, char *field, int n);
long find_int_in(char *field, int n);
bool parse_attribute(char *field, Alg_parameter_ptr parm);
bool parse_val(Alg_parameter_ptr param, char *s, int i);
bool check_type(char type_char, Alg_parameter_ptr param);
};
#endif /* EXPERIMENTAL_NOTE_TRACK */
void subseq(char *result, char *source, int from, int to)
{
memcpy(result, source + from, to - from);
result[to - from] = 0;
}
#ifndef EXPERIMENTAL_NOTE_TRACK
double Allegro_reader::parse_pitch(char *field)
#else /* EXPERIMENTAL_NOTE_TRACK */
double Alg_reader::parse_pitch(char *field)
#endif /* EXPERIMENTAL_NOTE_TRACK */
{
if (isdigit(field[1])) {
char real_string[80];
int last = find_real_in(field, 1);
subseq(real_string, field, 1, last);
return atof(real_string);
} else {
return (double) parse_key(field);
}
}
#ifndef EXPERIMENTAL_NOTE_TRACK
Allegro_reader::Allegro_reader(FILE *a_file)
{
file = a_file; // save the file
line_parser_flag = false;
line_no = 0;
seq = Seq();
tsnum = 4; // default time signature
tsden = 4;
}
#else /* EXPERIMENTAL_NOTE_TRACK */
// it is the responsibility of the caller to delete
// the seq
Alg_reader::Alg_reader(FILE *a_file, Alg_seq_ptr new_seq)
{
file = a_file; // save the file
line_parser_flag = false;
line_no = 0;
tsnum = 4; // default time signature
tsden = 4;
seq = new_seq;
}
#endif /* EXPERIMENTAL_NOTE_TRACK */
//Note that this is an #ifdef, not an #ifndef
#ifdef EXPERIMENTAL_NOTE_TRACK
Alg_seq_ptr alg_read(FILE *file, Alg_seq_ptr new_seq)
// read a sequence from allegro file
{
if (!new_seq) new_seq = new Alg_seq();
Alg_reader alg_reader(file, new_seq);
alg_reader.parse();
return alg_reader.seq;
}
#endif /* EXPERIMENTAL_NOTE_TRACK */
#ifndef EXPERIMENTAL_NOTE_TRACK
void Allegro_reader::readline()
#else /* EXPERIMENTAL_NOTE_TRACK */
void Alg_reader::readline()
#endif /* EXPERIMENTAL_NOTE_TRACK */
{
char line[256];
char *line_flag = fgets(line, 256, file);
line_parser_flag = false;
if (line_flag) {
line_parser.init(line);
line_parser_flag = true;
error_flag = false;
}
}
#ifndef EXPERIMENTAL_NOTE_TRACK
void Allegro_reader::process_attributes(Parameters_ptr attributes, double time)
{
// print "process_attributes:", attributes
bool ts_flag;
if (attributes) {
Parameters_ptr a;
if (a = Parameters::remove_key(&attributes, "tempor")) {
double tempo = a->parm.r;
seq.insert_tempo(tempo, seq.map.time_to_beat(time));
}
if (a = Parameters::remove_key(&attributes, "beatr")) {
double beat = a->parm.r;
seq.insert_beat(time, beat);
}
if (a = Parameters::remove_key(&attributes, "tsnumr")) {
tsnum = a->parm.r;
ts_flag = true;
}
if (a = Parameters::remove_key(&attributes, "tsdenr")) {
tsden = a->parm.r;
ts_flag = true;
}
if (ts_flag) {
seq.set_time_sig(seq.map.time_to_beat(time), tsnum, tsden);
}
}
}
#else /* EXPERIMENTAL_NOTE_TRACK */
Alg_parameters_ptr Alg_reader::process_attributes(
Alg_parameters_ptr attributes, double time)
{
// print "process_attributes:", attributes
bool ts_flag = false;
if (attributes) {
Alg_parameters_ptr a;
bool in_seconds = seq->get_units_are_seconds();
if (a = Alg_parameters::remove_key(&attributes, "tempor")) {
double tempo = a->parm.r;
seq->insert_tempo(tempo, seq->get_time_map()->time_to_beat(time));
}
if (a = Alg_parameters::remove_key(&attributes, "beatr")) {
double beat = a->parm.r;
seq->insert_beat(time, beat);
}
if (a = Alg_parameters::remove_key(&attributes, "timesig_numr")) {
tsnum = a->parm.r;
ts_flag = true;
}
if (a = Alg_parameters::remove_key(&attributes, "timesig_denr")) {
tsden = a->parm.r;
ts_flag = true;
}
if (ts_flag) {
seq->set_time_sig(seq->get_time_map()->time_to_beat(time),
tsnum, tsden);
}
if (in_seconds) seq->convert_to_seconds();
}
return attributes; // in case it was modified
}
#endif /* EXPERIMENTAL_NOTE_TRACK */
#ifndef EXPERIMENTAL_NOTE_TRACK
bool Allegro_reader::parse()
{
int voice = 0;
int key = 60;
double loud = 100.0;
double pitch = 60.0;
double dur = 1.0;
double time = 0.0;
readline();
bool valid = false; // ignore blank lines
while (line_parser_flag) {
bool time_flag = false;
bool next_flag = false;
double next;
bool voice_flag = false;
bool loud_flag = false;
bool dur_flag = false;
bool new_pitch_flag = false; // "P" syntax
double new_pitch = 0.0;
bool new_key_flag = false; // "K" syntax
int new_key = 0;
bool new_note_flag = false; // "A"-"G" syntax
int new_note = 0;
Parameters_ptr attributes = NULL;
line_parser.get_nonspace_quoted(field);
char pk = line_parser.peek();
if (pk && !isspace(pk)) {
line_parser.get_nonspace_quoted(field + strlen(field));
}
while (field[0]) {
// print "field", "|";field;"|", "|";line_parser.string;"|", line_parser.pos
char first = toupper(field[0]);
if (strchr("ABCDEFGKLPUSIQHW-", first)) {
valid = true; // it's a note or event
}
if (first == 'V') {
if (voice_flag) {
parse_error(field, 0, "Voice specified twice");
} else {
voice = parse_int(field);
}
voice_flag = true;
} else if (first == 'T') {
if (time_flag) {
parse_error(field, 0, "Time specified twice");
} else {
time = parse_dur(field, 0.0);
}
time_flag = true;
} else if (first == 'N') {
if (next_flag) {
parse_error(field, 0, "Next specified twice");
} else {
next = parse_dur(field, time);
}
next_flag = true;
} else if (first == 'K') {
if (new_key_flag) {
parse_error(field, 0, "Key specified twice");
} else {
new_key = parse_key(field);
new_key_flag = true;
}
} else if (first == 'L') {
if (loud_flag) {
parse_error(field, 0, "Loudness specified twice");
} else {
loud = parse_loud(field);
}
loud_flag = true;
} else if (first == 'P') {
if (new_note_flag || new_pitch_flag) {
parse_error(field, 0, "Pitch specified twice");
} else {
new_pitch = parse_pitch(field);
new_pitch_flag = true;
}
} else if (first == 'U') {
if (dur_flag) {
parse_error(field, 0, "Dur specified twice");
} else {
dur = parse_dur(field, time);
dur_flag = true;
}
} else if (strchr("SIQHW", first)) {
if (dur_flag) {
parse_error(field, 0, "Dur specified twice");
} else {
// prepend 'U' to field, copy EOS too
memmove(field + 1, field, strlen(field) + 1);
field[0] = 'U';
dur = parse_dur(field, time);
dur_flag = true;
}
} else if (strchr("ABCDEFG", first)) {
if (new_note_flag || new_pitch_flag) {
parse_error(field, 0, "Pitch specified twice");
} else {
// prepend 'K' to field, copy EOS too
memmove(field + 1, field, strlen(field) + 1);
field[0] = 'K';
new_note = parse_key(field);
new_note_flag = true;
}
} else if (first == '-') {
Parameter parm;
if (parse_attribute(field, &parm)) { // enter attribute-value pair
attributes = new Parameters(attributes);
attributes->parm = parm;
parm.s = NULL; // protect string from deletion by destructor
}
} else {
parse_error(field, 0, "Unknown field");
}
if (error_flag) {
field[0] = 0; // exit the loop
} else {
line_parser.get_nonspace_quoted(field);
pk = line_parser.peek();
if (pk && !isspace(pk)) {
line_parser.get_nonspace_quoted(field + strlen(field));
}
}
}
// a case analysis:
// Key < 128 counts as both key and pitch
// A-G implies pitch AND key unless key given too
// K60 P60 -- both are specified, use 'em
// K60 P60 C4 -- overconstrained, an error
// K60 C4 -- overconstrained
// K60 -- OK, pitch is 60
// C4 P60 -- over constrained
// P60 -- OK, key is from before, pitch is 60
// C4 -- OK, key is 60, pitch is 60
// <nothing> -- OK, key and pitch from before
// K200 with P60 ok, pitch is 60
// K200 with neither P60 nor C4 uses
// pitch from before
// figure out what the key/instance is:
if (new_key_flag) { // it was directly specified
key = new_key;
if (key < 128 && new_note_flag) {
parse_error("", 0, "Pitch specified twice");
}
} else if (new_note_flag) { // "A"-"G" used
key = new_note;
}
if (new_pitch_flag) {
pitch = new_pitch;
} else if (key < 128) {
pitch = key;
}
// now we've acquired new parameters
// if (it is a note, then enter the note
if (valid) {
// change tempo or beat
process_attributes(attributes, time);
// if there's a duration or pitch, make a note:
if (new_pitch_flag || dur_flag || new_note_flag) {
new_key_flag = false;
new_pitch_flag = false;
Allegro_note_ptr note_ptr = new Allegro_note;
note_ptr->chan = voice;
note_ptr->time = time;
note_ptr->dur = dur;
note_ptr->key = key;
note_ptr->pitch = pitch;
note_ptr->loud = loud;
note_ptr->parameters = attributes;
seq.add_event(note_ptr); // sort later
} else {
int update_key = -1;
// key or pitch must appear explicitly; otherwise
// update applies to channel
if (new_key_flag || new_pitch_flag) {
update_key = key;
}
if (loud_flag) {
Allegro_update_ptr new_upd = new Allegro_update;
new_upd->chan = voice;
new_upd->time = time;
new_upd->key = update_key;
new_upd->parameter.set_attr(symbol_table.insert_string("loudr"));
new_upd->parameter.r = pitch;
seq.add_event(new_upd);
}
if (attributes) {
while (attributes) {
Allegro_update_ptr new_upd = new Allegro_update;
new_upd->chan = voice;
new_upd->time = time;
new_upd->key = update_key;
new_upd->parameter = attributes->parm;
seq.add_event(new_upd);
Parameters_ptr p = attributes;
attributes = attributes->next;
delete p;
}
}
}
if (next_flag) {
time = time + next;
} else if (dur_flag) {
time = time + dur;
}
}
readline();
}
//print "Finished reading score"
if (!error_flag) {
seq.convert_to_seconds(); // make sure format is correct
// seq.notes.sort('event_greater_than');
}
// print "parse returns error_flag", error_flag
return error_flag;
}
#else /* EXPERIMENTAL_NOTE_TRACK */
bool Alg_reader::parse()
{
int voice = 0;
int key = 60;
double loud = 100.0;
double pitch = 60.0;
double dur = 1.0;
double time = 0.0;
int track_num = 0;
seq->convert_to_seconds();
//seq->set_real_dur(0.0); // just in case it's not initialized already
readline();
bool valid = false; // ignore blank lines
while (line_parser_flag) {
bool time_flag = false;
bool next_flag = false;
double next;
bool voice_flag = false;
bool loud_flag = false;
bool dur_flag = false;
bool new_pitch_flag = false; // "P" syntax
double new_pitch = 0.0;
bool new_key_flag = false; // "K" syntax
int new_key = 0;
bool new_note_flag = false; // "A"-"G" syntax
int new_note = 0;
Alg_parameters_ptr attributes = NULL;
if (line_parser.peek() == '#') {
// look for #track
line_parser.get_nonspace_quoted(field);
if (streql(field, "#track")) {
line_parser.get_nonspace_quoted(field); // number
track_num = parse_int(field - 1);
seq->add_track(track_num);
}
// maybe we have a comment
} else {
// we must have a track to insert into
if (seq->tracks() == 0) seq->add_track(0);
line_parser.get_nonspace_quoted(field);
char pk = line_parser.peek();
// attributes are parsed as two adjacent nonspace_quoted tokens
// so we have to conditionally call get_nonspace_quoted() again
if (pk && !isspace(pk)) {
line_parser.get_nonspace_quoted(field + strlen(field));
}
while (field[0]) {
char first = toupper(field[0]);
if (strchr("ABCDEFGKLPUSIQHW-", first)) {
valid = true; // it's a note or event
}
if (first == 'V') {
if (voice_flag) {
parse_error(field, 0, "Voice specified twice");
} else {
voice = parse_chan(field);
}
voice_flag = true;
} else if (first == 'T') {
if (time_flag) {
parse_error(field, 0, "Time specified twice");
} else {
time = parse_dur(field, 0.0);
}
time_flag = true;
} else if (first == 'N') {
if (next_flag) {
parse_error(field, 0, "Next specified twice");
} else {
next = parse_dur(field, time);
}
next_flag = true;
} else if (first == 'K') {
if (new_key_flag) {
parse_error(field, 0, "Key specified twice");
} else {
new_key = parse_key(field);
new_key_flag = true;
}
} else if (first == 'L') {
if (loud_flag) {
parse_error(field, 0, "Loudness specified twice");
} else {
loud = parse_loud(field);
}
loud_flag = true;
} else if (first == 'P') {
if (new_note_flag || new_pitch_flag) {
parse_error(field, 0, "Pitch specified twice");
} else {
new_pitch = parse_pitch(field);
new_pitch_flag = true;
}
} else if (first == 'U') {
if (dur_flag) {
parse_error(field, 0, "Dur specified twice");
} else {
dur = parse_dur(field, time);
dur_flag = true;
}
} else if (strchr("SIQHW", first)) {
if (dur_flag) {
parse_error(field, 0, "Dur specified twice");
} else {
// prepend 'U' to field, copy EOS too
memmove(field + 1, field, strlen(field) + 1);
field[0] = 'U';
dur = parse_dur(field, time);
dur_flag = true;
}
} else if (strchr("ABCDEFG", first)) {
if (new_note_flag || new_pitch_flag) {
parse_error(field, 0, "Pitch specified twice");
} else {
// prepend 'K' to field, copy EOS too
memmove(field + 1, field, strlen(field) + 1);
field[0] = 'K';
new_note = parse_key(field);
new_note_flag = true;
}
} else if (first == '-') {
Alg_parameter parm;
if (parse_attribute(field, &parm)) { // enter attribute-value pair
attributes = new Alg_parameters(attributes);
attributes->parm = parm;
parm.s = NULL; // protect string from deletion by destructor
}
} else {
parse_error(field, 0, "Unknown field");
}
if (error_flag) {
field[0] = 0; // exit the loop
} else {
line_parser.get_nonspace_quoted(field);
pk = line_parser.peek();
// attributes are parsed as two adjacent nonspace_quoted
// tokens so we have to conditionally call
// get_nonspace_quoted() again
if (pk && !isspace(pk)) {
line_parser.get_nonspace_quoted(field + strlen(field));
}
}
}
// a case analysis:
// Key < 128 counts as both key and pitch
// A-G implies pitch AND key unless key given too
// K60 P60 -- both are specified, use 'em
// K60 P60 C4 -- overconstrained, an error
// K60 C4 -- overconstrained
// K60 -- OK, pitch is 60
// C4 P60 -- over constrained
// P60 -- OK, key is from before, pitch is 60
// C4 -- OK, key is 60, pitch is 60
// <nothing> -- OK, key and pitch from before
// K200 with P60 ok, pitch is 60
// K200 with neither P60 nor C4 uses
// pitch from before
// figure out what the key/instance is:
if (new_key_flag) { // it was directly specified
key = new_key;
if (key < 128 && new_note_flag) {
parse_error("", 0, "Pitch specified twice");
}
} else if (new_note_flag) { // "A"-"G" used
key = new_note;
}
if (new_pitch_flag) {
pitch = new_pitch;
} else if (key < 128) {
pitch = key;
}
// now we've acquired new parameters
// if (it is a note, then enter the note
if (valid) {
// change tempo or beat
attributes = process_attributes(attributes, time);
// if there's a duration or pitch, make a note:
if (new_pitch_flag || dur_flag || new_note_flag) {
new_key_flag = false;
new_pitch_flag = false;
Alg_note_ptr note_ptr = new Alg_note;
note_ptr->chan = voice;
note_ptr->time = time;
note_ptr->dur = dur;
note_ptr->set_identifier(key);
note_ptr->pitch = pitch;
note_ptr->loud = loud;
note_ptr->parameters = attributes;
seq->add_event(note_ptr, track_num); // sort later
if (seq->get_real_dur() < (time + dur)) seq->set_real_dur(time + dur);
} else {
int update_key = -1;
// key or pitch must appear explicitly; otherwise
// update applies to channel
if (new_key_flag || new_pitch_flag) {
update_key = key;
}
if (loud_flag) {
Alg_update_ptr new_upd = new Alg_update;
new_upd->chan = voice;
new_upd->time = time;
new_upd->set_identifier(update_key);
new_upd->parameter.set_attr(symbol_table.insert_string("loudr"));
new_upd->parameter.r = pitch;
seq->add_event(new_upd, track_num);
if (seq->get_real_dur() < time) seq->set_real_dur(time);
}
if (attributes) {
while (attributes) {
Alg_update_ptr new_upd = new Alg_update;
new_upd->chan = voice;
new_upd->time = time;
new_upd->set_identifier(update_key);
new_upd->parameter = attributes->parm;
seq->add_event(new_upd, track_num);
Alg_parameters_ptr p = attributes;
attributes = attributes->next;
p->parm.s = NULL; // so we don't delete the string
delete p;
}
}
}
if (next_flag) {
time = time + next;
} else if (dur_flag) {
time = time + dur;
}
}
}
readline();
}
//print "Finished reading score"
if (!error_flag) {
seq->convert_to_seconds(); // make sure format is correct
// seq->notes.sort('event_greater_than');
}
// real_dur is valid, translate to beat_dur
seq->set_beat_dur((seq->get_time_map())->time_to_beat(seq->get_real_dur()));
// print "parse returns error_flag", error_flag
return error_flag;
}
static void parse_schema_decl(fb_parser_t *P)
{
switch(P->token->id) {
case tok_kw_namespace:
next(P);
parse_namespace(P);
break;
case tok_kw_file_extension:
next(P);
parse_file_extension(P, &P->schema.file_extension);
break;
case tok_kw_file_identifier:
next(P);
parse_file_identifier(P, &P->schema.file_identifier);
break;
case tok_kw_root_type:
next(P);
parse_root_type(P, &P->schema.root_type);
break;
case tok_kw_attribute:
next(P);
parse_attribute(P, fb_add_attribute(P));
break;
case tok_kw_struct:
next(P);
parse_compound_type(P, fb_add_struct(P), tok_kw_struct);
break;
case tok_kw_table:
next(P);
parse_compound_type(P, fb_add_table(P), tok_kw_table);
break;
case tok_kw_rpc_service:
next(P);
parse_compound_type(P, fb_add_rpc_service(P), tok_kw_rpc_service);
break;
case tok_kw_enum:
next(P);
parse_enum_decl(P, fb_add_enum(P));
break;
case tok_kw_union:
next(P);
parse_union_decl(P, fb_add_union(P));
break;
case tok_kw_include:
error_tok(P, P->token, "include statements must be placed first in the schema");
break;
case '{':
error_tok(P, P->token, "JSON objects in schema file is not supported - but a schema specific JSON parser can be generated");
break;
case LEX_TOK_CTRL:
error_tok_as_string(P, P->token, "unexpected control character in schema definition", "?", 1);
break;
case LEX_TOK_COMMENT_CTRL:
if (lex_isblank(P->token->text[0])) {
/* This also strips tabs in doc comments. */
next(P);
break;
}
error_tok_as_string(P, P->token, "unexpected control character in comment", "?", 1);
break;
case LEX_TOK_COMMENT_UNTERMINATED:
error_tok_as_string(P, P->token, "unterminated comment", "<eof>", 5);
break;
default:
error_tok(P, P->token, "unexpected token in schema definition");
break;
}
}
/**
* parse_options - Read and validate the programs command line
*
* Read the command line, verify the syntax and parse the options.
* This function is very long, but quite simple.
*
* Return: 1 Success
* 0 Error, one or more problems
*/
static int parse_options(int argc, char **argv)
{
static const char *sopt = "-a:fh?i:n:qVvr";
static const struct option lopt[] = {
{ "attribute", required_argument, NULL, 'a' },
{ "attribute-name", required_argument, NULL, 'n' },
{ "force", no_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
{ "inode", required_argument, NULL, 'i' },
{ "quiet", no_argument, NULL, 'q' },
{ "version", no_argument, NULL, 'V' },
{ "verbose", no_argument, NULL, 'v' },
{ "raw", no_argument, NULL, 'r' },
{ NULL, 0, NULL, 0 }
};
int c = -1;
int err = 0;
int ver = 0;
int help = 0;
int levels = 0;
ATTR_TYPES attr = AT_UNUSED;
opterr = 0; /* We'll handle the errors, thank you. */
opts.inode = -1;
opts.attr = cpu_to_le32(-1);
opts.attr_name = NULL;
opts.attr_name_len = 0;
while ((c = getopt_long(argc, argv, sopt, lopt, NULL)) != -1) {
switch (c) {
case 1: /* A non-option argument */
if (!opts.device) {
opts.device = argv[optind - 1];
} else if (!opts.file) {
opts.file = argv[optind - 1];
} else {
ntfs_log_error("You must specify exactly one "
"file.\n");
err++;
}
break;
case 'a':
if (opts.attr != cpu_to_le32(-1)) {
ntfs_log_error("You must specify exactly one "
"attribute.\n");
} else if (parse_attribute(optarg, &attr) > 0) {
opts.attr = attr;
break;
} else {
ntfs_log_error("Couldn't parse attribute.\n");
}
err++;
break;
case 'f':
opts.force++;
break;
case 'h':
case '?':
if (strncmp (argv[optind-1], "--log-", 6) == 0) {
if (!ntfs_log_parse_option (argv[optind-1]))
err++;
break;
}
help++;
break;
case 'i':
if (opts.inode != -1)
ntfs_log_error("You must specify exactly one inode.\n");
else if (utils_parse_size(optarg, &opts.inode, FALSE))
break;
else
ntfs_log_error("Couldn't parse inode number.\n");
err++;
break;
case 'n':
opts.attr_name_len = ntfs_mbstoucs(optarg,
&opts.attr_name);
if (opts.attr_name_len < 0) {
ntfs_log_perror("Invalid attribute name '%s'",
optarg);
usage();
}
case 'q':
opts.quiet++;
ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
break;
case 'V':
ver++;
break;
case 'v':
opts.verbose++;
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
break;
case 'r':
opts.raw = TRUE;
break;
default:
ntfs_log_error("Unknown option '%s'.\n", argv[optind-1]);
err++;
break;
}
}
/* Make sure we're in sync with the log levels */
levels = ntfs_log_get_levels();
if (levels & NTFS_LOG_LEVEL_VERBOSE)
opts.verbose++;
if (!(levels & NTFS_LOG_LEVEL_QUIET))
opts.quiet++;
if (help || ver) {
opts.quiet = 0;
} else {
if (opts.device == NULL) {
ntfs_log_error("You must specify a device.\n");
err++;
} else if (opts.file == NULL && opts.inode == -1) {
ntfs_log_error("You must specify a file or inode "
"with the -i option.\n");
err++;
} else if (opts.file != NULL && opts.inode != -1) {
ntfs_log_error("You can't specify both a file and inode.\n");
err++;
}
if (opts.quiet && opts.verbose) {
ntfs_log_error("You may not use --quiet and --verbose at the "
"same time.\n");
err++;
}
}
if (ver)
version();
if (help || err)
usage();
return (!err && !help && !ver);
}
void
parse_args( int argc, char** argv )
{
int i;
GSList* alist;
GSList* ap;
int n;
alist = 0;
for( i = 1; i < argc; i++ )
if( !strcmp(argv[i], "-h") || !strcmp(argv[i], "--help") )
{
printf("%s", usage);
exit(0);
}
else if( !strcmp(argv[i], "-v") || !strcmp(argv[i], "--version") )
{
printf(KPABE_VERSION, "-enc");
exit(0);
}
else if( !strcmp(argv[i], "-k") || !strcmp(argv[i], "--keep-input-file") )
{
keep = 1;
}
else if( !strcmp(argv[i], "-o") || !strcmp(argv[i], "--output") )
{
if( ++i >= argc )
die(usage);
else
out_file = argv[i];
}
else if( !strcmp(argv[i], "-d") || !strcmp(argv[i], "--deterministic") )
{
pbc_random_set_deterministic(0);
}
else if( !pub_file )
{
pub_file = argv[i];
}
else if( !in_file )
{
in_file = argv[i];
}
else
{
parse_attribute(&alist, argv[i]);
}
if( !pub_file || !in_file || !alist )
die(usage);
if( !out_file )
out_file = g_strdup_printf("%s.kpabe", in_file);
alist = g_slist_sort(alist, comp_string);
n = g_slist_length(alist);
attrs = malloc((n + 1) * sizeof(char*));
i = 0;
for( ap = alist; ap; ap = ap->next )
attrs[i++] = ap->data;
attrs[i] = 0;
}
