void Builder::computeOffsets() { int32_t i; Offset off = sizeof(header); if (debug>0) { printf("header \t offset=%4d size=%5d\n", 0, off); } // PropertyAliases must have no v-table and must be // padded (if necessary) to the next 32-bit boundary. //U_ASSERT(offsetof(PropertyAliases, enumToName_offset) == 0); // see above U_ASSERT(sizeof(header) % sizeof(int32_t) == 0); #define COMPUTE_OFFSET(foo) COMPUTE_OFFSET2(foo,int32_t) #define COMPUTE_OFFSET2(foo,type) \ if (debug>0)\ printf(#foo "\t offset=%4d size=%5d\n", off, (int)foo##_size);\ foo##_offset = off;\ U_ASSERT(IS_VALID_OFFSET(off + foo##_size));\ U_ASSERT(foo##_offset % sizeof(type) == 0);\ off = (Offset) (off + foo##_size); COMPUTE_OFFSET(enumToName); // 0: COMPUTE_OFFSET(nameToEnum); // 2: COMPUTE_OFFSET(enumToValue); // 3: COMPUTE_OFFSET(valueMap); // 4: for (i=0; i<valueMap_count; ++i) { if (debug>0) { printf(" enumToName[%d]\t offset=%4d size=%5d\n", (int)i, off, (int)valueEnumToName_size[i]); } valueEnumToName_offset[i] = off; // 5: U_ASSERT(IS_VALID_OFFSET(off + valueEnumToName_size[i])); off = (Offset) (off + valueEnumToName_size[i]); if (debug>0) { printf(" nameToEnum[%d]\t offset=%4d size=%5d\n", (int)i, off, (int)valueNameToEnum_size[i]); } valueNameToEnum_offset[i] = off; // 6: U_ASSERT(IS_VALID_OFFSET(off + valueNameToEnum_size[i])); off = (Offset) (off + valueNameToEnum_size[i]); } // These last two chunks have weaker alignment needs COMPUTE_OFFSET2(nameGroupPool,Offset); // 98: COMPUTE_OFFSET2(stringPool,char); // 99: total_size = off; if (debug>0) printf("total size=%5d\n\n", (int)total_size); U_ASSERT(total_size <= (MAX_OFFSET+1)); }
NameToEnum* Builder::buildNameToEnum(const NameToEnumEntry* nameToEnum, int32_t count, int32_t& size) { size = align(NameToEnum::getSize(count)); NameToEnum* n2e = (NameToEnum*) uprv_malloc(size); erase(n2e, size); n2e->count = count; Offset* p = n2e->getNameArray(); EnumValue* e = n2e->getEnumArray(); for (int32_t i=0; i<count; ++i) { // set these to SP index values // fix them up to SP offset values U_ASSERT(IS_VALID_OFFSET(nameToEnum[i].nameIndex)); p[i] = (Offset) nameToEnum[i].nameIndex; // FIXUP later e[i] = nameToEnum[i].enumValue; } return n2e; }
EnumToOffset* Builder::buildEnumToOffset(const EnumToNameGroupEntry* e2ng, int32_t count, int32_t& size) { U_ASSERT(e2ng->isContiguous(count)); size = align(EnumToOffset::getSize(count)); EnumToOffset* result = (EnumToOffset*) uprv_malloc(size); erase(result, size); result->enumStart = e2ng->enumValue; result->enumLimit = e2ng->enumValue + count; Offset* p = result->getOffsetArray(); for (int32_t i=0; i<count; ++i) { // set these to NGI index values // fix them up to NGI offset values U_ASSERT(IS_VALID_OFFSET(e2ng[i].nameGroupIndex)); p[i] = (Offset) e2ng[i].nameGroupIndex; // FIXUP later } return result; }
void Builder::buildStringPool(const AliasName* propertyNames, int32_t propertyNameCount, const int32_t* nameGroupIndices, int32_t nameGroupIndicesCount) { int32_t i; nameGroupPool_count = nameGroupIndicesCount; nameGroupPool_size = sizeof(Offset) * nameGroupPool_count; nameGroupPool = MALLOC(Offset, nameGroupPool_count); for (i=0; i<nameGroupPool_count; ++i) { // Some indices are negative. int32_t a = nameGroupIndices[i]; if (a < 0) a = -a; U_ASSERT(IS_VALID_OFFSET(a)); nameGroupPool[i] = (Offset) nameGroupIndices[i]; } stringPool_count = propertyNameCount; stringPool_size = 0; // first string must be "" -- we skip it U_ASSERT(*propertyNames[0].str == 0); for (i=1 /*sic*/; i<propertyNameCount; ++i) { stringPool_size += (int32_t)(uprv_strlen(propertyNames[i].str) + 1); } stringPool = MALLOC(char, stringPool_size); stringPool_offsetArray = MALLOC(Offset, stringPool_count); Offset soFar = 0; char* p = stringPool; stringPool_offsetArray[0] = -1; // we don't use this entry for (i=1 /*sic*/; i<propertyNameCount; ++i) { const char* str = propertyNames[i].str; int32_t len = (int32_t)uprv_strlen(str); uprv_strcpy(p, str); p += len; *p++ = 0; stringPool_offsetArray[i] = soFar; soFar += (Offset)(len+1); } U_ASSERT(soFar == stringPool_size); U_ASSERT(p == (stringPool + stringPool_size)); }
NonContiguousEnumToOffset* Builder::buildNCEnumToNameGroup(const EnumToNameGroupEntry* e2ng, int32_t count, int32_t& size) { U_ASSERT(!e2ng->isContiguous(count)); size = align(NonContiguousEnumToOffset::getSize(count)); NonContiguousEnumToOffset* nc = (NonContiguousEnumToOffset*) uprv_malloc(size); erase(nc, size); nc->count = count; EnumValue* e = nc->getEnumArray(); Offset* p = nc->getOffsetArray(); for (int32_t i=0; i<count; ++i) { // set these to NGI index values // fix them up to NGI offset values e[i] = e2ng[i].enumValue; U_ASSERT(IS_VALID_OFFSET(e2ng[i].nameGroupIndex)); p[i] = (Offset) e2ng[i].nameGroupIndex; // FIXUP later } return nc; }
struct skin_element* skin_parse(const char* document, skin_callback cb, void* cb_data) { callback = cb; callback_data = cb_data; #else struct skin_element* skin_parse(const char* document) { #endif struct skin_element* root = NULL; struct skin_element* last = NULL; const char* cursor = document; /*Keeps track of location in the document*/ skin_line = 1; skin_start = (char*)document; viewport_line = 0; skin_clear_errors(); while(*cursor != '\0') { struct skin_element* tree = skin_parse_viewport(&cursor); if(!root) { root = tree; last = root; } else { last->next = skin_buffer_to_offset(tree); last = tree; } if(!last) { skin_free_tree(root); /* Clearing any memory already used */ return NULL; } /* Making sure last is at the end */ while(IS_VALID_OFFSET(last->next)) last = skin_buffer_from_offset(last->next); } return root; } static struct skin_element* skin_parse_viewport(const char** document) { struct skin_element* root = NULL; struct skin_element* last = NULL; struct skin_element* retval = NULL; retval = skin_alloc_element(); if (!retval) return NULL; retval->type = VIEWPORT; retval->children_count = 1; retval->line = skin_line; viewport_line = skin_line; OFFSETTYPE(struct skin_element*)* children; const char* cursor = *document; /* Keeps track of location in the document */ const char* bookmark; /* Used when we need to look ahead */ int sublines = 0; /* Flag for parsing sublines */ /* Parsing out the viewport tag if there is one */ if(check_viewport(cursor)) { if (!skin_parse_tag(retval, &cursor)) return NULL; if(*cursor == '\n') { cursor++; skin_line++; } } #ifdef ROCKBOX else if (callback) { if (callback(retval, callback_data) == CALLBACK_ERROR) { skin_error(GOT_CALLBACK_ERROR, cursor); return NULL; } } #endif if (check_viewport(cursor)) { retval->children_count = 0; *document = cursor; return retval; } retval->children_count = 1; children = skin_alloc_children(1); if (!children) return NULL; do { /* First, we check to see if this line will contain sublines */ bookmark = cursor; sublines = 0; while(*cursor != '\n' && *cursor != '\0' && !(check_viewport(cursor) && cursor != *document)) { if(*cursor == MULTILINESYM) { sublines = 1; break; } else if(*cursor == TAGSYM) { skip_tag(&cursor); } else if(*cursor == COMMENTSYM) { skip_comment(&cursor); } else { /* Advancing the cursor as normal */ cursor++; } } cursor = bookmark; if(sublines) { struct skin_element* out = skin_parse_sublines(&cursor); if (!root) { root = out; last = root; } else { last->next = skin_buffer_to_offset(out); last = out; } if(!last) return NULL; } else { #ifdef ROCKBOX /* strip all leading comments */ while(*cursor == '#') { skip_comment(&cursor); skin_line++; } if (check_viewport(cursor)) break; #endif struct skin_element* out = skin_parse_line(&cursor); if (!root) { root = out; last = root; } else { last->next = skin_buffer_to_offset(out); last = out; } if(!last) return NULL; } /* Making sure last is at the end */ while(IS_VALID_OFFSET(last->next)) last = skin_buffer_from_offset(last->next); if(*cursor == '\n') { cursor++; skin_line++; } #ifdef ROCKBOX /* strip all comments */ while(*cursor == '#') { skip_comment(&cursor); skin_line++; } if (check_viewport(cursor)) break; #endif } while(*cursor != '\0' && !(check_viewport(cursor) && cursor != *document)); *document = cursor; children[0] = skin_buffer_to_offset(root); retval->children = skin_buffer_to_offset(children); return retval; } /* Auxiliary Parsing Functions */ static struct skin_element* skin_parse_line(const char**document) { return skin_parse_line_optional(document, 0); } /* * If conditional is set to true, then this will break upon encountering * SEPARATESYM. This should only be used when parsing a line inside a * conditional, otherwise just use the wrapper function skin_parse_line() */ static struct skin_element* skin_parse_line_optional(const char** document, int conditional) { const char* cursor = *document; struct skin_element* root = NULL; struct skin_element* current = NULL; struct skin_element* retval = NULL; OFFSETTYPE(struct skin_element*)* children = NULL; /* A wrapper for the line */ retval = skin_alloc_element(); if (!retval) return NULL; retval->type = LINE; retval->line = skin_line; while (*cursor == '\t') cursor++; if(*cursor != '\0' && *cursor != '\n' && *cursor != MULTILINESYM && !(conditional && (*cursor == ARGLISTSEPARATESYM || *cursor == ARGLISTCLOSESYM || *cursor == ENUMLISTSEPARATESYM || *cursor == ENUMLISTCLOSESYM))) { retval->children_count = 1; } else { retval->children_count = 0; } if(retval->children_count > 0) { children = skin_alloc_children(1); if (!children) return NULL; } #ifdef ROCKBOX if (callback) { switch (callback(retval, callback_data)) { case CALLBACK_ERROR: skin_error(GOT_CALLBACK_ERROR, cursor); return NULL; default: break; } } #endif while(*cursor != '\n' && *cursor != '\0' && *cursor != MULTILINESYM && !((*cursor == ARGLISTSEPARATESYM || *cursor == ARGLISTCLOSESYM || *cursor == ENUMLISTSEPARATESYM || *cursor == ENUMLISTCLOSESYM) && conditional) && !(check_viewport(cursor) && cursor != *document)) { /* Allocating memory if necessary */ if(root) { struct skin_element *next = skin_alloc_element(); if (!next) return NULL; current->next = skin_buffer_to_offset(next); current = next; } else { current = skin_alloc_element(); if (!current) return NULL; root = current; } /* Parsing the current element */ if(*cursor == TAGSYM && cursor[1] == CONDITIONSYM) { if(!skin_parse_conditional(current, &cursor)) return NULL; } else if(*cursor == TAGSYM && !find_escape_character(cursor[1])) { if(!skin_parse_tag(current, &cursor)) return NULL; } else if(*cursor == COMMENTSYM) { if(!skin_parse_comment(current, &cursor)) return NULL; } else { if(!skin_parse_text(current, &cursor, conditional)) return NULL; } } /* Moving up the calling function's pointer */ *document = cursor; if(root) { children[0] = skin_buffer_to_offset(root); retval->children = skin_buffer_to_offset(children); } return retval; } static struct skin_element* skin_parse_sublines(const char** document) { return skin_parse_sublines_optional(document, 0); } static struct skin_element* skin_parse_sublines_optional(const char** document, int conditional) { struct skin_element* retval; OFFSETTYPE(struct skin_element*)* children; const char* cursor = *document; int sublines = 1; int i; retval = skin_alloc_element(); if (!retval) return NULL; retval->type = LINE_ALTERNATOR; retval->next = skin_buffer_to_offset(NULL); retval->line = skin_line; while (*cursor == '\t') cursor++; /* First we count the sublines */ while(*cursor != '\0' && *cursor != '\n' && !((*cursor == ARGLISTSEPARATESYM || *cursor == ARGLISTCLOSESYM || *cursor == ENUMLISTSEPARATESYM || *cursor == ENUMLISTCLOSESYM) && conditional) && !(check_viewport(cursor) && cursor != *document)) { if(*cursor == COMMENTSYM) { skip_comment(&cursor); } else if(*cursor == TAGSYM) { skip_tag(&cursor); } else if(*cursor == MULTILINESYM) { sublines++; cursor++; } else { cursor++; } } /* ...and then we parse them */ retval->children_count = sublines; children = skin_alloc_children(sublines); if (!children) return NULL; cursor = *document; for(i = 0; i < sublines; i++) { children[i] = skin_buffer_to_offset(skin_parse_line_optional(&cursor, conditional)); if (children[i] < 0) return NULL; skip_whitespace(&cursor); if(*cursor != MULTILINESYM && i != sublines - 1) { skin_error(MULTILINE_EXPECTED, cursor); return NULL; } else if(i != sublines - 1) { cursor++; } } #ifdef ROCKBOX if (callback) { if (callback(retval, callback_data) == CALLBACK_ERROR) { skin_error(GOT_CALLBACK_ERROR, *document); return NULL; } } #endif *document = cursor; retval->children = skin_buffer_to_offset(children); return retval; } static int skin_parse_tag(struct skin_element* element, const char** document) { const char* cursor = *document + 1; const char* bookmark; char *open_square_bracket = NULL; char tag_name[MAX_TAG_LENGTH]; char* tag_args; const struct tag_info *tag; struct skin_tag_parameter* params = NULL; int num_args = 1; int i; int qmark = 0; /* Flag for the all-or-none option */ int optional = 0; /* Checking the tag name */ for (i=0; cursor[i] && i<MAX_TAG_LENGTH; i++) tag_name[i] = cursor[i]; /* First we check the two characters after the '%', then a single char */ tag = NULL; i = MAX_TAG_LENGTH; while (!tag && i > 1) { tag_name[i-1] = '\0'; tag = find_tag(tag_name); i--; } if(!tag) { skin_error(ILLEGAL_TAG, cursor); return 0; } cursor += i; /* Copying basic tag info */ if(element->type != CONDITIONAL && element->type != VIEWPORT) element->type = TAG; element->tag = tag; tag_args = tag->params; element->line = skin_line; /* Checking for the * flag */ if(tag_args[0] == '?') { qmark = 1; tag_args++; } /* If this tag has no arguments, we can bail out now */ if(strlen(tag_args) == 0 || (tag_args[0] == '|' && *cursor != ARGLISTOPENSYM) || (qmark && *cursor != ARGLISTOPENSYM)) { #ifdef ROCKBOX if (callback) { if (callback(element, callback_data) == CALLBACK_ERROR) { skin_error(GOT_CALLBACK_ERROR, cursor); return 0; } } #endif *document = cursor; return 1; } /* Checking the number of arguments and allocating args */ if(*cursor != ARGLISTOPENSYM && tag_args[0] != '|') { skin_error(ARGLIST_EXPECTED, cursor); return 0; } else { cursor++; } bookmark = cursor; while(*cursor != '\n' && *cursor != '\0' && *cursor != ARGLISTCLOSESYM) { /* Skipping over escaped characters */ if(*cursor == TAGSYM && *(cursor+1) != ARGLISTSEPARATESYM) { skip_tag(&cursor); } else if(*cursor == COMMENTSYM) { skip_comment(&cursor); } else if(*cursor == ARGLISTSEPARATESYM) { num_args++; cursor++; } else { cursor++; } } cursor = bookmark; /* Restoring the cursor */ element->params_count = num_args; params = skin_alloc_params(num_args); if (!params) return 0; /* Now we have to actually parse each argument */ for(i = 0; i < num_args; i++) { char type_code; /* Making sure we haven't run out of arguments */ if(*tag_args == '\0') { skin_error(TOO_MANY_ARGS, cursor); return 0; } /* Checking for the optional bar */ if(*tag_args == '|') { optional = 1; tag_args++; } /* Scanning the arguments */ skip_whitespace(&cursor); /* Checking for comments */ if(*cursor == COMMENTSYM) skip_comment(&cursor); if (*tag_args == '[') { /* we need to guess which type of param it is. * guess using this priority: * default > decimal/integer > single tag/code > string */ int j=0; bool canbedefault = false, last_char_is_percent = false; bool haspercent = false, number = true, hasdecimal = false; char temp_params[8]; open_square_bracket = tag_args; tag_args++; while (*tag_args != ']') { if (*tag_args >= 'a' && *tag_args <= 'z') canbedefault = true; temp_params[j++] = tolower(*tag_args++); } temp_params[j] = '\0'; j = 0; while (cursor[j] && cursor[j] != ',' && cursor[j] != ')') { haspercent = haspercent || (cursor[j] == '%'); hasdecimal = hasdecimal || (cursor[j] == '.'); number = number && (isdigit(cursor[j]) || (cursor[j] == '.') || (cursor[j] == '-') || (cursor[j] == '%')); j++; } last_char_is_percent = cursor[j-1] == '%'; type_code = '?'; if (canbedefault && *cursor == DEFAULTSYM && !isdigit(cursor[1])) { type_code = 'i'; } else if (number && hasdecimal && strchr(temp_params, 'd')) { type_code = 'd'; } else if (number && last_char_is_percent && strchr(temp_params, 'p')) { type_code = 'p'; } else if (number && (strchr(temp_params, 'i') || strchr(temp_params, 'd'))) { type_code = strchr(temp_params, 'i') ? 'i' : 'd'; } else if (haspercent && (strchr(temp_params, 't') || strchr(temp_params, 'c'))) { type_code = strchr(temp_params, 't') ? 't' : 'c'; } else if (strchr(temp_params, 's')) { type_code = 's'; } if (type_code == '?') { skin_error(INSUFFICIENT_ARGS, cursor); return 0; } } else type_code = *tag_args; /* Storing the type code */ params[i].type_code = type_code; /* Checking a nullable argument for null. */ if(*cursor == DEFAULTSYM && !isdigit(cursor[1])) { if(islower(type_code)) { params[i].type = DEFAULT; cursor++; } else { skin_error(DEFAULT_NOT_ALLOWED, cursor); return 0; } } else if(tolower(type_code) == 'i') { /* Scanning an int argument */ if(!isdigit(*cursor) && *cursor != '-') { skin_error(INT_EXPECTED, cursor); return 0; } params[i].type = INTEGER; params[i].data.number = scan_int(&cursor); } else if(tolower(type_code) == 'd' || tolower(type_code) == 'p') { int val = 0; bool have_point = false; bool have_tenth = false; while ( isdigit(*cursor) || *cursor == '.' ) { if (*cursor != '.') { val *= 10; val += *cursor - '0'; if (have_point) { have_tenth = true; cursor++; break; } } else have_point = true; cursor++; } if (have_tenth == false) val *= 10; if (tolower(type_code) == 'd') params[i].type = DECIMAL; else { params[i].type = PERCENT; cursor++; /* skip trailing % sign */ } params[i].data.number = val; } else if(tolower(type_code) == 's' || tolower(type_code) == 'f') { /* Scanning a string argument */ params[i].type = STRING; params[i].data.text = skin_buffer_to_offset(scan_string(&cursor)); } else if(tolower(type_code) == 'c') { /* Recursively parsing a code argument */ params[i].type = CODE; params[i].data.code = skin_buffer_to_offset(skin_parse_code_as_arg(&cursor)); if(params[i].data.code < 0) return 0; } else if (tolower(type_code) == 't') { struct skin_element* child = skin_alloc_element(); child->type = TAG; if (!skin_parse_tag(child, &cursor)) return 0; child->next = skin_buffer_to_offset(NULL); params[i].type = CODE; params[i].data.code = skin_buffer_to_offset(child); } skip_whitespace(&cursor); if(*cursor != ARGLISTSEPARATESYM && i < num_args - 1) { skin_error(SEPARATOR_EXPECTED, cursor); return 0; } else if(*cursor != ARGLISTCLOSESYM && i == num_args - 1) { skin_error(CLOSE_EXPECTED, cursor); return 0; } else { cursor++; } if (*(tag_args + 1) == '*') { if (i+1 == num_args) tag_args += 2; else if (open_square_bracket && *tag_args == ']') { tag_args = open_square_bracket; open_square_bracket = NULL; } } else tag_args++; /* Checking for the optional bar */ if(*tag_args == '|') { optional = 1; tag_args++; } } element->params = skin_buffer_to_offset(params); /* Checking for a premature end */ if(*tag_args != '\0' && !optional) { skin_error(INSUFFICIENT_ARGS, cursor); return 0; } #ifdef ROCKBOX if (callback) { if (callback(element, callback_data) == CALLBACK_ERROR) { skin_error(GOT_CALLBACK_ERROR, *document); return 0; } } #endif *document = cursor; return 1; } /* * If the conditional flag is set true, then parsing text will stop at an * ARGLISTSEPARATESYM. Only set that flag when parsing within a conditional */ static int skin_parse_text(struct skin_element* element, const char** document, int conditional) { const char* cursor = *document; int length = 0; int dest; char *text = NULL; /* First figure out how much text we're copying */ while(*cursor != '\0' && *cursor != '\n' && *cursor != MULTILINESYM && *cursor != COMMENTSYM && !((*cursor == ARGLISTSEPARATESYM || *cursor == ARGLISTCLOSESYM || *cursor == ENUMLISTSEPARATESYM || *cursor == ENUMLISTCLOSESYM) && conditional)) { /* Dealing with possibility of escaped characters */ if(*cursor == TAGSYM) { if(find_escape_character(cursor[1])) cursor++; else break; } length++; cursor++; } cursor = *document; /* Copying the text into the element struct */ element->type = TEXT; element->line = skin_line; element->next = skin_buffer_to_offset(NULL); text = skin_alloc_string(length); element->data = skin_buffer_to_offset(text); if (element->data < 0) return 0; for(dest = 0; dest < length; dest++) { /* Advancing cursor if we've encountered an escaped character */ if(*cursor == TAGSYM) cursor++; text[dest] = *cursor; cursor++; } text[length] = '\0'; #ifdef ROCKBOX if (callback) { if (callback(element, callback_data) == CALLBACK_ERROR) { skin_error(GOT_CALLBACK_ERROR, *document); return 0; } } #endif *document = cursor; return 1; } static int skin_parse_conditional(struct skin_element* element, const char** document) { const char* cursor = *document + 1; /* Starting past the "%" */ const char* bookmark; int children = 1; int i; #ifdef ROCKBOX bool feature_available = true; const char *false_branch = NULL; const char *conditional_end = NULL; #endif OFFSETTYPE(struct skin_element*)* children_array = NULL; /* Some conditional tags allow for target feature checking, * so to handle that call the callback as usual with type == TAG * then call it a second time with type == CONDITIONAL and check the return * value */ element->type = TAG; element->line = skin_line; /* Parsing the tag first */ if(!skin_parse_tag(element, &cursor)) return 0; element->type = CONDITIONAL; #ifdef ROCKBOX if (callback) { switch (callback(element, callback_data)) { case FEATURE_NOT_AVAILABLE: feature_available = false; break; case CALLBACK_ERROR: return 0; default: break; } } #endif /* Counting the children */ if(*(cursor++) != ENUMLISTOPENSYM) { skin_error(ARGLIST_EXPECTED, cursor); return 0; } bookmark = cursor; while(*cursor != ENUMLISTCLOSESYM && *cursor != '\0') { if(*cursor == COMMENTSYM) { skip_comment(&cursor); } else if(*cursor == TAGSYM) { skip_tag(&cursor); } else if(*cursor == ENUMLISTSEPARATESYM) { children++; cursor++; if (*cursor == '\n') cursor++; #ifdef ROCKBOX if (false_branch == NULL && !feature_available) { false_branch = cursor; children--; } #endif } else { cursor++; } } #ifdef ROCKBOX if (*cursor == ENUMLISTCLOSESYM && false_branch == NULL && !feature_available) { false_branch = cursor+1; children--; } if (element->tag->flags&FEATURE_TAG) { if (feature_available && children > 1) children--; } conditional_end = cursor; /* if we are skipping the true branch fix that up */ cursor = false_branch ? false_branch : bookmark; #else cursor = bookmark; #endif /* Parsing the children */ /* Feature tags could end up having 0 children which breaks * the render in dangerous ways. Minor hack, but insert an empty * child. (e.g %?xx<foo> when xx isnt available ) */ if (children == 0) { const char* emptyline= ""; children = 1; children_array = skin_alloc_children(children); if (!children_array) return 0; element->children_count = children; children_array[0] = skin_buffer_to_offset(skin_parse_code_as_arg(&emptyline)); } else { children_array = skin_alloc_children(children); if (!children_array) return 0; element->children_count = children; for(i = 0; i < children; i++) { if (*cursor == '\n') { skin_line++; cursor++; } children_array[i] = skin_buffer_to_offset(skin_parse_code_as_arg(&cursor)); if (children_array[i] < 0) return 0; skip_whitespace(&cursor); #ifdef ROCKBOX if ((element->tag->flags&FEATURE_TAG) && feature_available) cursor = conditional_end; #endif if(i < children - 1 && *cursor != ENUMLISTSEPARATESYM) { skin_error(SEPARATOR_EXPECTED, cursor); return 0; } else if(i == children - 1 && *cursor != ENUMLISTCLOSESYM) { skin_error(CLOSE_EXPECTED, cursor); return 0; } else { cursor++; } } } *document = cursor; element->children = skin_buffer_to_offset(children_array); return 1; } static int skin_parse_comment(struct skin_element* element, const char** document) { const char* cursor = *document; #ifndef ROCKBOX char* text = NULL; #endif int length; /* * Finding the index of the ending newline or null-terminator * The length of the string of interest doesn't include the leading #, the * length we need to reserve is the same as the index of the last character */ for(length = 0; cursor[length] != '\n' && cursor[length] != '\0'; length++); element->type = COMMENT; element->line = skin_line; #ifdef ROCKBOX element->data = INVALID_OFFSET; #else element->data = text = skin_alloc_string(length); if (!element->data) return 0; /* We copy from one char past cursor to leave out the # */ memcpy((void*)text, (void*)(cursor + 1), sizeof(char) * (length-1)); text[length - 1] = '\0'; #endif if(cursor[length] == '\n') skin_line++; *document += (length); /* Move cursor up past # and all text */ if(**document == '\n') (*document)++; return 1; } static struct skin_element* skin_parse_code_as_arg(const char** document) { int sublines = 0; const char* cursor = *document; /* Checking for sublines */ while(*cursor != '\n' && *cursor != '\0' && *cursor != ENUMLISTSEPARATESYM && *cursor != ARGLISTSEPARATESYM && *cursor != ENUMLISTCLOSESYM && *cursor != ARGLISTCLOSESYM) { if(*cursor == MULTILINESYM) { sublines = 1; break; } else if(*cursor == TAGSYM) { skip_tag(&cursor); } else { /* Advancing the cursor as normal */ cursor++; } } if(sublines) return skin_parse_sublines_optional(document, 1); else return skin_parse_line_optional(document, 1); }