diff options
Diffstat (limited to 'components/rtgui_win/common/rtgui_xml.c')
| -rw-r--r-- | components/rtgui_win/common/rtgui_xml.c | 291 |
1 files changed, 291 insertions, 0 deletions
diff --git a/components/rtgui_win/common/rtgui_xml.c b/components/rtgui_win/common/rtgui_xml.c new file mode 100644 index 0000000000..9289b3404c --- /dev/null +++ b/components/rtgui_win/common/rtgui_xml.c @@ -0,0 +1,291 @@ +#include <rtgui/rtgui_xml.h> +#include <rtgui/rtgui_system.h>
+ +/* Internal states that the parser can be in at any given time. */ +enum { + STAT_START = 0, /* starting base state, default state */ + STAT_TEXT, /* text state */ + STAT_START_TAG, /* start tag state */ + STAT_START_TAGNAME, /* start tagname state */ + STAT_START_TAGNAME_END, /* start tagname ending state */ + STAT_END_TAG, /* end tag state */ + STAT_END_TAGNAME, /* end tag tagname state */ + STAT_END_TAGNAME_END, /* end tag tagname ending */ + STAT_EMPTY_TAG, /* empty tag state */ + STAT_SPACE, /* linear whitespace state */ + STAT_ATTR_NAME, /* attribute name state */ + STAT_ATTR_NAME_END, /* attribute name ending state */ + STAT_ATTR_VAL, /* attribute value starting state */ + STAT_ATTR_VAL2, /* attribute value state */ + STAT_ERROR /* error state */ +}; + +/* character classes that we will match against; This could be expanded if + need be, however, we are aiming for simple. */ +enum { + CLASS_TYPE_NONE = 0, /* matches nothing, a base state */ + CLASS_TYPE_LEFT_ANGLE, /* matches start tag '<' */ + CLASS_TYPE_SLASH, /* matches forward slash */ + CLASS_TYPE_RIGHT_ANGLE, /* matches end tag '>' */ + CLASS_TYPE_EQUALS, /* matches equals sign */ + CLASS_TYPE_QUOTE, /* matches double-quotes */ + CLASS_TYPE_LETTERS, /* matches a-zA-Z letters and digits 0-9 */ + CLASS_TYPE_SPACE, /* matches whitespace */ + CLASS_TYPE_ANY /* matches any ASCII character; will match all + above classes */ +}; + +/* xml state transition table */ +struct rtgui_xml_state +{ + rt_uint8_t state; + rt_uint8_t class_type; + rt_uint8_t next_state; + rt_uint8_t event; +}; + +/* Note: States must be grouped in match order AND grouped together! */ +static const struct rtgui_xml_state RTGUI_XML_STATES [] = { + /* [0-2] starting state, which also serves as the default state in case + of error */ + { STAT_START, CLASS_TYPE_SPACE, STAT_SPACE, EVENT_NONE }, + { STAT_START, CLASS_TYPE_LEFT_ANGLE, STAT_START_TAG, EVENT_NONE }, + { STAT_START, CLASS_TYPE_ANY, STAT_TEXT, EVENT_COPY }, + + /* [3-5] space state handles linear white space */ + { STAT_SPACE, CLASS_TYPE_SPACE, STAT_SPACE, EVENT_NONE }, + { STAT_SPACE, CLASS_TYPE_LEFT_ANGLE, STAT_START_TAG, EVENT_TEXT }, + { STAT_SPACE, CLASS_TYPE_ANY, STAT_TEXT, EVENT_COPY }, + + /* [6-8] handle start tag */ + { STAT_START_TAG, CLASS_TYPE_LETTERS, STAT_START_TAGNAME, EVENT_COPY }, + { STAT_START_TAG, CLASS_TYPE_SLASH, STAT_END_TAG, EVENT_COPY }, + /* below added since some individuals get a little carried away with + spacing around tag names, e.g. < tag > */ + { STAT_START_TAG, CLASS_TYPE_SPACE, STAT_START_TAG, EVENT_NONE }, + + /* [9-12] handle start tag name */ + { STAT_START_TAGNAME, CLASS_TYPE_LETTERS, STAT_START_TAGNAME, EVENT_NONE }, + { STAT_START_TAGNAME, CLASS_TYPE_SPACE, STAT_START_TAGNAME_END, EVENT_START }, + /* below added for tags without any space between tag and ending + slash, e.g., <br/> */ + { STAT_START_TAGNAME, CLASS_TYPE_SLASH, STAT_EMPTY_TAG, EVENT_END }, + { STAT_START_TAGNAME, CLASS_TYPE_RIGHT_ANGLE, STAT_START, EVENT_START }, + + /* [13-16] handle start tag name end */ + { STAT_START_TAGNAME_END, CLASS_TYPE_LETTERS, STAT_ATTR_NAME, EVENT_COPY }, + /* below added to handle additional space in between attribute value + pairs in start tags, e.g., <tag attr="2" attr2="test" > */ + { STAT_START_TAGNAME_END, CLASS_TYPE_SPACE, STAT_START_TAGNAME_END, EVENT_NONE }, + { STAT_START_TAGNAME_END, CLASS_TYPE_RIGHT_ANGLE, STAT_START, EVENT_START }, + /* below supports tags that are self-closing, e.g., <br /> */ + { STAT_START_TAGNAME_END, CLASS_TYPE_SLASH, STAT_EMPTY_TAG, EVENT_COPY }, + + /* [17] handle empty tags, e.g., <br /> */ + { STAT_EMPTY_TAG, CLASS_TYPE_RIGHT_ANGLE, STAT_START, EVENT_END }, + + /* [18] handle end tag, e.g., <tag /> */ + { STAT_END_TAG, CLASS_TYPE_LETTERS, STAT_END_TAGNAME, EVENT_NONE }, + + /* [19-21] handle end tag name */ + { STAT_END_TAGNAME, CLASS_TYPE_LETTERS, STAT_END_TAGNAME, EVENT_NONE }, + { STAT_END_TAGNAME, CLASS_TYPE_RIGHT_ANGLE, STAT_START, EVENT_END }, + /* below adds support for spaces at the end of an end tag (before + closing bracket) */ + { STAT_END_TAGNAME, CLASS_TYPE_SPACE, STAT_END_TAGNAME_END, EVENT_END }, + + /* [22] handle ending of end tag name */ + { STAT_END_TAGNAME_END, CLASS_TYPE_SPACE, STAT_END_TAGNAME_END, EVENT_NONE }, + { STAT_END_TAGNAME_END, CLASS_TYPE_RIGHT_ANGLE,STAT_START, EVENT_NONE }, + + /* [23-25] handle text */ + { STAT_TEXT, CLASS_TYPE_SPACE, STAT_SPACE, EVENT_NONE }, + { STAT_TEXT, CLASS_TYPE_LEFT_ANGLE, STAT_START_TAG, EVENT_TEXT }, + { STAT_TEXT, CLASS_TYPE_ANY, STAT_TEXT, EVENT_NONE }, + + /* [26-30] handle attribute names */ + { STAT_ATTR_NAME, CLASS_TYPE_LETTERS, STAT_ATTR_NAME, EVENT_COPY }, + /* below add support for space before the equals sign, e.g, <tag + attr ="2"> */ + { STAT_ATTR_NAME, CLASS_TYPE_SPACE, STAT_ATTR_NAME_END, EVENT_NAME }, + { STAT_ATTR_NAME, CLASS_TYPE_EQUALS, STAT_ATTR_VAL, EVENT_NAME }, + + /* [31-33] attribute name end */ + { STAT_ATTR_NAME_END, CLASS_TYPE_SPACE, STAT_ATTR_NAME_END, EVENT_NONE }, + { STAT_ATTR_NAME_END, CLASS_TYPE_LETTERS, STAT_ATTR_NAME, EVENT_COPY }, + { STAT_ATTR_NAME_END, CLASS_TYPE_EQUALS, STAT_ATTR_VAL, EVENT_NONE }, + + /* [34-35] handle attribute values, initial quote and spaces */ + { STAT_ATTR_VAL, CLASS_TYPE_QUOTE, STAT_ATTR_VAL2, EVENT_NONE }, + /* below handles initial spaces before quoted attribute value */ + { STAT_ATTR_VAL, CLASS_TYPE_SPACE, STAT_ATTR_VAL, EVENT_NONE }, + + /* [36-37] handle actual attribute values */ + { STAT_ATTR_VAL2, CLASS_TYPE_QUOTE, STAT_START_TAGNAME_END, EVENT_VAL }, + { STAT_ATTR_VAL2, CLASS_TYPE_LETTERS, STAT_ATTR_VAL2, EVENT_COPY }, + { STAT_ATTR_VAL2, CLASS_TYPE_SLASH, STAT_ATTR_VAL2, EVENT_NONE }, + + /* End of table marker */ + { STAT_ERROR, CLASS_TYPE_NONE, STAT_ERROR, EVENT_NONE } +}; + +struct rtgui_xml +{ + /* event handler */ + XML_handle handle; + void* user; + + char* buffer; /* xml buffer */ + rt_size_t buffer_size; /* buffer size */ + rt_size_t position; /* current position in buffer */ + rt_uint16_t state, event; /* current state and event */ + + rt_bool_t copy; /* copy text into tmp buffer */ + rt_bool_t halt; /* halt parsing of document */ +}; + +rtgui_xml_t* rtgui_xml_create(rt_size_t buffer_size, XML_handle handle, + void* user) +{ + rtgui_xml_t* xml = (rtgui_xml_t*) rt_malloc(sizeof(struct rtgui_xml)); + rt_memset(xml, 0, sizeof(rtgui_xml_t)); + + xml->event_handler = handle; + xml->user = user; + + /* create buffer */ + xml->buffer_size = buffer_size; + xml->buffer = (char*)rt_malloc(xml->buffer_size); + return xml; +} + +void rtgui_xml_destroy(rtgui_xml_t* xml) +{ + if(xml) + { + rt_free(xml->buffer); + rt_free(xml); + } +} + +const char* rtgui_xml_event_str(rt_uint8_t event) +{ + switch(event) + { + case EVENT_START: + return "start tag"; + case EVENT_END: + return "end tag"; + case EVENT_TEXT: + return "text"; + case EVENT_NAME: + return "attr name"; + case EVENT_VAL: + return "attr val"; + case EVENT_END_DOC: + return "end document"; + default: + break; + } + return "err"; +} + +int rtgui_xml_parse(rtgui_xml_t* xml, const char* buf, rt_size_t len) +{ + int i, j, c, match; + +#define is_space(ch) \ + ((rt_uint32_t)(ch - 9) < 5u || ch == ' ') +#define is_alpha(ch) \ + ((rt_uint32_t)((ch | 0x20) - 'a') < 26u) +#define is_digit(ch) \ + ((rt_uint32_t)(ch - '0') < 10u) +#define is_letters(ch) \ + (is_alpha(ch) || is_digit(ch) || (ch == '.')) + + for(i=0; i<len; i++) + { + if(xml->halt) break; + + c = buf[i] & 0xff; + + /* search in state table */ + for(j=0, match = 0; RTGUI_XML_STATES[j].state != STAT_ERROR; j++) + { + if(RTGUI_XML_STATES[j].state != xml->state) + continue; + + switch(RTGUI_XML_STATES[j].class_type) + { + case CLASS_TYPE_LETTERS: + match = is_letters(c); + break; + case CLASS_TYPE_LEFT_ANGLE: + match = (c == '<'); + break; + case CLASS_TYPE_SLASH: + match = (c == '/'); + break; + case CLASS_TYPE_RIGHT_ANGLE: + match = (c == '>'); + break; + case CLASS_TYPE_EQUALS: + match = (c == '='); + break; + case CLASS_TYPE_QUOTE: + match = (c == '"'); + break; + case CLASS_TYPE_SPACE: + match = is_space(c); + break; + case CLASS_TYPE_ANY: + match = 1; + break; + default: + break; + } + + /* we matched a character class */ + if(match) + { + if(RTGUI_XML_STATES[j].event == EVENT_COPY) + { + xml->copy = TRUE; + } + else if(RTGUI_XML_STATES[j].event != EVENT_NONE) + { + if(xml->copy == TRUE) + { + /* basically we are guaranteed never to have an event of + type EVENT_COPY or EVENT_NONE here. */ + xml->event = RTGUI_XML_STATES[j].event; + xml->buffer[xml->position] = 0; /* make a string */ + + if(!xml->event_handler(RTGUI_XML_STATES[j].event, + xml->buffer, xml->position , + xml->user)) + { + xml->halt = 1; /* stop parsing from here out */ + } + xml->position = 0; + xml->copy = FALSE; + } + } + if(xml->copy == TRUE) + { + /* check to see if we have room; one less for trailing + nul */ + if(xml->position < xml->buffer_size-1) + { + xml->buffer[xml->position] = buf[i]; + xml->position++; + } + } + xml->state = RTGUI_XML_STATES[j].next_state; /* change state */ + break; /* break out of loop though state search */ + } + } + } + + return !xml->halt; +} |