genSML.c File Reference

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "newgen_include.h"
#include "genC.h"

Include dependency graph for genSML.c:

Go to the source code of this file.

Macros
#define	GEN_HEADER   2
	For simplicity, the tabulation slot is always here. More...
#define	IS_NON_INLINABLE_BASIS(f)   (strcmp(f,"chunk")==0)
#define	UPPER(c)   ((islower( c )) ? toupper( c ) : c )
#define	TYPE(bp)   (bp-Domains-Number_imports-Current_start)
#define	OR_TAG_OFFSET   2

Functions
int	gen_size (bp)
	GEN_SIZE returns the size (in gen_chunks) of an object of type defined by the BP type. More...
static char *	primitive_field (dp)
	PRIMITIVE_FIELD returns the appropriate field to acces an object in BP. More...
static void	gen_member (name, dp, offset)
	GEN_MEMBER generates a member access functions for domain DP and OFFSET. More...
static char *	gen_arg (dp)
	GEN_ARG returns the constructor name of domain DP. More...
static char *	gen_args (dlp)
	GEN_ARGS returns a comma-separated list of constructor names for the list of domains DLP. More...
static char *	gen_update_arg (dp, index)
static char *	gen_update_args (dlp)
	GEN_UPDATE_ARGS returns a comma-separated list of constructor names for the list of domains DLP. More...
static void	gen_make (bp, size, char *args, char *updated_args, char *option_name)
	GEN_MAKE generates the gen_alloc call for gen_bindings BD with SIZE user members and ARGS as list of arguments. More...
void	gen_and (bp)
	GEN_AND generates the manipulation functions for an AND type BP. More...
void	gen_or (bp)
	GEN_OR generates the manipulation function for an OR_OP type BP. More...
void	gen_list (bp)
	GEN_LIST defines the manipulation functions for a list type BP. More...
void	gen_set (bp)
	GEN_SET defines the manipulation functions for a set type BP. More...
void	gen_array (bp)
	GEN_ARRAY defines the manipulation functions for an array type BP. More...
void	gen_external (bp)
	GEN_EXTERNAL defines the acces functions for an external type BP. More...
void	gen_domain (bp)
	GEN_DOMAIN generates the manipulation functions for a type BP. More...
void	gencode (file)
	GENCODE generates the code necessary to manipulate every internal and non-inlinable type in the Domains table. More...

Variables
static char	start [1024]
int	Read_spec_mode
	extern int Current_first ; More...
struct gen_binding *	Tabulated_bp

Macro Definition Documentation

GEN_HEADER

#define GEN_HEADER   2

For simplicity, the tabulation slot is always here.

Definition at line 34 of file genSML.c.

IS_NON_INLINABLE_BASIS

#define IS_NON_INLINABLE_BASIS

(

f

)

(strcmp(f,"chunk")==0)

Definition at line 36 of file genSML.c.

OR_TAG_OFFSET

#define OR_TAG_OFFSET   2

Definition at line 40 of file genSML.c.

TYPE

#define TYPE

(

bp

)

(bp-Domains-Number_imports-Current_start)

Definition at line 38 of file genSML.c.

UPPER

#define UPPER

(

c

)

((islower( c )) ? toupper( c ) : c )

Definition at line 37 of file genSML.c.

Function Documentation

gen_and()

void gen_and

(

bp

)

GEN_AND generates the manipulation functions for an AND type BP.

Definition at line 230 of file genSML.c.

{
    union domain *dom = bp->domain ;
    struct domainlist *dlp ;
    int size ;
 
    gen_make(bp, gen_size(bp)-GEN_HEADER,
             gen_args(dom->co.components), 
             gen_update_args(dom->co.components),
             "") ;
    size = GEN_HEADER ;
 
    for( dlp=dom->co.components ; dlp != NULL ; dlp=dlp->cdr )
            gen_member( bp->name, dlp->domain, size++ ) ;
}

References domain::co, domain::components, gen_binding::domain, gen_args(), GEN_HEADER, gen_make(), gen_member(), gen_size(), gen_update_args(), and gen_binding::name.

Referenced by gen_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_arg()

static char* gen_arg ( dp  )

static

GEN_ARG returns the constructor name of domain DP.

Definition at line 141 of file genSML.c.

{
    return( (dp->ba.type == BASIS_DT) ? dp->ba.constructor :
            (dp->ba.type == LIST_DT) ? dp->li.constructor :
            (dp->ba.type == SET_DT) ? dp->se.constructor :
            (dp->ba.type == ARRAY_DT) ? dp->ar.constructor :
            (fatal( "gen_arg: Unknown type %s\n", i2a( dp->ba.type )), 
             (char *)NULL) ) ;
}

References domain::ar, ARRAY_DT, domain::ba, BASIS_DT, domain::constructor, fatal(), i2a(), domain::li, LIST_DT, domain::se, SET_DT, and domain::type.

Referenced by gen_args(), and gen_update_arg().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_args()

static char* gen_args ( dlp  )

static

GEN_ARGS returns a comma-separated list of constructor names for the list of domains DLP.

Definition at line 156 of file genSML.c.

{
    static char buffer[ 1024 ] ;
 
    for( sprintf( buffer, "" ) ; dlp->cdr != NULL ; dlp = dlp->cdr ) {
        strcat( buffer, gen_arg( dlp->domain )) ;
        strcat( buffer, ", " )  ;
    }
    strcat( buffer, gen_arg( dlp->domain )) ;
    return( buffer ) ;
}

References buffer, and gen_arg().

Referenced by gen_and().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_array()

void gen_array

(

bp

)

GEN_ARRAY defines the manipulation functions for an array type BP.

Definition at line 314 of file genSML.c.

{
    extern int printf();
    char *name = bp->name ;
    union domain *dom = bp->domain ;
    int data = GEN_HEADER ;
 
    gen_make(bp, 1, dom->ar.constructor, gen_update_arg(dom, 2), "");
    (void) printf("fun %s_%s (vector ar) = ", name, dom->ar.constructor ) ;
    (void) printf("(sub (ar,%d));\n", data) ;
}

References domain::ar, domain::constructor, gen_binding::domain, GEN_HEADER, gen_make(), gen_update_arg(), gen_binding::name, and printf().

Referenced by gen_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_domain()

void gen_domain

(

bp

)

GEN_DOMAIN generates the manipulation functions for a type BP.

This is manily a dispatching function.

Definition at line 342 of file genSML.c.

{
    extern int printf();
    union domain *dp = bp->domain ;
    char *s = bp->name ;
 
    if( !IS_EXTERNAL( bp )) {
        (void) printf( "type %s = chunk;\n", bp->name ) ;
        (void) printf( "val %s_undefined = (undefined:%s);\n", 
                       bp->name, bp->name ) ;
        (void) printf( "fun write_%s fd obj = gen_write fd obj;\n",
                bp->name ) ;
        (void) printf( "fun read_%s fd = (gen_read fd):%s;\n", 
                bp->name, bp->name ) ;
    }
    switch( dp->ba.type ) {
    case CONSTRUCTED_DT:
        switch( dp->co.op ) {
        case AND_OP: 
            gen_and( bp ) ;
            break ;
        case OR_OP:
            gen_or( bp ) ;
            break ;
        default:
            fatal( "gen_domain: Unknown constructed %s\n", i2a( dp->co.op )) ;
        }
        break ;
    case LIST_DT:
        gen_list( bp ) ;
        break ;
    case SET_DT:
        gen_set( bp ) ;
        break ;
    case ARRAY_DT:
        gen_array( bp ) ;
        break ;
    case EXTERNAL_DT:
        gen_external( bp ) ;
        break ;
    default:
        fatal( "gen_domain: Unknown type %s\n", i2a( dp->ba.type )) ;
    }
}

References AND_OP, ARRAY_DT, domain::ba, domain::co, CONSTRUCTED_DT, gen_binding::domain, EXTERNAL_DT, fatal(), gen_and(), gen_array(), gen_external(), gen_list(), gen_or(), gen_set(), i2a(), IS_EXTERNAL, LIST_DT, gen_binding::name, domain::op, OR_OP, printf(), SET_DT, and domain::type.

Referenced by gencode().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_external()

void gen_external

(

bp

)

GEN_EXTERNAL defines the acces functions for an external type BP.

The TYPEDEF has to be added by the user, but should be castable to a string (char *).

Definition at line 332 of file genSML.c.

{
    fprintf( stderr, "External: too be implemented\n" ) ;
}

References fprintf().

Referenced by gen_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_list()

void gen_list

(

bp

)

GEN_LIST defines the manipulation functions for a list type BP.

Definition at line 289 of file genSML.c.

{
    extern int printf();
    char *name = bp->name ;
    union domain *dom = bp->domain ;
    int data = GEN_HEADER ;
 
    gen_make(bp, 1, dom->li.constructor, gen_update_arg(dom, 2), "") ;
    (void) printf("fun %s_%s (vector li) = ", name, dom->li.constructor ) ;
    (void) printf("(sub (li,%d));\n", data) ;
}

References domain::constructor, gen_binding::domain, GEN_HEADER, gen_make(), gen_update_arg(), domain::li, gen_binding::name, and printf().

Referenced by gen_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_make()

static void gen_make ( bp  , size  , char *  args, char *  updated_args, char *  option_name  )

static

GEN_MAKE generates the gen_alloc call for gen_bindings BD with SIZE user members and ARGS as list of arguments.

Definition at line 202 of file genSML.c.

{
    extern int printf();
 
    (void) printf("fun make_%s%s%s (%s) =", bp->name, 
                  (strcmp(option_name, "") == 0 ? "" : "_"), option_name,
                  args) ;
    (void) printf(" let val gen_v = array(%d+%d, undefined) in\n",
                  GEN_HEADER, size);
    (void) printf(" update(gen_v, 0, int (%s+%d));\n", start, TYPE(bp)) ;
    (void) printf(" %s\n", updated_args);
 
    if( IS_TABULATED( bp )) {
        fprintf(stderr, "enter_tabulated not called\n");
    }
    (void) printf(" vector gen_v end:%s;\n", bp->name) ;
 
    if( IS_TABULATED( bp )) {
        printf( "val %s_domain = %s+%d;\n", bp->name, start, TYPE( bp )) ;
    }
}

References fprintf(), GEN_HEADER, IS_TABULATED, gen_binding::name, printf(), gen_binding::size, start, and TYPE.

Referenced by gen_and(), gen_array(), gen_list(), and gen_or().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_member()

static void gen_member ( name  , dp  , offset    )

static

GEN_MEMBER generates a member access functions for domain DP and OFFSET.

NAME is the domain of the defined domain.

Definition at line 122 of file genSML.c.

{
    char *field = primitive_field( dp ) ;
 
    if( dp->ba.type == BASIS_DT && 
       strcmp( dp->ba.constructand->name, UNIT_TYPE_NAME ) == 0 )
            return ;
 
    (void) printf( "fun %s_%s (vector node) = ", name, dp->ba.constructor ) ;
    (void) printf("case (sub (node,%d)) of (%s x) => x;\n",
                  offset, field) ;
}

References domain::ba, BASIS_DT, domain::constructand, domain::constructor, gen_binding::name, offset, primitive_field(), printf(), return(), domain::type, and UNIT_TYPE_NAME.

Referenced by gen_and(), and gen_or().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_or()

void gen_or

(

bp

)

GEN_OR generates the manipulation function for an OR_OP type BP.

Note that for a UNIT_TYPE_NAME, no access function is defined since the value is meaningless.

Definition at line 252 of file genSML.c.

{
    extern int printf();
    char *name = bp->name ;
    union domain *dom = bp->domain ;
    struct domainlist *dlp ;
    int offset ;
  
    (void) printf("fun %s_tag (vector or) = ", name ) ;
    (void) printf("case (sub (or,%d)) of (int x) => x;\n", 
                  GEN_HEADER) ;
 
    for( dlp=dom->co.components,offset=dom->co.first ;
        dlp != NULL ; 
        dlp=dlp->cdr, offset++ ) {
        union domain *dp = dlp->domain ;
        static char args[ 1024 ] ;
        static char updated_args[ 1024 ] ;
 
        sprintf(args, "tag, %s", dp->ba.constructor ) ;
        strcpy(updated_args, "update(gen_v, 2, int tag);") ;
        gen_make(bp, 2,args , 
                 strcat(updated_args, gen_update_arg(dp, 3)),
                 dp->ba.constructor);
        (void) printf("val is_%s_%s = %d;\n",
                      name, dp->ba.constructor, offset ) ;
        (void) printf("fun %s_%s_p or = ((%s_tag or)=is_%s_%s);\n",
                      name, dp->ba.constructor, name, 
                      name, dp->ba.constructor ) ;
        gen_member( name, dp, OR_TAG_OFFSET ) ;
    }
}

References domain::ba, domain::co, domain::components, domain::constructor, gen_binding::domain, domain::first, GEN_HEADER, gen_make(), gen_member(), gen_update_arg(), gen_binding::name, offset, OR_TAG_OFFSET, and printf().

Referenced by gen_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_set()

void gen_set

(

bp

)

GEN_SET defines the manipulation functions for a set type BP.

Definition at line 305 of file genSML.c.

{
    fprintf( stderr, "Set: too be implemented\n" ) ;
}

References fprintf().

Referenced by gen_domain().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_size()

int gen_size

(

bp

)

GEN_SIZE returns the size (in gen_chunks) of an object of type defined by the BP type.

OTREACHED

Definition at line 52 of file genSML.c.

{
    int overhead = GEN_HEADER ;
 
    switch( bp->domain->ba.type ) {
    case BASIS_DT:
    case ARRAY_DT:
    case LIST_DT:
    case SET_DT:
        return( overhead + 1 ) ;
    case CONSTRUCTED_DT:
        if( bp->domain->co.op == OR_OP )
                return( overhead + 2 ) ;
        else {
            int size ;
            struct domainlist *dlp = bp->domain->co.components ;
 
            for( size=0 ; dlp != NULL ; dlp=dlp->cdr, size++ )
                    ;
            return( overhead + size ) ;
        }
    default:
        fatal( "gen_size: Unknown type %s\n", i2a( bp->domain->ba.type )) ;
        /*NOTREACHED*/
    }
}

References ARRAY_DT, domain::ba, BASIS_DT, domain::co, domain::components, CONSTRUCTED_DT, gen_binding::domain, fatal(), GEN_HEADER, i2a(), LIST_DT, domain::op, OR_OP, SET_DT, gen_binding::size, and domain::type.

Referenced by gen_and().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_update_arg()

static char* gen_update_arg ( dp  , index    )

static

Definition at line 170 of file genSML.c.

{
    static char arg[ 1024 ] ;
 
    sprintf(arg, "update(gen_v, %d, %s %s);", index, 
            primitive_field(dp), gen_arg(dp));
    return(arg) ;
}

References gen_arg(), and primitive_field().

Referenced by gen_array(), gen_list(), gen_or(), and gen_update_args().

Here is the call graph for this function:

Here is the caller graph for this function:

gen_update_args()

static char* gen_update_args ( dlp  )

static

GEN_UPDATE_ARGS returns a comma-separated list of constructor names for the list of domains DLP.

Definition at line 185 of file genSML.c.

{
    static char buffer[ 1024 ] ;
    int index = GEN_HEADER ;
 
    for( sprintf(buffer, "") ; dlp->cdr!=NULL ; dlp=dlp->cdr, index++ ) {
        strcat(buffer, gen_update_arg(dlp->domain, index)) ;
    }
    strcat(buffer, gen_update_arg(dlp->domain, index)) ;
    return( buffer ) ;
}

References buffer, GEN_HEADER, and gen_update_arg().

Referenced by gen_and().

Here is the call graph for this function:

Here is the caller graph for this function:

gencode()

void gencode

(

file

)

GENCODE generates the code necessary to manipulate every internal and non-inlinable type in the Domains table.

Definition at line 392 of file genSML.c.

{
    struct gen_binding *bp = Domains ;
    
    sprintf( start, "gen_%s_start", file ) ;
 
    for( ; bp < &Domains[ MAX_DOMAIN ] ; bp++ ) {
        if(bp->name == NULL || IS_INLINABLE( bp ) || IS_IMPORT( bp ) ||
           bp == Tabulated_bp ) 
                continue ;
 
        gen_domain( bp ) ;
    }
}

References Domains, gen_domain(), IS_IMPORT, IS_INLINABLE, MAX_DOMAIN, gen_binding::name, start, and Tabulated_bp.

Here is the call graph for this function:

primitive_field()

static char* primitive_field ( dp  )

static

PRIMITIVE_FIELD returns the appropriate field to acces an object in BP.

Note how inlined types are managed (see genC.h comments).

OTREACHED

Definition at line 84 of file genSML.c.

{
    static char buffer[ 1024 ];
 
    switch( dp->ba.type ) {
    case BASIS_DT: {
        struct gen_binding *bp = dp->ba.constructand ;
 
        if( IS_INLINABLE( bp )) {
            sprintf( buffer, "%s", bp->name ) ;
        }
        else if( IS_EXTERNAL( bp )) {
            fprintf(stderr, "primitive_field not implemented\n");
        }
        else sprintf( buffer, "chunk" ) ;
        break ;
    }
    case LIST_DT:
        sprintf( buffer, "list" ) ;
        break ;
    case SET_DT:
        sprintf( buffer, "set" ) ;
        break ;
    case ARRAY_DT: 
        sprintf( buffer, "vector" ) ;
        break ;
    default:
        fatal( "primitive_field: Unknown type %s\n", i2a( dp->ba.type )) ;
        /*NOTREACHED*/
    }
    return( buffer ) ;
}

References ARRAY_DT, domain::ba, BASIS_DT, buffer, domain::constructand, fatal(), fprintf(), i2a(), IS_EXTERNAL, IS_INLINABLE, LIST_DT, gen_binding::name, SET_DT, and domain::type.

Referenced by gen_member(), and gen_update_arg().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

Read_spec_mode

int Read_spec_mode

extern int Current_first ;

Definition at line 44 of file genSML.c.

start

char start[1024]

static

Definition at line 42 of file genSML.c.

Referenced by gen_make(), and gencode().

Tabulated_bp

struct gen_binding* Tabulated_bp

Definition at line 46 of file genSML.c.

Referenced by gencode().