builtins.c

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

	LIST *l;

	for( l = targets; l; l = list_next( l ) )
	{
	    TARGET *t = bindtarget( l->string );
	    t->rebuilds = targetlist( t->rebuilds, rebuilds );
	}

	return L0;
}

/*
 * builtin_echo() - ECHO rule
 *
 * The ECHO builtin rule echoes the targets to the user.  No other 
 * actions are taken.
 */

LIST *
builtin_echo(
	PARSE	*parse,
	FRAME *frame )
{
	list_print( lol_get( frame->args, 0 ) );
	printf( "\n" );
	return L0;
}

/*
 * builtin_exit() - EXIT rule
 *
 * The EXIT builtin rule echoes the targets to the user and exits
 * the program with a failure status.
 */

LIST *
builtin_exit(
    PARSE   *parse,
    FRAME   *frame )
{
    list_print( lol_get( frame->args, 0 ) );
    printf( "\n" );
    if ( lol_get( frame->args, 1 ) )
    {
        exit ( atoi( lol_get( frame->args, 1 )->string ) );
    }
    else
    {
        exit( EXITBAD ); /* yeech */
    }
    return L0;
}

/*
 * builtin_flags() - NOCARE, NOTFILE, TEMPORARY rule
 *
 * Builtin_flags() marks the target with the appropriate flag, for use
 * by make0().  It binds each target as a TARGET.
 */

LIST *
builtin_flags(
	PARSE	*parse,
	FRAME *frame )
{
	LIST *l = lol_get( frame->args, 0 );

	for( ; l; l = list_next( l ) )
	    bindtarget( l->string )->flags |= parse->num;

	return L0;
}

/*
 * builtin_globbing() - GLOB rule
 */

struct globbing {
    LIST    *patterns;
    LIST    *results;
    LIST    *case_insensitive;
} ;

static void downcase_inplace( char* p )
{
    for ( ; *p; ++p )
    {
        *p = tolower(*p);
    }
}
    
static void
builtin_glob_back(
    void    *closure,
    char    *file,
    int status,
    time_t  time )
{
    PROFILE_ENTER(BUILTIN_GLOB_BACK);
    
    struct globbing *globbing = (struct globbing *)closure;
    LIST        *l;
    PATHNAME    f;
    string          buf[1];
    
    /* Null out directory for matching. */
    /* We wish we had file_dirscan() pass up a PATHNAME. */

    path_parse( file, &f );
    f.f_dir.len = 0;

    /* For globbing, we unconditionally ignore current and parent
       directory items. Since they items always exist, there's not
       reason why caller of GLOB would want to see them.
       We could also change file_dirscan, but then paths with embedded
       "." and ".." won't work anywhere.
    */
    if (strcmp(f.f_base.ptr, ".") == 0 || strcmp(f.f_base.ptr, "..") == 0)
    {
        PROFILE_EXIT(BUILTIN_GLOB_BACK);
        return;
    }

    string_new( buf );
    path_build( &f, buf, 0 );

    if (globbing->case_insensitive) {
        downcase_inplace( buf->value );
    }

    for( l = globbing->patterns; l; l = l->next )
    {
        if( !glob( l->string, buf->value ) )
        {
            globbing->results = list_new( globbing->results, newstr( file ) );
            break;
        }
    }
    
    string_free( buf );
    
    PROFILE_EXIT(BUILTIN_GLOB_BACK);
}

static LIST* downcase_list( LIST *in )
{
    LIST* result = 0;
    
    string s[1];
    string_new( s );
        
    while (in)
    {
        string_copy( s, in->string );
        downcase_inplace( s->value );
        result = list_append( result, list_new( 0, newstr( s->value ) ) );
        in = in->next;
    }
    
    string_free( s );
    return result;
}

LIST *
builtin_glob(
    PARSE   *parse,
    FRAME *frame )
{
    LIST *l = lol_get( frame->args, 0 );
    LIST *r = lol_get( frame->args, 1 );
    
    struct globbing globbing;

    globbing.results = L0;
    globbing.patterns = r;
    
    globbing.case_insensitive
# if defined( OS_NT ) || defined( OS_CYGWIN )
       = l;  /* always case-insensitive if any files can be found */
# else 
       = lol_get( frame->args, 2 );
# endif

    if ( globbing.case_insensitive )
    {
        globbing.patterns = downcase_list( r );
    }
    
    for( ; l; l = list_next( l ) )
        file_dirscan( l->string, builtin_glob_back, &globbing );

    if ( globbing.case_insensitive )
    {
        list_free( globbing.patterns );
    }
    return globbing.results;
}

static int has_wildcards(const char* str)
{
    size_t index = strcspn(str, "[]*?");
    if (str[index] == '\0')
        return 0;
    else
        return 1;
}

/** If 'file' exists, append 'file' to 'list'.
    Returns 'list'.
*/
static LIST* append_if_exists(LIST* list, char* file)
{
    time_t time;
    timestamp(file, &time);
    if (time > 0)
        return list_new(list, newstr(file));
    else
        return list;        
}

LIST* glob1(char* dirname, char* pattern)
{
    LIST* plist = list_new(L0, pattern);
    struct globbing globbing;

    globbing.results = L0;
    globbing.patterns = plist;
    
    globbing.case_insensitive
# if defined( OS_NT ) || defined( OS_CYGWIN )
       = plist;  /* always case-insensitive if any files can be found */
# else 
       = L0;
# endif

    if ( globbing.case_insensitive )
    {
        globbing.patterns = downcase_list( plist );
    }
    
    file_dirscan( dirname, builtin_glob_back, &globbing );

    if ( globbing.case_insensitive )
    {
        list_free( globbing.patterns );
    }

    list_free(plist);

    return globbing.results;
}


LIST* glob_recursive(char* pattern)
{
    LIST* result = L0;

    /* Check if there's metacharacters in pattern */
    if (!has_wildcards(pattern))
    {
        /* No metacharacters. Check if the path exists. */
        result = append_if_exists(result, pattern);
    }        
    else
    {
        /* Have metacharacters in the pattern. Split into dir/name */
        PATHNAME path[1];
        path_parse(pattern, path);            
        
        if (path->f_dir.ptr)
        {
            LIST* dirs = L0;
            string dirname[1];
            string basename[1];
            string_new(dirname);
            string_new(basename);

            string_append_range(dirname, path->f_dir.ptr, 
                                path->f_dir.ptr + path->f_dir.len);

            path->f_grist.ptr = 0;
            path->f_grist.len = 0;
            path->f_dir.ptr = 0;
            path->f_dir.len = 0;
            path_build(path, basename, 0);

            if (has_wildcards(dirname->value))
            {
                dirs = glob_recursive(dirname->value);
            }
            else
            {
                dirs = list_new(dirs, dirname->value);
            }
            
            if (has_wildcards(basename->value))
            {
                for(; dirs; dirs = dirs->next)
                {
                    result = list_append(result, 
                                         glob1(dirs->string, basename->value));
                }
            }
            else
            {
                string file_string[1];
                string_new(file_string);

                /** No wildcard in basename. */
                for(; dirs; dirs = dirs->next)
                {                                      
                    path->f_dir.ptr = dirs->string;
                    path->f_dir.len = strlen(dirs->string);                    
                    path_build(path, file_string, 0);

                    result = append_if_exists(result, file_string->value);

                    string_truncate(file_string, 0);
                }

                string_free(file_string);
            }

            string_free(dirname);
            string_free(basename);
        }
        else
        {
            /** No directory, just a pattern. */
            result = list_append(result, glob1(".", pattern));
        }
    }

    return result;
}

LIST *
builtin_glob_recursive(
    PARSE   *parse,
    FRAME *frame )
{
    LIST* result = L0;
    LIST* l = lol_get( frame->args, 0 );

    for(; l; l = l->next)
    {
        result = list_append(result, glob_recursive(l->string));
    }

    return result;
}

/*
 * builtin_match() - MATCH rule, regexp matching
 */

LIST *
builtin_match(
	PARSE	*parse,
	FRAME	*frame )
{
	LIST *l, *r;
	LIST *result = 0;
        
        string buf[1];
        string_new(buf);

	/* For each pattern */

	for( l = lol_get( frame->args, 0 ); l; l = l->next )
	{
            /* Result is cached and intentionally never freed */
	    regexp *re = regex_compile( l->string );

	    /* For each string to match against */
            for( r = lol_get( frame->args, 1 ); r; r = r->next )
            {
                if( regexec( re, r->string ) )
                {
                    int i, top;

                    /* Find highest parameter */

                    for( top = NSUBEXP; top-- > 1; )
                        if( re->startp[top] )
                            break;

                    /* And add all parameters up to highest onto list. */
                    /* Must have parameters to have results! */

                    for( i = 1; i <= top; i++ )
                    {
                        string_append_range( buf, re->startp[i], re->endp[i] );
                        result = list_new( result, newstr( buf->value ) );
                        string_truncate( buf, 0 );
                    }
                }
            }
        }

        string_free( buf );
        return result;
}

LIST *
builtin_hdrmacro(
    PARSE    *parse,
    FRAME *frame )
{
  LIST*  l = lol_get( frame->args, 0 );
  
  for ( ; l; l = list_next(l) )
  {
    TARGET*  t = bindtarget( l->string );

    /* scan file for header filename macro definitions */    
    if ( DEBUG_HEADER )
      printf( "scanning '%s' for header file macro definitions\n",
              l->string );

    macro_headers( t );
  }
  
  return L0;
}

/*  builtin_rulenames() - RULENAMES ( MODULE ? )
 *
 *  Returns a list of the non-local rule names in the given MODULE. If
 *  MODULE is not supplied, returns the list of rule names in the
 *  global module.
 */

/* helper function for builtin_rulenames(), below */
static void add_rule_name( void* r_, void* result_ )
{
    RULE* r = (RULE*)r_;
    LIST** result = (LIST**)result_;

    if ( r->exported )
        *result = list_new( *result, copystr( r->name ) );
}

LIST *
builtin_rulenames(
    PARSE   *parse,
    FRAME *frame )
{
    LIST *arg0 = lol_get( frame->args, 0 );
    LIST *result = L0;
    module_t* source_module = bindmodule( arg0 ? arg0->string : 0 );

    if ( source_module->rules )
        hashenumerate( source_module->rules, add_rule_name, &result );
    return result;
}

/*  builtin_varnames() - VARNAMES ( MODULE ? )
 *
 *  Returns a list of the variable names in the given MODULE. If
 *  MODULE is not supplied, returns the list of variable names in the
 *  global module.
 */

/* helper function for builtin_varnames(), below.  Used with
 * hashenumerate, will prepend the key of each element to a list
 */
static void add_hash_key( void* np, void* result_ )
{
    LIST** result = (LIST**)result_;