void add_glossary_item( xml_elem_t* doc, ASXMLInterpreterState *state ) { xml_elem_t *cdata = find_tag_by_id( doc->child, XML_CDATA_ID ); char *term_text = mystrdup(cdata?cdata->parm:"") ; char *orig_term_text = term_text ; int i ; LOCAL_DEBUG_OUT( "term_text = \"%s\"", term_text ); while(*term_text) { if( isalnum(*term_text) ) break; ++term_text ; } i = 0 ; while( isalnum(term_text[i]) ) ++i ; term_text[i] = '\0' ; if( term_text[0] != '\0' ) /* need to add glossary term */ { char *target = NULL, *target2 ; char *term = NULL, *term2 ; char *ptr = &(state->dest_file[strlen(state->dest_file)-4]); if( state->doc_type == DocType_PHP && *ptr == '.') *ptr = '\0' ; target = safemalloc( strlen( state->dest_file)+5+1+strlen(state->curr_url_anchor)+1); sprintf( target, "%s#%s", state->dest_file, state->curr_url_anchor ); if( state->doc_type == DocType_PHP && *ptr == '\0' ) *ptr = '.' ; target2 = mystrdup(target); term2 = mystrdup(term_text); if( add_hash_item( Links, AS_HASHABLE(term2), (void*)target2 ) != ASH_Success ) { free( target2 ); free( term2 ); } term = safemalloc( strlen( term_text)+ 1 + 1 +strlen( state->doc_name ) + 1 +1 ); sprintf( term, "%s (%s)", term_text, state->doc_name ); LOCAL_DEBUG_OUT( "term = \"%s\"", term ); if( add_hash_item( Glossary, AS_HASHABLE(term), (void*)target ) != ASH_Success ) { free( target ); free( term ); } } free(orig_term_text); }
static struct hash_entry * remove_hash_item(int idx) { int cnt = 0, i, j = 0; struct hash_entry *retval; struct hash_entry **saved_entries = 0; // count the items after this one ASSERT(hash_table[idx]); retval = hash_table[idx]; i = (idx + HASH_STEP) % HASH_SIZE; while (hash_table[i]) { cnt++; i = (i + HASH_STEP) % HASH_SIZE; } if (!cnt) { hash_table[idx] = 0; return retval; } XALLOCAZ(saved_entries, cnt); i = idx; hash_table[i] = 0; i = (i + HASH_STEP) % HASH_SIZE; while (hash_table[i]) { saved_entries[j++] = hash_table[i]; hash_table[i] = 0; i = (i + HASH_STEP) % HASH_SIZE; } ASSERT(j == cnt); for (j = 0; j < cnt; j++) add_hash_item(saved_entries[j]); return retval; }
AfterShowXWindow * aftershow_create_x_window (AfterShowContext *ctx, AfterShowXWindow *parent, int width, int height) { AfterShowXWindow *window = safecalloc( 1, sizeof(AfterShowXWindow)); AfterShowXScreen *scr = parent->screen; unsigned long attr_mask = CWEventMask ; XSetWindowAttributes attr; window->magic = MAGIC_AFTERSHOW_X_WINDOW; window->screen = scr; attr.event_mask = ExposureMask; window->w = create_visual_window(scr->asv, parent->w, 0, 0, width, height, 0, InputOutput, attr_mask, &attr); add_hash_item (scr->windows, AS_HASHABLE(window->w), window); window->width = width; window->height = height; window->back = create_visual_pixmap(scr->asv, window->w, width, height, 0); window->gc = create_visual_gc(scr->asv, window->w, 0, NULL); window->depth = scr->asv->true_depth; window->back_width = width; window->back_height = height; return window; }
ASHashResult countadd_hash_item (const char *fname, int line, struct ASHashTable *hash, ASHashableValue value, void *data ) { ASHashResult res ; service_mode++ ; res = add_hash_item(hash, value, data ); service_mode-- ; /* show_debug( __FILE__, __FUNCTION__, __LINE__, "add_hash_item called from %s:%d with args %p, %lX, %p", fname, line, hash, value, data ); */ if( hash != allocs_hash ) { if( res == ASH_Success ) { if( check_hash_item_reused (hash->most_recent) ) { /*show_debug( __FILE__, fname, line, "reused hash item %p", hash->most_recent );*/ count_alloc (fname, line, hash->most_recent, sizeof(ASHashItem), C_MEM | C_ADD_HASH_OPTIONAL_ITEM ); }else count_alloc (fname, line, hash->most_recent, sizeof(ASHashItem), C_MEM | C_ADD_HASH_ITEM); } } return res; }
void * countrealloc (const char *fname, int line, void *ptr, size_t length) { if (ptr != NULL && length == 0) countfree (fname, line, ptr); if (length == 0) return NULL; if (ptr != NULL) { mem *m = NULL; ASHashResult res ; if( allocs_hash != NULL ) { ASHashData hd ; service_mode++ ; if( remove_hash_item (allocs_hash, AS_HASHABLE(ptr), &hd.vptr, False) == ASH_Success ) { m = hd.vptr ; if( (m->type & 0xff) != C_MEM ) { show_error( "while deallocating pointer 0x%lX discovered that it was allocated with different type", ptr ); print_simple_backtrace(); #ifdef DEBUG_ALLOC_STRICT { char *segv = NULL ; *segv = 0 ; } #endif m = NULL ; } } service_mode-- ; } if (m == NULL) { show_error ("countrealloc:attempt in %s:%d to realloc memory(%p) that was never allocated!\n", fname, line, ptr); print_simple_backtrace(); #ifdef DEBUG_ALLOC_STRICT { char *segv = NULL ; *segv = 0 ; } #endif return NULL; } if ((m->type & 0xff) == C_MEM) { total_alloc -= m->length; total_alloc += length; if (total_alloc > max_alloc) max_alloc = total_alloc; } else { total_x_alloc -= m->length; total_x_alloc += length; if (total_x_alloc > max_x_alloc) max_x_alloc = total_x_alloc; } m->fname = fname; m->line = line; m->length = length; m->type = C_MEM | C_REALLOC; m->ptr = saferealloc (ptr, length); m->freed = 0; ptr = m->ptr; if( (res = add_hash_item( allocs_hash, (ASHashableValue)ptr, m )) != ASH_Success ) { show_error( "failed to log allocation for pointer 0x%lX - result = %d", ptr, res); #ifdef DEBUG_ALLOC_STRICT { char *segv = NULL ; *segv = 0 ; } #endif } reallocations++; } else ptr = countmalloc (fname, line, length); return ptr; }
void count_alloc (const char *fname, int line, void *ptr, size_t length, int type) { mem *m = NULL; ASHashResult res ; ASHashData hdata = {0}; if( service_mode > 0 ) return ; if( allocs_hash == NULL ) { service_mode++ ; allocs_hash = create_ashash( 256, pointer_hash_value, NULL, mem_destroy ); fprintf( stderr, "MEMORY AUDIT: count_alloc() called from %s:%d: allocs hash table created with pointer %p\n", fname, line, allocs_hash ); service_mode-- ; }else if( ptr == allocs_hash ) return; if( get_hash_item( allocs_hash, (ASHashableValue)ptr, &hdata.vptr ) == ASH_Success ) { m = (mem*)hdata.vptr ; if( type != (C_MEM|C_ADD_HASH_OPTIONAL_ITEM) ) { show_error( "Same pointer value 0x%lX is being counted twice!\n Called from %s:%d - previously allocated in %s:%d", (unsigned long)ptr, fname, line, m->fname, m->line ); print_simple_backtrace(); #ifdef DEBUG_ALLOC_STRICT { char *segv = NULL ; *segv = 0 ; } #endif }else return ; }else if( deallocated_used > 0 ) { m = deallocated_mem[--deallocated_used]; /* show_warning( "<mem> reusing deallocation cache - element %d, pointer %p auditing service memory used (%lu )\n Called from %s:%d", deallocated_used, m, total_service, fname, line ); */ }else { m = safecalloc (1, sizeof (mem)); if( total_service+sizeof(mem) > AUDIT_SERVICE_MEM_LIMIT ) { show_error( "<mem> too much auditing service memory used (%lu - was %lu)- aborting, please investigate.\n Called from %s:%d", total_service+sizeof(mem), total_service, fname, line ); print_simple_backtrace(); output_unfreed_mem (stderr); #ifdef DEBUG_ALLOC_STRICT { char *segv = NULL ; *segv = 0 ; } #endif exit(0); } total_service += sizeof(mem); if( total_service > max_service ) max_service = total_service ; } m->fname = fname; m->line = line; m->length = length; m->type = type; m->ptr = ptr; m->freed = 0; allocations++; if ((type & 0xff) == C_MEM) { total_alloc += length; if (total_alloc > max_alloc) max_alloc = total_alloc; } else { total_x_alloc += length; if (total_x_alloc > max_x_alloc) max_x_alloc = total_x_alloc; } if (allocations - deallocations > max_allocations) max_allocations = allocations - deallocations; if( (res = add_hash_item( allocs_hash, (ASHashableValue)ptr, m )) != ASH_Success ) show_error( "failed to log allocation for pointer 0x%lX - result = %d", ptr, res); else { if( total_service+sizeof(ASHashItem) > AUDIT_SERVICE_MEM_LIMIT ) { show_error( "<add_hash_item> too much auditing service memory used (%lu - was %lu)- aborting, please investigate.\n Called from %s:%d", total_service+sizeof(ASHashItem), total_service, fname, line ); print_simple_backtrace(); #ifdef DEBUG_ALLOC_STRICT { char *segv = NULL ; *segv = 0 ; } #endif exit(0); } total_service += sizeof(ASHashItem); if( total_service > max_service ) max_service = total_service ; } }
void gen_syntax_doc( const char *source_dir, const char *dest_dir, SyntaxDef *syntax, ASDocType doc_type ) { ASXMLInterpreterState state; const char *doc_path = AfterStepName ; char *syntax_dir = NULL ; int i ; ASFlagType doc_class_mask = 0 ; if( syntax ) { if( get_hash_item( ProcessedSyntaxes, AS_HASHABLE(syntax), NULL ) == ASH_Success ) return ; doc_path = syntax->doc_path ; } if( syntax != NULL && syntax->doc_path != NULL && syntax->doc_path[0] != '\0' ) syntax_dir = make_file_name (source_dir, syntax->doc_path); if( syntax_dir == NULL ) syntax_dir = mystrdup( source_dir ); if( doc_type == DocType_PHP ) { int overview_size = 0 ; int tmp ; /* we generate upto 4 files in PHP mode : overview, Base config, MyStyles and Config Options * Overview and Config Options are always present. Others may be ommited if source is missing * If Overview is too small - say < 1024 bytes - it could be bundled with Config Options */ set_flags( doc_class_mask, DOC_CLASS_Overview ); LOCAL_DEBUG_OUT( "Checking what parts to generate ...%s", ""); if( (tmp = check_xml_contents( syntax_dir, MyStylesOptionsEntry )) > 0) set_flags( doc_class_mask, DOC_CLASS_MyStyles ); LOCAL_DEBUG_OUT( "MyStyle size = %d", tmp ); if((tmp = check_xml_contents( syntax_dir, BaseOptionsEntry )) > 0) set_flags( doc_class_mask, DOC_CLASS_BaseConfig ); LOCAL_DEBUG_OUT( "Base size = %d", tmp ); for( i = 0 ; StandardSourceEntries[i] ; ++i ) overview_size += check_xml_contents( syntax_dir, StandardSourceEntries[i] ); if( syntax == NULL ) overview_size += 0 ; LOCAL_DEBUG_OUT( "overview size = %d", overview_size ); if( overview_size > OVERVIEW_SIZE_THRESHOLD ) set_flags( doc_class_mask, DOC_CLASS_Options ); }else doc_class_mask = DOC_CLASS_None ; if( !start_doc_file( dest_dir, doc_path, NULL, doc_type, syntax?syntax->doc_path:NULL, syntax?syntax->display_name:NULL, syntax?syntax->display_purpose:NULL, &state, doc_class_mask, DocClass_Overview ) ) return ; if( doc_type != DocType_PHP ) { /* BODY *************************************************************************/ i = 0 ; if( syntax == NULL ) { convert_xml_file( syntax_dir, StandardSourceEntries[0], &state ); ++i ; convert_xml_file( syntax_dir, StandardOptionsEntry, &state ); } for( ; i < OPENING_PARTS_END ; ++i ) convert_xml_file( syntax_dir, StandardSourceEntries[i], &state ); if( syntax ) { convert_xml_file( syntax_dir, BaseOptionsEntry, &state ); convert_xml_file( syntax_dir, MyStylesOptionsEntry, &state ); } }else { i = 0 ; if( syntax == NULL ) { convert_xml_file( syntax_dir, StandardSourceEntries[0], &state ); ++i ; convert_xml_file( syntax_dir, StandardOptionsEntry, &state ); } for( ; StandardSourceEntries[i] ; ++i ) { if (( convert_xml_file( syntax_dir, StandardSourceEntries[i], &state ) == True) && ( i == 0 ) ) fprintf( state.dest_fp, "<hr>\n" ); } if( get_flags( doc_class_mask, DOC_CLASS_Options ) ) { end_doc_file( &state ); start_doc_file( dest_dir, doc_path, "_options", doc_type, syntax?syntax->doc_path:NULL, syntax?syntax->display_name:NULL, syntax?syntax->display_purpose:NULL, &state, doc_class_mask, DocClass_Options ); fprintf( state.dest_fp, "<UL>\n" ); } } LOCAL_DEBUG_OUT( "starting config_options%s", "" ); if( syntax && state.dest_fp ) { write_options_header( &state ); write_options_keywords(source_dir, syntax_dir, syntax, &state ); write_options_footer( &state ); } LOCAL_DEBUG_OUT( "done with config_options%s", "" ); if( doc_type != DocType_PHP ) { for( i = OPENING_PARTS_END ; StandardSourceEntries[i] ; ++i ) convert_xml_file( syntax_dir, StandardSourceEntries[i], &state ); }else if( state.dest_fp ) { if( state.doc_class == DocClass_Options ) fprintf( state.dest_fp, "</UL>\n" ); if( get_flags( doc_class_mask, DOC_CLASS_BaseConfig ) ) { end_doc_file( &state ); start_doc_file( dest_dir, doc_path, BaseOptionsEntry, doc_type, syntax?syntax->doc_path:NULL, syntax?syntax->display_name:NULL, syntax?syntax->display_purpose:NULL, &state, doc_class_mask, DocClass_BaseConfig ); convert_xml_file( syntax_dir, BaseOptionsEntry, &state ); } if( get_flags( doc_class_mask, DOC_CLASS_MyStyles ) ) { end_doc_file( &state ); start_doc_file( dest_dir, doc_path, MyStylesOptionsEntry, doc_type, syntax?syntax->doc_path:NULL, syntax?syntax->display_name:NULL, syntax?syntax->display_purpose:NULL, &state, doc_class_mask, DocClass_MyStyles ); convert_xml_file( syntax_dir, MyStylesOptionsEntry, &state ); } } /* FOOTER ***********************************************************************/ end_doc_file( &state ); if( syntax ) add_hash_item( ProcessedSyntaxes, AS_HASHABLE(syntax), NULL ); free( syntax_dir ); }
void check_syntax_source( const char *source_dir, SyntaxDef *syntax, Bool module ) { int i ; char *syntax_dir = NULL ; char *obsolete_dir ; struct direntry **list = NULL; int list_len ; if( syntax ) { if( get_hash_item( ProcessedSyntaxes, AS_HASHABLE(syntax), NULL ) == ASH_Success ) return ; if( syntax->doc_path != NULL && syntax->doc_path[0] != '\0' ) syntax_dir = make_file_name (source_dir, syntax->doc_path); } if( syntax_dir == NULL ) syntax_dir = mystrdup( source_dir ); obsolete_dir = make_file_name (syntax_dir, "obsolete" ); if( CheckDir(syntax_dir) != 0 ) if( !make_doc_dir( syntax_dir ) ) { free( syntax_dir ); return; } if( syntax ) { add_hash_item( ProcessedSyntaxes, AS_HASHABLE(syntax), NULL ); /* pass one: lets see which of the existing files have no related options : */ list_len = my_scandir ((char*)syntax_dir, &list, ignore_dots, NULL); for (i = 0; i < list_len; i++) { int k ; if (!S_ISDIR (list[i]->d_mode)) { char *name = list[i]->d_name ; show_progress( "checking \"%s\" ... ", name ); if( name[0] != '_' ) { for (k = 0; syntax->terms[k].keyword; k++) if( mystrcasecmp(name, syntax->terms[k].keyword ) == 0 ) break; if( syntax->terms[k].keyword == NULL || get_flags( syntax->terms[k].flags, TF_OBSOLETE) ) { /* obsolete option - move it away */ char *obsolete_fname = make_file_name (obsolete_dir, name ); char *fname = make_file_name (syntax_dir, name ); Bool no_dir = False ; if( CheckDir(obsolete_dir) != 0 ) no_dir = !make_doc_dir( obsolete_dir ) ; if( !no_dir ) { copy_file (fname, obsolete_fname); show_progress( "Option \"%s\" is obsolete - moving away!", name ); unlink(fname); } free( fname ); free( obsolete_fname ); } } } free( list[i] ); } if( list ) free (list); /* pass two: lets see which options are missing : */ for (i = 0; syntax->terms[i].keyword; i++) { if( !get_flags( syntax->terms[i].flags, TF_OBSOLETE) ) { SyntaxDef *sub_syntax = syntax->terms[i].sub_syntax ; if( sub_syntax == pPopupFuncSyntax ) sub_syntax = pFuncSyntax ; if (sub_syntax) check_syntax_source( source_dir, sub_syntax, False ); if( isalnum( syntax->terms[i].keyword[0] ) ) check_option_source( syntax_dir, syntax->terms[i].keyword, sub_syntax, module?syntax->doc_path:NULL ) ; } } for (i = module?0:1; StandardSourceEntries[i] != NULL ; ++i) check_option_source( syntax_dir, StandardSourceEntries[i], NULL, module?syntax->doc_path:NULL ) ; if( module ) { check_option_source( syntax_dir, BaseOptionsEntry, NULL, syntax->doc_path ) ; check_option_source( syntax_dir, MyStylesOptionsEntry, NULL, syntax->doc_path ) ; } }else generate_main_source( syntax_dir ); free( obsolete_dir ); free( syntax_dir ); }
int main (int argc, char **argv) { int i ; char *source_dir = NULL ; const char *destination_dir = NULL ; Bool do_data = False; ASDocType target_type = DocType_Source ; /* Save our program name - for error messages */ set_DeadPipe_handler(DeadPipe); InitMyApp (CLASS_ASDOCGEN, argc, argv, NULL, asdocgen_usage, 0 ); LinkAfterStepConfig(); InitSession(); for( i = 1 ; i< argc ; ++i) { LOCAL_DEBUG_OUT( "argv[%d] = \"%s\", original argv[%d] = \"%s\"", i, argv[i]?argv[i]:"(null)", i, MyArgs.saved_argv[i]); if( argv[i] != NULL ) { if( (strcmp( argv[i], "-t" ) == 0 || strcmp( argv[i], "--target" ) == 0) && i+1 < argc && argv[i+1] != NULL ) { ++i ; if( mystrcasecmp( argv[i], "plain" ) == 0 || mystrcasecmp( argv[i], "text" ) == 0) target_type = DocType_Plain ; else if( mystrcasecmp( argv[i], "html" ) == 0 ) target_type = DocType_HTML ; else if( mystrcasecmp( argv[i], "php" ) == 0 ) target_type = DocType_PHP ; else if( mystrcasecmp( argv[i], "xml" ) == 0 ) target_type = DocType_XML ; else if( mystrcasecmp( argv[i], "nroff" ) == 0 ) target_type = DocType_NROFF ; else if( mystrcasecmp( argv[i], "source" ) == 0 ) target_type = DocType_Source ; else show_error( "unknown target type \"%s\"" ); }else if( (strcmp( argv[i], "-s" ) == 0 || strcmp( argv[i], "--css" ) == 0) && i+1 < argc && argv[i+1] != NULL ) { ++i ; HTML_CSS_File = argv[i] ; }else if( strcmp( argv[i], "--faq-css" ) == 0 && i+1 < argc && argv[i+1] != NULL ) { ++i ; FAQ_HTML_CSS_File = argv[i] ; }else if( strcmp( argv[i], "--html-data-back" ) == 0 && i+1 < argc && argv[i+1] != NULL ) { ++i ; if( strcasecmp( argv[i], "none") == 0 ) HTML_DATA_BACKGROUND_File = NULL ; else HTML_DATA_BACKGROUND_File = argv[i] ; }else if( (strcmp( argv[i], "-d" ) == 0 || strcmp( argv[i], "--data" ) == 0) ) { do_data = True ; }else if( (strcmp( argv[i], "-S" ) == 0 || strcmp( argv[i], "--source" ) == 0) && i+1 < argc && argv[i+1] != NULL ) { ++i ; source_dir = argv[i] ; }else if( (strcmp( argv[i], "-D" ) == 0 || strcmp( argv[i], "--dst" ) == 0) && i+1 < argc && argv[i+1] != NULL ) { ++i ; destination_dir = argv[i] ; } } } if( destination_dir == NULL ) destination_dir = do_data?"data":ASDocTypeExtentions[target_type] ; if( source_dir == NULL ) source_dir = do_data?"../../afterstep":"source" ; #if 0 ConnectAfterStep ( mask_reg, 0); SendInfo ( "Nop \"\"", 0); #endif ProcessedSyntaxes = create_ashash( 7, pointer_hash_value, NULL, NULL ); Glossary = create_ashash( 4096, string_hash_value, string_compare, string_destroy ); Index = create_ashash( 4096, string_hash_value, string_compare, string_destroy ); UserLinks = create_ashash( 4096, string_hash_value, string_compare, string_destroy ); APILinks = create_ashash( 4096, string_hash_value, string_compare, string_destroy ); Links = UserLinks; GlossaryName = UserGlossaryName ; TopicIndexName = UserTopicIndexName ; if( target_type < DocType_Source ) { time_t curtime; struct tm *loctime; DocBookVocabulary = create_ashash( 7, casestring_hash_value, casestring_compare, string_destroy_without_data ); for( i = 1 ; i < DOCBOOK_SUPPORTED_IDS ; ++i ) add_hash_item( DocBookVocabulary, AS_HASHABLE(SupportedDocBookTagInfo[i].tag), (void*)(SupportedDocBookTagInfo[i].tag_id)); /* Get the current time. */ curtime = time (NULL); /* Convert it to local time representation. */ loctime = localtime (&curtime); strftime(CurrentDateLong, DATE_SIZE, "%b %e %Y", loctime); strftime(CurrentDateShort, DATE_SIZE, "%m/%d/%Y", loctime); } i = 0 ; LOCAL_DEBUG_OUT( "Starting main action... %s", "" ); if( target_type >= DocType_Source ) /* 1) generate HTML doc structure */ { while( TopLevelSyntaxes[i] ) { /* create directory structure for source docs and all the missing files */ check_syntax_source( source_dir, TopLevelSyntaxes[i], (i >= MODULE_SYNTAX_START) ); ++i ; } check_syntax_source( source_dir, NULL, True ); }else if( do_data ) { char *env_path1 = NULL, *env_path2 = NULL ; ASColorScheme *cs = NULL ; if ((dpy = XOpenDisplay (MyArgs.display_name))) { set_current_X_display (dpy); Scr.MyDisplayWidth = DisplayWidth (dpy, Scr.screen); Scr.MyDisplayHeight = DisplayHeight (dpy, Scr.screen); Scr.asv = create_asvisual (dpy, Scr.screen, DefaultDepth(dpy,Scr.screen), NULL); }else { Scr.asv = create_asvisual(NULL, 0, 32, NULL); } asxml_var_insert("xroot.width", 640); asxml_var_insert("xroot.height", 480); env_path1 = getenv( "IMAGE_PATH" ) ; env_path2 = getenv( "PATH" ); if( env_path1 == NULL ) { env_path1 = env_path2; env_path2 = NULL ; } Scr.image_manager = create_image_manager( NULL, 2.2, env_path1, env_path2, NULL ); set_xml_image_manager( Scr.image_manager ); env_path1 = getenv( "FONT_PATH" ) ; Scr.font_manager = create_font_manager( dpy, env_path1, NULL ); set_xml_font_manager( Scr.font_manager ); /*ReloadASEnvironment( NULL, NULL, NULL, False ); */ cs = make_default_ascolor_scheme(); populate_ascs_colors_rgb( cs ); populate_ascs_colors_xml( cs ); free( cs ); TopicIndexName = NULL ; CurrHtmlBackFile = HTML_DATA_BACKGROUND_File ; gen_data_doc( source_dir, destination_dir?destination_dir:"data", "", "Installed data files - fonts, images and configuration", target_type ); flush_ashash( Glossary ); flush_ashash( Index ); }else { char *api_dest_dir ; api_dest_dir = make_file_name( destination_dir, "API" ); GlossaryName = UserGlossaryName ; TopicIndexName = UserTopicIndexName ; Links = UserLinks; DocGenerationPass = 2 ; while( --DocGenerationPass >= 0 ) { gen_code_doc( "../../libAfterImage", destination_dir, "asimagexml.c", "AfterImage XML", "XML schema to be used for scripting image manipulation by AfterStep and ascompose", target_type ); /* we need to generate some top level files for afterstep itself : */ gen_syntax_doc( source_dir, destination_dir, NULL, target_type ); for( i = 0 ; TopLevelSyntaxes[i] ; ++i ) gen_syntax_doc( source_dir, destination_dir, TopLevelSyntaxes[i], target_type ); if( DocGenerationPass == 0 ) { gen_faq_doc( source_dir, destination_dir, target_type ); gen_glossary( destination_dir, "Glossary", target_type ); gen_index( destination_dir, "index", target_type, True ); } flush_ashash( ProcessedSyntaxes ); } flush_ashash( Glossary ); flush_ashash( Index ); GlossaryName = APIGlossaryName ; TopicIndexName = APITopicIndexName ; Links = APILinks; DocGenerationPass = 2 ; CurrentManType = 3 ; while( --DocGenerationPass >= 0 ) { int s ; for( s = 0 ; libAfterImage_Sources[s].src_file != NULL ; ++s ) { gen_code_doc( "../../libAfterImage", api_dest_dir, libAfterImage_Sources[s].src_file, libAfterImage_Sources[s].descr_short, libAfterImage_Sources[s].descr_long, target_type ); } if( DocGenerationPass == 0 ) { gen_glossary( api_dest_dir, "Glossary", target_type ); gen_index( api_dest_dir, "index", target_type, False ); } flush_ashash( Glossary ); flush_ashash( Index ); } } if( dpy ) XCloseDisplay (dpy); return 0; }
int filehash_get(const unsigned char *path, unsigned char *val) { unsigned long p_hash; unsigned int idx, i, min_i; struct hash_entry *p, *q; FILE *f = 0; unsigned min_tick; ASSERT(path); p_hash = get_hash(path); idx = p_hash % HASH_SIZE; while (hash_table[idx] && hash_table[idx]->path_hash == p_hash && strcmp(hash_table[idx]->path, path) != 0) { idx = (idx + HASH_STEP) % HASH_SIZE; } if (hash_table[idx] && hash_table[idx]->path_hash == p_hash) { // hit! if (!file_stamp_is_updated(path, hash_table[idx]->stamp)) { info("entry <%s> is in hash table and is not changed", path); memcpy(val, hash_table[idx]->sha1_hash, SHA1_SIZE); hash_table[idx]->tick = cur_tick++; return 0; } // update the hash code, maybe removing an item info("entry <%s> is in hash table and is CHANGED!", path); hash_table[idx]->stamp = file_stamp_update(path, hash_table[idx]->stamp); if (!hash_table[idx]->stamp || !(f = fopen(path, "rb")) || sha_stream(f, hash_table[idx]->sha1_hash)) { // file no longer exists or I/O error if (f) fclose(f); p = remove_hash_item(idx); free_hash_item(p); hash_use--; return -1; } // recalculate the hash fclose(f); memcpy(val, hash_table[idx]->sha1_hash, SHA1_SIZE); hash_table[idx]->tick = cur_tick++; return 0; } // no entry in the hash table XCALLOC(p, 1); if (!(p->stamp = file_stamp_get(path)) || !(f = fopen(path, "rb")) || sha_stream(f, p->sha1_hash)) { if (f) fclose(f); free_hash_item(p); return -1; } fclose(f); p->path_hash = p_hash; p->path = xstrdup(path); p->tick = cur_tick++; memcpy(val, p->sha1_hash, SHA1_SIZE); if (hash_use < HASH_CAP) { info("entry <%s> is not in the hash table - adding", path); add_hash_item(p); hash_use++; return 0; } // find the least recently used entry and remove it info("entry <%s> is not in the hash table - REPLACING", path); min_i = -1; min_tick = cur_tick; for (i = 0; i < HASH_SIZE; i++) if (hash_table[i] && hash_table[i]->tick < min_tick) { min_i = i; min_tick = hash_table[i]->tick; } ASSERT(min_i >= 0); q = remove_hash_item(min_i); free_hash_item(q); add_hash_item(p); return 0; }
int dirtree_parse (dirtree_t * tree, const char *file) { FILE *fp; char *str; ASHashTable *exclusions = NULL; ASSERT_TREE_INT(tree,1); if( file == NULL ) return 1 ; if ((fp = fopen (file, "r")) == NULL) return 1; str = safemalloc (8192); while (fgets (str, 8192, fp) != NULL) { char *ptr; Bool do_include = False ; int include_order = 0 ; ptr = strip_whitespace (str); /* ignore comments and blank lines */ if (*ptr == '#' || *ptr == '\0') continue; if( !mystrncasecmp (ptr, "exclude", 7) ) { char *excl_name ; if( exclusions == NULL ) exclusions = create_ashash( 0, casestring_hash_value, casestring_compare, string_destroy ); if( exclusions ) { excl_name = stripcpy2 (ptr +7, 0); add_hash_item( exclusions, AS_HASHABLE(excl_name), NULL ); } continue; } if( !mystrncasecmp (ptr, "category", 8) ) { char *cat_name; Bool include_children = False; ptr+= 8 ; if( *ptr == '_' ) ++ptr ; if( !mystrncasecmp (ptr, "tree", 4)) { include_children = True ; ptr += 4 ; } cat_name = stripcpy2 (ptr, 0); dirtree_add_category_by_name (tree, cat_name, include_children, exclusions); free( cat_name ); continue; } if( !mystrncasecmp (ptr, "include", 7) ) { do_include = True ; ptr += 7 ; if( *ptr == '_' ) ++ptr ; if( !mystrncasecmp (ptr, "ordered", 7) ) { for (ptr += 7; isspace (*ptr); ptr++); if ( isdigit(*ptr) ) { include_order = atoi( ptr ); while( isdigit( *ptr ) ) ++ptr; } } } if( do_include ) { char *path; dirtree_t *t; while(isspace (*ptr)) ptr++; if (*ptr != '"') continue; path = ++ptr; for (; *ptr != '\0' && *ptr != '"'; ptr++); if (*ptr == '"') for (*ptr++ = '\0'; isspace (*ptr); ptr++); path = make_absolute (tree->path, path); t = dirtree_new_from_dir (path); free (path); if (t != NULL) { if (*ptr != '\0') { txt2func (ptr, &t->command, False); dirtree_set_command (t, &t->command, 1); } /* included dir might have a .include */ dirtree_parse_include (t); if( include_order != 0 ) dirtree_set_base_order ( t, include_order); dirtree_move_children (tree, t); dirtree_delete (t); } } else if (!mystrncasecmp (ptr, "keepname", 8)) tree->flags |= DIRTREE_KEEPNAME; else if (!mystrncasecmp (ptr, "ShowUnavailable", 15)) tree->flags |= DIRTREE_SHOW_UNAVAILABLE; else if (!mystrncasecmp (ptr, "extension", 9)) { char *tmp; for (ptr += 9; isspace (*ptr); ptr++); for (tmp = ptr + strlen (ptr); tmp > ptr && isspace (*(tmp - 1)); tmp--); if (tmp != ptr) { if( tree->extension ) free( tree->extension ); tree->extension = mystrndup (ptr, tmp - ptr); } }else if (!mystrncasecmp (ptr, "miniextension", 13)) { char *tmp; for (ptr += 13; isspace (*ptr); ptr++); for (tmp = ptr + strlen (ptr); tmp > ptr && isspace (*(tmp - 1)); tmp--); if (tmp != ptr) tree->minipixmap_extension = mystrndup (ptr, tmp - ptr); } else if (!mystrncasecmp (ptr, "minipixmap", 10) || !mystrncasecmp (ptr, "smallminipixmap", 15)) { if( ptr[0] == 's' || ptr[0] == 'S' ) { set_flags(tree->flags, DIRTREE_ICON_IS_SMALL); ptr += 5 ; }else clear_flags(tree->flags, DIRTREE_ICON_IS_SMALL); set_string(&(tree->icon), stripcpy2(ptr+10,False)); } else if (!mystrncasecmp (ptr, "command", 7)) { for (ptr += 7; isspace (*ptr); ptr++); txt2func (ptr, &tree->command, False); dirtree_set_command (tree, &tree->command, 0); } else if (!mystrncasecmp (ptr, "order", 5)) { tree->order = strtol (ptr + 5, NULL, 10); } else if (!mystrncasecmp (ptr, "RecentSubmenuItems", 18)) { tree->recent_items = strtol (ptr + 18, NULL, 10); tree->flags |= DIRTREE_RECENT_ITEMS_SET; } else if (!mystrncasecmp (ptr, "name", 4)) { set_string(&(tree->name), stripcpy2(ptr+4,False)); clear_flags( tree->flags, DIRTREE_NAME_IS_UTF8 ); }else if (!mystrncasecmp (ptr, "Comment", 7)) { set_string(&(tree->Comment), stripcpy2(ptr+7,False)); clear_flags( tree->flags, DIRTREE_COMMENT_IS_UTF8 ); }else if (!mystrncasecmp (ptr, "FolderReference", 15)) { set_string(&(tree->FolderReference), stripcpy2(ptr+15,False)); dirtree_fill_from_reference( tree, tree->FolderReference ); } } free (str); fclose (fp); return 0; }