gerb_stats.c

Go to the documentation of this file.

/*
 * gEDA - GNU Electronic Design Automation
 *   gerbv_stats.c -- a part of gerbv.
 *
 *   Copyright (C) Stuart Brorson (sdb@cloud9.net)
 *
 * $Id$
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
 */
 
#include "gerbv.h"
 
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
#include "common.h"
#include "gerb_stats.h"
 
#undef DPRINTF
#define DPRINTF(...) do { if (DEBUG) printf(__VA_ARGS__); } while (0)
 
/* ------------------------------------------------------- */
gerbv_stats_t *
gerbv_stats_new(void) {
 
    gerbv_stats_t *stats;
    gerbv_error_list_t *error_list;
    gerbv_aperture_list_t *aperture_list;
    gerbv_aperture_list_t *D_code_list;
 
    /* Malloc space for new stats struct.  Return NULL if error. */
    if (NULL == (stats = g_new0(gerbv_stats_t, 1))) {
        return NULL;
    }
 
    /* Initialize error list */
    error_list = gerbv_stats_new_error_list();
    if (error_list == NULL)
        GERB_FATAL_ERROR("malloc error_list failed in %s()", __FUNCTION__);
    stats->error_list = (gerbv_error_list_t *) error_list;
 
    /* Initialize aperture list */
    aperture_list = gerbv_stats_new_aperture_list();
    if (aperture_list == NULL)
        GERB_FATAL_ERROR("malloc aperture_list failed in %s()", __FUNCTION__);
    stats->aperture_list = (gerbv_aperture_list_t *) aperture_list;
 
    /* Initialize D codes list */
    D_code_list = gerbv_stats_new_aperture_list();
    if (D_code_list == NULL)
        GERB_FATAL_ERROR("malloc D_code_list failed in %s()", __FUNCTION__);
    stats->D_code_list = (gerbv_aperture_list_t *) D_code_list;
 
    return stats;
}
 
void
gerbv_destroy_error_list (gerbv_error_list_t *errorList) {
       gerbv_error_list_t *nextError=errorList,*tempError;
       
       while (nextError) {
              tempError = nextError->next;
              g_free (nextError->error_text);
              g_free (nextError);
              nextError = tempError;
       }
}
 
void
gerbv_destroy_aperture_list (gerbv_aperture_list_t *apertureList) {
       gerbv_aperture_list_t *nextAperture=apertureList,*tempAperture;
       
       while (nextAperture) {
              tempAperture = nextAperture->next;
              g_free (nextAperture);
              nextAperture = tempAperture;
       }
}
 
/* ------------------------------------------------------- */
void
gerbv_stats_destroy(gerbv_stats_t *stats) {
       if (stats == NULL)
              return;
       gerbv_destroy_error_list (stats->error_list);
       gerbv_destroy_aperture_list (stats->aperture_list);
       gerbv_destroy_aperture_list (stats->D_code_list);
       g_free (stats);
}      
 
 
/* ------------------------------------------------------- */
void
gerbv_stats_add_layer(gerbv_stats_t *accum_stats, 
                   gerbv_stats_t *input_stats,
                   int this_layer) {
    
    DPRINTF("---> Entering gerbv_stats_add_layer ... \n");
 
    gerbv_error_list_t *error;
    gerbv_aperture_list_t *aperture;
    gerbv_aperture_list_t *D_code;
 
    accum_stats->layer_count++;
    accum_stats->G0 += input_stats->G0;
    accum_stats->G1 += input_stats->G1;
    accum_stats->G2 += input_stats->G2;
    accum_stats->G3 += input_stats->G3;
    accum_stats->G4 += input_stats->G4;
    accum_stats->G10 += input_stats->G10;
    accum_stats->G11 += input_stats->G11;
    accum_stats->G12 += input_stats->G12;
    accum_stats->G36 += input_stats->G36;
    accum_stats->G37 += input_stats->G37;
    accum_stats->G54 += input_stats->G54;
    accum_stats->G55 += input_stats->G55;
    accum_stats->G70 += input_stats->G70;
    accum_stats->G71 += input_stats->G71;
    accum_stats->G74 += input_stats->G74;
    accum_stats->G75 += input_stats->G75;
    accum_stats->G90 += input_stats->G90;
    accum_stats->G91 += input_stats->G91;
    accum_stats->G_unknown += input_stats->G_unknown;
 
    accum_stats->D1 += input_stats->D1;
    accum_stats->D2 += input_stats->D2;
    accum_stats->D3 += input_stats->D3;
    /* Create list of user-defined D codes from aperture list */
    for (D_code = input_stats->D_code_list;
         D_code != NULL;
         D_code = D_code->next) {
        if (D_code->number != -1) {
         DPRINTF("     .... In gerbv_stats_add_layer, D code section, adding number = %d to accum_stats D list ...\n",
                D_code->number);
         gerbv_stats_add_to_D_list(accum_stats->D_code_list,
                               D_code->number);
         DPRINTF("     .... In gerbv_stats_add_layer, D code section, calling increment_D_count with count %d ...\n", 
                D_code->count);
         gerbv_stats_increment_D_list_count(accum_stats->D_code_list,
                                       D_code->number,
                                       D_code->count,
                                       accum_stats->error_list);
      }
    }
    accum_stats->D_unknown += input_stats->D_unknown;
    accum_stats->D_error += input_stats->D_error;
 
    accum_stats->M0 += input_stats->M0;
    accum_stats->M1 += input_stats->M1;
    accum_stats->M2 += input_stats->M2;
    accum_stats->M_unknown += input_stats->M_unknown;
 
    accum_stats->X += input_stats->X;
    accum_stats->Y += input_stats->Y;
    accum_stats->I += input_stats->I;
    accum_stats->J += input_stats->J;
 
    accum_stats->star += input_stats->star;
    accum_stats->unknown += input_stats->unknown;
 
    /* ==== Now deal with the error list ==== */
    for (error = input_stats->error_list;
         error != NULL;
         error = error->next) {
        if (error->error_text != NULL) {
            gerbv_stats_add_error(accum_stats->error_list,
                                  this_layer,
                                  error->error_text,
                                  error->type);
        }
    }
 
    /* ==== Now deal with the aperture list ==== */
    for (aperture = input_stats->aperture_list;
         aperture != NULL;
         aperture = aperture->next) {
        if (aperture->number != -1) {
            gerbv_stats_add_aperture(accum_stats->aperture_list,
                                this_layer,
                                aperture->number,
                                aperture->type,
                                aperture->parameter);
        }
    }
 
    DPRINTF("<---- .... Leaving gerbv_stats_add_layer. \n");
 
    return;
}
 
/* ------------------------------------------------------- */
gerbv_error_list_t *
gerbv_stats_new_error_list() {
    gerbv_error_list_t *error_list;
 
    /* Malloc space for new error_list struct.  Return NULL if error. */
    if (NULL == (error_list = g_new(gerbv_error_list_t, 1))) {
        return NULL;
    }
 
    error_list->layer = -1;
    error_list->error_text = NULL;
    error_list->next = NULL;
    return error_list;
}
 
/* ------------------------------------------------------- */
void
gerbv_stats_printf(gerbv_error_list_t *list, gerbv_message_type_t type,
                     int layer, const char *text, ...)
{
    gchar *str;
    va_list args;
 
    va_start(args, text);
    str = g_strdup_vprintf(text, args);
    va_end(args);
    gerbv_stats_add_error(list, layer, str, type);
    g_free(str);
}
 
/* ------------------------------------------------------- */
int
gerbv_escape_char_return_int(char c)
{
       int i = 0;
       char *ec = (char *)&i;
 
       ec[0] = '\\';
 
       switch (c) {
       case '\0':
              ec[1] = '0';
              break;
       case '\a':
              ec[1] = 'a';
              break;
       case '\b':
              ec[1] = 'b';
              break;
       case '\f':
              ec[1] = 'f';
              break;
       case '\n':
              ec[1] = 'n';
              break;
       case '\r':
              ec[1] = 'r';
              break;
       case '\t':
              ec[1] = 't';
              break;
       case '\v':
              ec[1] = 'v';
              break;
       case '\\':
              ec[1] = '\\';
              break;
       case '"':
              ec[1] = '"';
              break;
       default:
              ec[0] = c;
       }
 
       return i;
}
 
/* ------------------------------------------------------- */
void
gerbv_stats_add_error(gerbv_error_list_t *error_list_in,
                      int layer, const char *error_text,
                      gerbv_message_type_t type) {
 
    gerbv_error_list_t *error_list_new;
    gerbv_error_list_t *error_last = NULL;
    gerbv_error_list_t *error;
 
    /* Replace embedded error messages */
    switch (type) {
        case GERBV_MESSAGE_FATAL:
            GERB_FATAL_ERROR("%s",error_text);
            break;
        case GERBV_MESSAGE_ERROR:
            GERB_COMPILE_ERROR("%s",error_text);
            break;
        case GERBV_MESSAGE_WARNING:
            GERB_COMPILE_WARNING("%s",error_text);
            break;
        case GERBV_MESSAGE_NOTE:
            GERB_NOTE("%s", error_text);
            break;
    }
 
    /* First handle case where this is the first list element */
    if (error_list_in->error_text == NULL) {
        error_list_in->layer = layer;
        error_list_in->error_text = g_strdup_printf("%s", error_text);
        error_list_in->type = type;
        error_list_in->next = NULL;
        return;
    }
 
    /* Next check to see if this error is already in the list */
    for(error = error_list_in; error != NULL; error = error->next) {
        if ((strcmp(error->error_text, error_text) == 0) &&
            (error->layer == layer) ) {
            return;  /* This error text is already in the error list */
        }
        error_last = error;  /* point to last element in error list */
    }
    /* This error text is unique.  Therefore, add it to the list */
 
    /* Now malloc space for new error list element */
    if (NULL == (error_list_new = g_new(gerbv_error_list_t, 1))) {
        GERB_FATAL_ERROR("malloc error_list failed in %s()", __FUNCTION__);
    }
 
    /* Set member elements */
    error_list_new->layer = layer;
    error_list_new->error_text = g_strdup_printf("%s", error_text);
    error_list_new->type = type;
    error_list_new->next = NULL;
    error_last->next = error_list_new;
 
    return;
}
 
/* ------------------------------------------------------- */
gerbv_aperture_list_t *
gerbv_stats_new_aperture_list() {
    gerbv_aperture_list_t *aperture_list;
    int i;
 
    DPRINTF("Mallocing new gerb aperture list\n");
    /* Malloc space for new aperture_list struct.  Return NULL if error. */
    if (NULL == (aperture_list = g_new(gerbv_aperture_list_t, 1))) {
        DPRINTF("malloc new gerb aperture list failed in %s()\n", __FUNCTION__);
        return NULL;
    }
 
    DPRINTF("   Placing values in certain structs.\n");
    aperture_list->number = -1;
    aperture_list->count = 0;
    aperture_list->type = 0;
    for (i = 0; i<5; i++) {
       aperture_list->parameter[i] = 0.0;
    }
    aperture_list->next = NULL;
    return aperture_list;
}
 
 
/* ------------------------------------------------------- */
void
gerbv_stats_add_aperture(gerbv_aperture_list_t *aperture_list_in,
                     int layer, int number, gerbv_aperture_type_t type,
                     double parameter[5]) {
 
    gerbv_aperture_list_t *aperture_list_new;
    gerbv_aperture_list_t *aperture_last = NULL;
    gerbv_aperture_list_t *aperture;
    int i;
 
    DPRINTF("   --->  Entering gerbv_stats_add_aperture ....\n"); 
 
    /* First handle case where this is the first list element */
    if (aperture_list_in->number == -1) {
       DPRINTF("     .... Adding first aperture to aperture list ... \n"); 
       DPRINTF("     .... Aperture type = %d ... \n", type); 
        aperture_list_in->number = number;
        aperture_list_in->type = type;
       aperture_list_in->layer = layer;
       for(i=0; i<5; i++) { 
           aperture_list_in->parameter[i] = parameter[i];
       }
        aperture_list_in->next = NULL;
       DPRINTF("   <---  .... Leaving gerbv_stats_add_aperture.\n"); 
        return;
    }
 
    /* Next check to see if this aperture is already in the list */
    for(aperture = aperture_list_in; 
       aperture != NULL; 
       aperture = aperture->next) {
        if ((aperture->number == number) &&
            (aperture->layer == layer) ) {
         DPRINTF("     .... This aperture is already in the list ... \n"); 
           DPRINTF("   <---  .... Leaving gerbv_stats_add_aperture.\n"); 
            return;  
        }
        aperture_last = aperture;  /* point to last element in list */
    }
    /* This aperture number is unique.  Therefore, add it to the list */
    DPRINTF("     .... Adding another aperture to list ... \n"); 
    DPRINTF("     .... Aperture type = %d ... \n", type); 
       
    /* Now malloc space for new aperture list element */
    if (NULL == (aperture_list_new = g_new(gerbv_aperture_list_t, 1))) {
        GERB_FATAL_ERROR("malloc aperture_list failed in %s()", __FUNCTION__);
    }
 
    /* Set member elements */
    aperture_list_new->layer = layer;
    aperture_list_new->number = number;
    aperture_list_new->type = type;
    aperture_list_new->next = NULL;
    for(i=0; i<5; i++) { 
       aperture_list_new->parameter[i] = parameter[i];
    }
    aperture_last->next = aperture_list_new;
 
    DPRINTF("   <---  .... Leaving gerbv_stats_add_aperture.\n"); 
 
    return;
}
 
/* ------------------------------------------------------- */
void
gerbv_stats_add_to_D_list(gerbv_aperture_list_t *D_list_in,
                      int number) {
  
  gerbv_aperture_list_t *D_list;
  gerbv_aperture_list_t *D_list_last=NULL;
  gerbv_aperture_list_t *D_list_new;
 
    DPRINTF("   ----> Entering add_to_D_list, numbr = %d\n", number);
 
    /* First handle case where this is the first list element */
    if (D_list_in->number == -1) {
       DPRINTF("     .... Adding first D code to D code list ... \n"); 
       DPRINTF("     .... Aperture number = %d ... \n", number); 
        D_list_in->number = number;
       D_list_in->count = 0;
        D_list_in->next = NULL;
       DPRINTF("   <---  .... Leaving add_to_D_list.\n"); 
        return;
    }
 
    /* Look to see if this is already in list */
    for(D_list = D_list_in; 
       D_list != NULL; 
       D_list = D_list->next) {
        if (D_list->number == number) {
           DPRINTF("    .... Found in D list .... \n");
           DPRINTF("   <---  .... Leaving add_to_D_list.\n"); 
            return;  
        }
        D_list_last = D_list;  /* point to last element in list */
    }
 
    /* This aperture number is unique.  Therefore, add it to the list */
    DPRINTF("     .... Adding another D code to D code list ... \n"); 
       
    /* Malloc space for new aperture list element */
    if (NULL == (D_list_new = g_new(gerbv_aperture_list_t, 1))) {
        GERB_FATAL_ERROR("malloc D_list failed in %s()", __FUNCTION__);
    }
 
    /* Set member elements */
    D_list_new->number = number;
    D_list_new->count = 0;
    D_list_new->next = NULL;
    D_list_last->next = D_list_new;
 
    DPRINTF("   <---  .... Leaving add_to_D_list.\n"); 
 
    return;
}
 
/* ------------------------------------------------------- */
int 
gerbv_stats_increment_D_list_count(gerbv_aperture_list_t *D_list_in,
                                int number, 
                                int count,
                                gerbv_error_list_t *error) {
  
    gerbv_aperture_list_t *D_list;
 
    DPRINTF("   Entering inc_D_list_count, code = D%d, input count to add = %d\n", number, count);
 
    /* Find D code in list and increment it */
    for(D_list = D_list_in; 
       D_list != NULL; 
       D_list = D_list->next) {
        if (D_list->number == number) {
           DPRINTF("    old count = %d\n", D_list->count);
           D_list->count += count;  /* Add to this aperture count, then return */
           DPRINTF("    updated count = %d\n", D_list->count);
            return 0;  /* Return 0 for success */  
        }
    }
 
    /* This D number is not defined.  Therefore, flag error */
    DPRINTF("    .... Didn't find this D code in defined list .... \n");
    DPRINTF("   <---  .... Leaving inc_D_list_count.\n"); 
 
    gerbv_stats_printf(error, GERBV_MESSAGE_ERROR, -1,
           _("Undefined aperture number called out in D code"));
 
    return -1;  /* Return -1 for failure */
}