writ_ifs.c

ngspice又一个电子CAD仿真软件代码.功能更全

	fprintf(fp, "static int val_sizeofMIFmodel    = sizeof(MIFmodel);\n");

    /* Write out the structure beginning */

    /* Use the c function external identifier appended with _info as the */
    /* external identifier for the structure.                            */

    fprintf(fp, "\n");
    fprintf(fp, "SPICEdev %s_info = {\n", ifs_table->name.c_fcn_name);

    /* Write the IFdevice structure */

    fprintf(fp, "    { \"%s\",\n", ifs_table->name.model_name);
    fprintf(fp, "      \"%s\",\n", ifs_table->name.description);
    fprintf(fp, "      &val_terms,\n");
    fprintf(fp, "      &val_numNames,\n");
    fprintf(fp, "      NULL,\n");

    fprintf(fp, "      &val_numInstanceParms,\n");
    if(ifs_table->num_inst_var > 0)
        fprintf(fp, "      MIFpTable,\n");
    else
        fprintf(fp, "      NULL,\n");

    fprintf(fp, "      &val_numModelParms,\n");
    if(ifs_table->num_param > 0)
        fprintf(fp, "      MIFmPTable,\n");
    else
        fprintf(fp, "      NULL,\n");

    fprintf(fp, "      %s,\n", ifs_table->name.c_fcn_name);

    fprintf(fp, "      %d,\n", ifs_table->num_conn);
    if(ifs_table->num_conn > 0)
        fprintf(fp, "      MIFconnTable,\n");
    else
        fprintf(fp, "      NULL,\n");

    fprintf(fp, "      %d,\n", ifs_table->num_param);
    if(ifs_table->num_param > 0)
        fprintf(fp, "      MIFparamTable,\n");
    else
        fprintf(fp, "      NULL,\n");

    fprintf(fp, "      %d,\n", ifs_table->num_inst_var);
    if(ifs_table->num_inst_var > 0)
        fprintf(fp, "      MIFinst_varTable,\n");
    else
        fprintf(fp, "      NULL,\n");

    fprintf(fp, "    },\n");

    /* Write the names of the generic code model functions */

    fprintf(fp, "NULL,          \n");  /* DEVparam */
    fprintf(fp, "MIFmParam,     \n");  /* DEVmodParam */
    fprintf(fp, "MIFload,       \n");  /* DEVload */
    fprintf(fp, "MIFsetup,      \n");  /* DEVsetup */
    fprintf(fp, "MIFunsetup,    \n");  /* DEVunsetup */
    fprintf(fp, "NULL,          \n");  /* DEVpzSetup */
    fprintf(fp, "NULL,          \n");  /* DEVtemperature */
    fprintf(fp, "MIFtrunc,      \n");  /* DEVtrunc */
    fprintf(fp, "NULL,          \n");  /* DEVfindBranch */
    fprintf(fp, "MIFload,       \n");  /* DEVacLoad */
    fprintf(fp, "NULL,          \n");  /* DEVaccept */
    fprintf(fp, "MIFdestroy,    \n");  /* DEVdestroy */
    fprintf(fp, "MIFmDelete,    \n");  /* DEVmodDelete */
    fprintf(fp, "MIFdelete,     \n");  /* DEVdelete */
    fprintf(fp, "NULL,          \n");  /* DEVsetic */
    fprintf(fp, "MIFask,        \n");  /* DEVask */
    fprintf(fp, "MIFmAsk,       \n");  /* DEVmodAsk */
    fprintf(fp, "NULL,          \n");  /* DEVpzLoad */
    fprintf(fp, "MIFconvTest,   \n");  /* DEVconvTest */
    fprintf(fp, "NULL,          \n");  /* DEVsenSetup */
    fprintf(fp, "NULL,          \n");  /* DEVsenLoad */
    fprintf(fp, "NULL,          \n");  /* DEVSenUpdate */
    fprintf(fp, "NULL,          \n");  /* DEVsenAcLoad */
    fprintf(fp, "NULL,          \n");  /* DEVsenPrint */
    fprintf(fp, "NULL,          \n");  /* DEVsenTrunc */
    fprintf(fp, "NULL,          \n");  /* DEVdisto */
    fprintf(fp, "NULL,          \n");  /* DEVnoise */
    fprintf(fp, "#ifdef CIDER   \n");  /* CIDER enhancements */
    fprintf(fp, "NULL,          \n");  /* DEVdump */
    fprintf(fp, "NULL,          \n");  /* DEVacct */
    fprintf(fp, "#endif         \n");  /* CIDER enhancements */    

    /* Write the sizeof stuff used in dynamic allocation of inst/model structs */

    fprintf(fp, "&val_sizeofMIFinstance,\n");
    fprintf(fp, "&val_sizeofMIFmodel,\n");
    fprintf(fp, "\n");
    fprintf(fp, "};\n");
    fprintf(fp, "\n");

}




/* *********************************************************************** */


/*
The following functions are utility routines used to convert internal
enums and data to ASCII form for placing into the .c file
being created.
*/


#define BASE_STR_LEN  80


static char  *data_type_to_str(Data_Type_t type)
{
    static char *str = NULL;

    if(str == NULL)
        str = malloc(BASE_STR_LEN+1);

    switch(type) {

        case BOOLEAN:
            strcpy(str,"MIF_BOOLEAN");
            break;

        case INTEGER:
            strcpy(str,"MIF_INTEGER");
            break;

        case REAL:
            strcpy(str,"MIF_REAL");
            break;

        case COMPLEX:
            strcpy(str,"MIF_COMPLEX");
            break;

        case STRING:
            strcpy(str,"MIF_STRING");
            break;

	case POINTER:
            strcpy(str,"MIF_STRING");
            break;

        default:
            print_error("INTERNAL ERROR - data_type_to_str() - Impossible data type.");
    }

    return(str);
}


/* *********************************************************************** */

static char  *port_type_to_str(Port_Type_t port)
{
    static char *str = NULL;

    if(str == NULL)
        str = malloc(BASE_STR_LEN+1);

    switch(port) {

        case VOLTAGE:
            strcpy(str,"MIF_VOLTAGE");
            break;

        case DIFF_VOLTAGE:
            strcpy(str,"MIF_DIFF_VOLTAGE");
            break;

        case CURRENT:
            strcpy(str,"MIF_CURRENT");
            break;

        case DIFF_CURRENT:
            strcpy(str,"MIF_DIFF_CURRENT");
            break;

        case VSOURCE_CURRENT:
            strcpy(str,"MIF_VSOURCE_CURRENT");
            break;

        case CONDUCTANCE:
            strcpy(str,"MIF_CONDUCTANCE");
            break;

        case DIFF_CONDUCTANCE:
            strcpy(str,"MIF_DIFF_CONDUCTANCE");
            break;

        case RESISTANCE:
            strcpy(str,"MIF_RESISTANCE");
            break;

        case DIFF_RESISTANCE:
            strcpy(str,"MIF_DIFF_RESISTANCE");
            break;

        case DIGITAL:
            strcpy(str,"MIF_DIGITAL");
            break;

        case USER_DEFINED:
            strcpy(str,"MIF_USER_DEFINED");
            break;

        default:
            print_error("INTERNAL ERROR - port_type_to_str() - Impossible port type.");
    }

    return(str);

}

/* *********************************************************************** */

static char  *gen_port_type_str(Port_Type_t port)
{
    static char *str = NULL;

    if(str == NULL)
        str = malloc(BASE_STR_LEN+1);

    switch(port) {

        case VOLTAGE:
            strcpy(str,"v");
            break;

        case DIFF_VOLTAGE:
            strcpy(str,"vd");
            break;

        case CURRENT:
            strcpy(str,"i");
            break;

        case DIFF_CURRENT:
            strcpy(str,"id");
            break;

        case VSOURCE_CURRENT:
            strcpy(str,"vnam");
            break;

        case CONDUCTANCE:
            strcpy(str,"g");
            break;

        case DIFF_CONDUCTANCE:
            strcpy(str,"gd");
            break;

        case RESISTANCE:
            strcpy(str,"h");
            break;

        case DIFF_RESISTANCE:
            strcpy(str,"hd");
            break;

        case DIGITAL:
            strcpy(str,"d");
            break;

        case USER_DEFINED:
            strcpy(str,"");
            break;

        default:
            print_error("INTERNAL ERROR - gen_port_type_str() - Impossible port type.");
    }

    return(str);

}


/* *********************************************************************** */

static char  *dir_to_str(Dir_t dir)
{
    static char *str = NULL;

    if(str == NULL)
        str = malloc(BASE_STR_LEN+1);

    switch(dir) {

        case IN:
            strcpy(str,"MIF_IN");
            break;

        case OUT:
            strcpy(str,"MIF_OUT");
            break;

        case INOUT:
            strcpy(str,"MIF_INOUT");
            break;

        default:
            print_error("INTERNAL ERROR - dir_to_str() - Impossible direction type.");
    }

    return(str);
}



/* *********************************************************************** */

static char  *value_to_str(Data_Type_t type, Value_t value)
{
    static char *str = NULL;
    static int  max_len = 0;

    char *bool_str;
    int  str_len;


    if(str == NULL) {
        str = malloc(2 * BASE_STR_LEN + 1);
        max_len = 2 * BASE_STR_LEN;
    }

    switch(type) {

        case BOOLEAN:
            bool_str = boolean_to_str(value.bvalue);
            sprintf(str, "{%s, 0, 0.0, {0.0, 0.0}, NULL}", bool_str);
            break;

        case INTEGER:
            sprintf(str, "{MIF_FALSE, %d, 0.0, {0.0, 0.0}, NULL}", value.ivalue);
            break;

        case REAL:
            sprintf(str, "{MIF_FALSE, 0, %e, {0.0, 0.0}, NULL}", value.rvalue);
            break;

        case COMPLEX:
            sprintf(str, "{MIF_FALSE, 0, 0.0, {%e, %e}, NULL}",
                                      value.cvalue.real, value.cvalue.imag);
            break;

        case STRING:
            /* be careful, the string could conceivably be very long... */
            str_len = strlen(value.svalue);
            if((str_len + BASE_STR_LEN) > max_len) {
                str = realloc(str, (max_len + str_len +1));
                max_len += str_len;
            }
            sprintf(str, "{MIF_FALSE, 0, 0.0, {0.0, 0.0}, \"%s\"}", value.svalue);
            break;

        default:
            print_error("INTERNAL ERROR - value_to_str() - Impossible data type.");

    }

    return(str);
}


/* *********************************************************************** */

static char  *boolean_to_str(Boolean_t value)
{
    static char *str = NULL;

    if(str == NULL)
        str = malloc(BASE_STR_LEN+1);

    switch(value) {

        case TRUE:
            strcpy(str,"MIF_TRUE");
            break;

        case FALSE:
            strcpy(str,"MIF_FALSE");
            break;

        default:
            print_error("INTERNAL ERROR - boolean_to_str() - Impossible boolean value.");
	    {
	       char *p = 0; *p = 0;
	    }
    }

    return(str);
}


/* *********************************************************************** */

static char  *integer_to_str(int value)
{
    static char *str = NULL;

    if(str == NULL) {
        str = malloc(BASE_STR_LEN + 1);
    }

    sprintf(str, "%d", value);

    return(str);
}


/* *********************************************************************** */

static char  *no_value_to_str(void)
{
    static char *str = NULL;

    if(str == NULL) {
        str = malloc(BASE_STR_LEN + 1);
    }

    sprintf(str, "{MIF_FALSE, 0, 0.0, {0.0, 0.0}, NULL}");

    return(str);
}