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;
}
