build.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "genC.h"
#include "newgen_include.h"

Include dependency graph for build.c:

Go to the source code of this file.

Data Structures
struct	inlinable
	INLINE[] gives, for each inlinable (i.e., unboxed) type, its NAME, its initial VALUE and its printing FORMAT (for each language which can be a target. More...

Functions
	__attribute__ ((__noreturn__))
	FATAL generates a fatal error by printing (according to FORMAT) the given MSG. More...
void	check_not_keyword (char *s)
	CHECK_NOT_KEYWORD checks if S isn't a reserved word. More...
void	init (void)
	INIT initializes global data structures. More...
int	max_domain_index ()
struct gen_binding *	lookup (char *name, int action)
	LOOKUP checks whether a given NAME is in the Domains table. More...
struct gen_binding *	new_binding (char *name, union domain *val)
	NEW_BINDING introduces a new pair (NAME, VAL) in the Domains table. More...
void	print_domainlist (out, l, op)
	PRINT_DOMAINLIST prints, in the OUT stream, the List of domains, bound together by an OPerator. More...
void	print_persistant (out, dp)
void	print_domain (FILE *out, union domain *dp)
	PRINT_DOMAIN prints on the OUT stream a domain denoted by the DP pointer. More...
void	print_domains (FILE *out)
	PRINT_DOMAINS prints on the OUT stream the Domains table. More...
void	reconnect (int op, union domain *dp)
void	compile (void)
	COMPILE reconnects the Domains table (for not compiled types – note that an inlined type is already compiled). More...
void	gen_write_spec (char *filename)
	GEN_WRITE_SPEC prints the Domains table in the given FILENAME. More...
int	build (int argc, char *argv[])
	BUILD (in fact, the "main" function) parses the specifications and generates the manipulation functions. More...
char *	alloc (int size)
	ALLOC is an "iron-clad" version of malloc(3). More...

Variables
static char *	keywords []
int	Current_op
	Used to check, while parsing specs, that a constructed domain use only one operator type. More...
int	Current_start
static char *	Op_names []
	Warning: this table knows about the actual values used for AND_OP and OR_OP. More...
int	error_seen
	Have we seen a user error somewhere ? More...
static int	max_domain = -1
static int	current_first
	RECONNECT replaces the (STRUCT BINDING *) members of the DP domain which are, on entry, strings by their effective values, i.e. More...

Function Documentation

__attribute__()

__attribute__

(

(__noreturn__)

)

FATAL generates a fatal error by printing (according to FORMAT) the given MSG.

USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.

If there already is a user error, let's suppose that's her fault !

Definition at line 82 of file build.c.

{
    va_list args;
    va_start(args, fmt);
    fprintf( stderr, "\nNewgen Fatal Error -- " ) ;
    vfprintf( stderr, fmt, args) ;
    va_end(args);
 
    abort() ;
}

References abort, and fprintf().

Here is the call graph for this function:

alloc()

char* alloc

(

int

size

)

ALLOC is an "iron-clad" version of malloc(3).

Definition at line 501 of file build.c.

{
    char * p;
 
    if( (p=malloc( (unsigned)size )) == NULL && size != 0)
            fatal( "alloc: No more memory for %s bytes\n", i2a( size )) ;
  
    return p;
}

References fatal(), i2a(), and malloc().

Referenced by chunk_for_domain(), copy_obj_in(), freia_memory_management_statement(), gen_alloc(), gen_cons(), gen_copy_array(), gen_copy_list(), gen_init_tabulated(), gen_make_array(), gen_sort_list(), gtt_make(), hash_enlarge_table(), hash_map_put(), hash_table_generic_make(), init_array(), make_ref(), new_local_image_variable(), push_gen_trav_env(), and set_generic_make().

Here is the call graph for this function:

Here is the caller graph for this function:

build()

int build	(	int	argc,
		char *	argv[]
	)

BUILD (in fact, the "main" function) parses the specifications and generates the manipulation functions.

RGSUSED

Definition at line 483 of file build.c.

{
  init();
  genspec_parse();
  compile();
  
  if (error_seen == 0) {
    if (argc<3)
      user("not enough arguments provided, need 3, got %d!", argc);
    gencode(argv[1]);
    gen_write_spec(argv[2]);
    return 0;
  }
  return 1;
}

References compile(), error_seen, gen_write_spec(), gencode(), genspec_parse(), init(), and user().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

check_not_keyword()

void check_not_keyword

(

char *

s

)

CHECK_NOT_KEYWORD checks if S isn't a reserved word.

Definition at line 117 of file build.c.

{
  char **sp ;
 
  for( sp = keywords ; *sp != NULL ; sp++ ) {
    if( strcmp( s, *sp ) == 0 ) {
            user( "Trying to use the reserved word %s\n", s ) ;
    }
  }
}

References keywords, and user().

Here is the call graph for this function:

compile()

void compile

(

void

)

COMPILE reconnects the Domains table (for not compiled types – note that an inlined type is already compiled).

set size of domain.

Definition at line 422 of file build.c.

{
  int i;
  current_first = 0;
  
  for(i=0; i<MAX_DOMAIN; i++)
  {
    struct gen_binding * bp = &Domains[i];
    
    if( bp->name == NULL || bp->compiled || bp == Tabulated_bp )
      continue ;
    
    reconnect( -1, bp->domain ) ;
    bp->compiled = (bp->domain->ba.type != EXTERNAL_DT ) ;
    
    if( IS_TABULATED( bp )) {
      union domain *dp = NULL;
      
      if( !(bp->domain->ba.type == CONSTRUCTED_DT &&
            (dp=bp->domain->co.components->domain)->ba.type == BASIS_DT &&
            strcmp( dp->ba.constructand->name, "string" ) == 0)) {
        user( "compile: tabulated first %s domain isn't string\n",
              dp->ba.constructand->name ) ;
      }
    }
    
    /* set size of domain. */
    if (bp->domain->ba.type == BASIS_DT ||
        bp->domain->ba.type == ARRAY_DT ||
        bp->domain->ba.type == SET_DT ||
        bp->domain->ba.type == LIST_DT ||
        bp->domain->ba.type == CONSTRUCTED_DT)
      bp->size = gen_size(i);
  }
 
#ifdef DBG_COMPILE
  print_domains( stderr ) ;
#endif
}

References ARRAY_DT, domain::ba, BASIS_DT, domain::co, gen_binding::compiled, domain::components, domain::constructand, CONSTRUCTED_DT, current_first, gen_binding::domain, Domains, EXTERNAL_DT, gen_size(), IS_TABULATED, LIST_DT, MAX_DOMAIN, gen_binding::name, print_domains(), reconnect(), SET_DT, gen_binding::size, Tabulated_bp, domain::type, and user().

Referenced by build(), gen_read_spec(), and opencl_compile_mergeable_dag().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_write_spec()

void gen_write_spec

(

char *

filename

)

GEN_WRITE_SPEC prints the Domains table in the given FILENAME.

Definition at line 464 of file build.c.

{
    extern int fclose();
    FILE *id ;
 
    if( (id = fopen( filename, "w" )) == NULL ) {
        user( "Cannot open spec file %s in write mode\n", filename ) ;
        return ;
    }
    print_domains( id ) ;
 
    if( fclose( id )) 
      user( "Cannot close spec file %s\n", filename ) ;
}

References domain::filename, print_domains(), return(), and user().

Referenced by build().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void init

(

void

)

INIT initializes global data structures.

FC: formats are directly inlined in genClib...

Tabulated_bp hack is statically allocated here.

Definition at line 130 of file build.c.

{
    struct gen_binding *bp ;
    struct inlinable *ip ;
 
    /* FC: formats are directly inlined in genClib...
     */
    struct inlinable Inline[] = {
      {UNIT_TYPE_NAME, "U", "U", ":unit", "U"},
      {"bool", "1", "B%d", "newgen:gen-true", "~S"},
      {"char", "#\\a", "#\\%c", "#\\space", "~C"},
      {"int", "0", "%d", "0", "~D"},
      {"float", "0.0", "%f", "0.0", "~F"},
      {"string", "\"\"", "\"%s\"", "\"\"", "~S"},
      {NULL, "-- HELP --", "-- HELP --", "-- HELP --", "-- HELP --"},
    } ;
 
    for( bp = Domains ; bp < &Domains[ MAX_DOMAIN ] ; bp++ ) {
        bp->name = NULL ;
        bp->compiled = 0 ;
        bp->size = 0 ; 
        bp->tabulated = NULL;
        bp->domain = NULL ;
        bp->inlined = NULL ;
    }
 
    for( ip = Inline, bp = Domains ; ip->name != NULL ; ip++, bp++ ) {
        bp->name = ip->name ;
        bp->compiled = 1 ;
        bp->inlined = ip ;
    }
 
    /* Tabulated_bp hack is statically allocated here. */
    {
      static union domain d ;
      bp->name = "Name for tabulated domain" ;
      bp->domain = &d ;
      d.ba.type = ARRAY_DT ;
      d.ar.constructor = "Constructor for tabulated domain" ;
      d.ar.element = (struct gen_binding *) NULL ;
      d.ar.dimensions = (struct intlist *) NULL;
      Tabulated_bp = bp ;
    }
    
    Current_op = UNDEF_OP ;
    Current_start = -1 ;
    error_seen = 0 ;
}

References domain::ar, ARRAY_DT, domain::ba, gen_binding::compiled, domain::constructor, Current_op, Current_start, domain::dimensions, gen_binding::domain, Domains, domain::element, error_seen, gen_binding::inlined, MAX_DOMAIN, inlinable::name, gen_binding::name, gen_binding::size, gen_binding::tabulated, Tabulated_bp, domain::type, UNDEF_OP, and UNIT_TYPE_NAME.

Referenced by build().

Here is the caller graph for this function:

lookup()

struct gen_binding* lookup	(	char *	name,
		int	action
	)

LOOKUP checks whether a given NAME is in the Domains table.

If not, the ACTION says whether this is an error or it should be introduced. If this is for a new gen_binding, look in the current allocation range, else from beginning

Definition at line 191 of file build.c.

{
    struct gen_binding *bp ;
 
    //bp = (action == NEW_BINDING) ? Tabulated_bp+Current_start+1 : Domains ;
    bp = Domains + ((action == NEW_BINDING) ? Current_start : 0);
 
    for( ; bp < &Domains[ MAX_DOMAIN ] ; bp++ ) {
        if( bp->name == NULL ) {
            if( action == NEW_BINDING )
                    break ;
        }
        else if( strcmp( bp->name, name ) == 0 ) break ;
    }
    switch( action ) {
    case NEW_BINDING:
        if( bp == &Domains[ MAX_DOMAIN ] )
                fatal( "lookup: Domains overflow on %s -- new\n", name ) ;
 
        break;
    case OLD_BINDING:
        if( bp == &Domains[ MAX_DOMAIN ] )
                user( "Unknown domain <%s>\n", name ) ;
 
        break ;
    default:
        fatal( "lookup: Unknown type %s\n", i2a( action )) ;
    }
    if( max_domain < bp-Domains ) {
        max_domain = bp-Domains ;
    }
    return( bp ) ;
}

References Current_start, Domains, fatal(), i2a(), max_domain, MAX_DOMAIN, gen_binding::name, NEW_BINDING, OLD_BINDING, and user().

Referenced by new_binding(), and reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

max_domain_index()

int max_domain_index

(

)

Definition at line 181 of file build.c.

{
  return max_domain;
}

References max_domain.

Referenced by gen_check().

Here is the caller graph for this function:

new_binding()

struct gen_binding* new_binding	(	char *	name,
		union domain *	val
	)

NEW_BINDING introduces a new pair (NAME, VAL) in the Domains table.

Redeclaration is allowed if this is to overwrite a previous IMPORT definition. Note that we could (should ?) check that this new gen_binding isn't a new (and incompatible) IMPORT definition.

Definition at line 230 of file build.c.

{
    struct gen_binding * bp;
 
    if( Read_spec_mode && val->ba.type ==  IMPORT_DT ) {
        bp = lookup(name, OLD_BINDING);
    }
    else {
        bp = lookup(name, NEW_BINDING);
    }
    if( bp->domain == NULL ) {
#ifdef DBG_BINDING
        (void)fprintf(stderr, "Introducing %s at index %d\n", 
                      name, bp-Domains ) ;
#endif
        bp->domain = val ;
        bp->name = name ;
    }
    else
    {
        if( val->ba.type == IMPORT_DT || 
            (Read_spec_mode && val->ba.type == EXTERNAL_DT )) {
        }
        else 
            user( "Redeclaration skipped: <%s>\n", name ) ;
        free(val);
    }
 
    return( bp ) ;
}

References domain::ba, gen_binding::domain, Domains, EXTERNAL_DT, fprintf(), free(), IMPORT_DT, lookup(), gen_binding::name, NEW_BINDING, OLD_BINDING, Read_spec_mode, domain::type, and user().

Here is the call graph for this function:

print_domain()

void print_domain	(	FILE *	out,
		union domain *	dp
	)

PRINT_DOMAIN prints on the OUT stream a domain denoted by the DP pointer.

This is done before the compilation so (STRUCT BINDING *) members are still strings.

Definition at line 294 of file build.c.

{
    if (!dp) {
        fprintf(out, " NULL union domain");
        return;
    }
 
    switch( dp->ba.type ) {
    case EXTERNAL_DT:
        break ;
    case IMPORT_DT:
        (void)fprintf( out, " from \"%s\"", dp->im.filename ) ;
        break ;
    case BASIS_DT:
        (void)print_persistant( out, dp ) ;
#ifdef DBG_DOMAINS
        (void)fprintf( out, "%s:%s (%d)", 
                      dp->ba.constructor, dp->ba.constructand->name,
                      dp->ba.constructand-Domains ) ;
#else
        (void)fprintf(out, "%s:%s", 
                      dp->ba.constructor, dp->ba.constructand->name );
#endif
        break ;
    case LIST_DT:
        print_persistant( out, dp ) ;
        (void)fprintf(out, "%s:%s*", 
                      dp->li.constructor, dp->li.element->name ) ;
        break ;
    case SET_DT:
        print_persistant( out, dp ) ;
        (void)fprintf(out, "%s:%s{}", 
                      dp->se.constructor, dp->se.element->name ) ;
        break ;
    case ARRAY_DT: {
        struct intlist *ilp ;
 
        print_persistant( out, dp ) ;
        (void)fprintf(out, "%s:%s", 
                      dp->ar.constructor, dp->ar.element->name ) ;
 
        for( ilp = dp->ar.dimensions ; ilp != NULL ; ilp = ilp->cdr ) 
                (void)fprintf( out, "[%d]", ilp->val ) ;
 
        break ;
    }
    case CONSTRUCTED_DT:
        print_domainlist( out, dp->co.components, dp->co.op ) ;
        break ;
    default:
        fatal( "print_domain: switch on %s\n", i2a( dp->ba.type )) ;
    }
}

References domain::ar, ARRAY_DT, domain::ba, BASIS_DT, domain::co, domain::components, domain::constructand, CONSTRUCTED_DT, domain::constructor, domain::dimensions, Domains, domain::element, EXTERNAL_DT, fatal(), domain::filename, fprintf(), i2a(), domain::im, IMPORT_DT, domain::li, LIST_DT, gen_binding::name, domain::op, out, print_domainlist(), print_persistant(), domain::se, SET_DT, and domain::type.

Referenced by defined_null(), gen_trav_obj(), gen_trav_simple(), print_domainlist(), and print_domains().

Here is the call graph for this function:

Here is the caller graph for this function:

print_domainlist()

void print_domainlist	(	out	,
		l	,
		op
	)

PRINT_DOMAINLIST prints, in the OUT stream, the List of domains, bound together by an OPerator.

Definition at line 265 of file build.c.

{
  if( l == NULL )
    fatal( "print_domainlist: null", "" ) ;
 
  for( ; l->cdr != NULL ; l = l->cdr ) {
    print_domain( out, l->domain ) ;
    (void)fprintf( out, " %s ", Op_names[ op ] ) ;
  }
  print_domain( out, l->domain ) ;
}

References fatal(), fprintf(), Op_names, out, and print_domain().

Referenced by print_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

print_domains()

void print_domains

(

FILE *

out

)

PRINT_DOMAINS prints on the OUT stream the Domains table.

Inlined domains aren't printed.

if( (dp=bp->domain)->ba.type==CONSTRUCTED_DT && dp->co.op==OR_OP) (void)fprintf( out, "--NEWGEN-FIRST %d\n", dp->co.first ) ;

Definition at line 352 of file build.c.

{
    struct gen_binding *bp ;
 
    for( bp = Domains ; bp < &Domains[ MAX_DOMAIN ] ; bp++ ) {
        if( bp->name == NULL || bp == Tabulated_bp ) continue ;
 
        if( !IS_INLINABLE( bp )) {
 
          /* if( (dp=bp->domain)->ba.type==CONSTRUCTED_DT && dp->co.op==OR_OP)
             (void)fprintf( out, "--NEWGEN-FIRST %d\n", dp->co.first ) ; */
 
            (void)fprintf( out, 
                    (IS_EXTERNAL( bp ) ? "external %s" : 
                     IS_IMPORT( bp ) ? "import %s" :
                     IS_TABULATED( bp ) ? "tabulated %s = " :
                     "%s = "), 
                    bp->name ) ;
            print_domain( out, bp->domain ) ;
            (void)fprintf( out, ";\n" ) ;
        }
    }
}

References gen_binding::domain, Domains, fprintf(), IS_EXTERNAL, IS_IMPORT, IS_INLINABLE, IS_TABULATED, MAX_DOMAIN, gen_binding::name, out, print_domain(), and Tabulated_bp.

Referenced by compile(), and gen_write_spec().

Here is the call graph for this function:

Here is the caller graph for this function:

print_persistant()

void print_persistant	(	out	,
		dp
	)

Definition at line 281 of file build.c.

{
    if( dp->ba.persistant ) {
        (void)fprintf( out, "persistant " ) ;
    }
}

References domain::ba, fprintf(), out, and domain::persistant.

Referenced by print_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

reconnect()

void reconnect	(	int	op,
		union domain *	dp
	)

Definition at line 384 of file build.c.

{
    struct domainlist *dlp ;
 
    if( op == OR_OP ) current_first++ ;
 
    switch( dp->ba.type ) {
    case EXTERNAL_DT:
    case IMPORT_DT:
        return ;
    case BASIS_DT:
        dp->ba.constructand = lookup( (char *)dp->ba.constructand, OLD_BINDING ) ;
        break;
    case LIST_DT:
        dp->li.element = lookup( (char *)dp->li.element, OLD_BINDING ) ;
        break ;
    case SET_DT:
        dp->se.element = lookup( (char *)dp->se.element, OLD_BINDING ) ;
        break ;
    case ARRAY_DT:
        dp->ar.element = lookup( (char *)dp->ar.element, OLD_BINDING ) ;
        break ;
    case CONSTRUCTED_DT: 
        if( dp->co.op == OR_OP && !Read_spec_mode ) 
                dp->co.first = current_first ;
 
        for( dlp = dp->co.components ; dlp != NULL ; dlp = dlp->cdr ) {
            reconnect( dp->co.op, dlp->domain ) ;
        }
        return ;
    default:
        fatal( "reconnect: switch on %s\n", i2a( dp->ba.type )) ;
    }
}

References domain::ar, ARRAY_DT, domain::ba, BASIS_DT, domain::co, domain::components, domain::constructand, CONSTRUCTED_DT, current_first, domain::element, EXTERNAL_DT, fatal(), domain::first, i2a(), IMPORT_DT, domain::li, LIST_DT, lookup(), OLD_BINDING, domain::op, OR_OP, Read_spec_mode, return(), domain::se, SET_DT, and domain::type.

Referenced by compile().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

current_first

int current_first

static

RECONNECT replaces the (STRUCT BINDING *) members of the DP domain which are, on entry, strings by their effective values, i.e.

pointers in the Domains table which have the corresponding names.

FIRST members for OR_OP (checked with OP) domains are updated.

Definition at line 382 of file build.c.

Referenced by compile(), and reconnect().

Current_op

int Current_op

Used to check, while parsing specs, that a constructed domain use only one operator type.

Definition at line 62 of file build.c.

Referenced by init(), and update_op().

Current_start

int Current_start

Definition at line 62 of file build.c.

Referenced by init(), and lookup().

error_seen

int error_seen

Have we seen a user error somewhere ?

Definition at line 76 of file build.c.

Referenced by build(), gen_consistent_p(), gen_defined_p(), and init().

keywords

char* keywords[]

static

Initial value:

= {
    "external",
    "import",
    "tabulated",
    "from",
    "persistant",
    NULL
}

Definition at line 53 of file build.c.

Referenced by check_not_keyword().

max_domain

int max_domain = -1

static

Definition at line 179 of file build.c.

Referenced by lookup(), and max_domain_index().

Op_names

char* Op_names[]

static

Initial value:

= {
  "-- shouldn't appear --",
  "x",
  "+",
  "->"
  }

Warning: this table knows about the actual values used for AND_OP and OR_OP.

Definition at line 67 of file build.c.

Referenced by print_domainlist().