drill_stats.c

Go to the documentation of this file.

/*
 * gEDA - GNU Electronic Design Automation
 *   drill_stats.c -- a part of gerbv.
 *
 *   Copyright (C) 2007 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
#include "common.h"
#include "drill_stats.h"
#include "gerb_stats.h"
 
#undef DPRINTF
#define DPRINTF(...) do { if (DEBUG) printf(__VA_ARGS__); } while (0)
 
 
/* ------------------------------------------------------- */
gerbv_drill_stats_t *
gerbv_drill_stats_new(void) {
 
    gerbv_drill_stats_t *stats;
    gerbv_drill_list_t *drill_list;
    gerbv_error_list_t *error_list;
 
    /* Malloc space for new stats struct.  Return NULL if error. */
    if (NULL == (stats = g_new0(gerbv_drill_stats_t, 1))) {
        return NULL;
    }
 
    /* Initialize drill list */
    drill_list = gerbv_drill_stats_new_drill_list();
    if (drill_list == NULL)
        GERB_FATAL_ERROR("malloc drill_list failed in %s()", __FUNCTION__);
    stats->drill_list = (gerbv_drill_list_t *) drill_list;
 
    /* Initialize error list */
    error_list = gerbv_drill_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;
 
    stats->detect = NULL;
 
    return stats;
}
 
void
gerbv_drill_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_drill_destroy_drill_list (gerbv_drill_list_t *apertureList) {
       gerbv_drill_list_t *nextAperture=apertureList,*tempAperture;
       
       while (nextAperture) {
              tempAperture = nextAperture->next;
              g_free(nextAperture->drill_unit);
              g_free (nextAperture);
              nextAperture = tempAperture;
       }
}
 
void
gerbv_drill_stats_destroy(gerbv_drill_stats_t *stats) {
       if (stats == NULL)
              return;
       gerbv_drill_destroy_error_list (stats->error_list);
       gerbv_drill_destroy_drill_list (stats->drill_list);
       g_free (stats);
}      
       
/* ------------------------------------------------------- */
void
gerbv_drill_stats_add_layer(gerbv_drill_stats_t *accum_stats, 
                    gerbv_drill_stats_t *input_stats,
                    int this_layer) {
 
    gerbv_drill_list_t *drill;
    gerbv_error_list_t *error;
    char *tmps, *tmps2;
 
    DPRINTF("--->  Entering gerbv_drill_stats_add_layer ..... \n");
 
    accum_stats->layer_count++;
 
    accum_stats->comment += input_stats->comment;
    /* F codes go here */
 
    accum_stats->G00 += input_stats->G00;
    accum_stats->G01 += input_stats->G01;
    accum_stats->G02 += input_stats->G02;
    accum_stats->G03 += input_stats->G03;
    accum_stats->G04 += input_stats->G04;
    accum_stats->G05 += input_stats->G05;
    accum_stats->G32 += input_stats->G32;
    accum_stats->G33 += input_stats->G33;
    accum_stats->G85 += input_stats->G85;
    accum_stats->G87 += input_stats->G87;
    accum_stats->G90 += input_stats->G90;
    accum_stats->G91 += input_stats->G91;
    accum_stats->G93 += input_stats->G93;
    accum_stats->G_machine_only += input_stats->G_machine_only;
    accum_stats->G_unknown += input_stats->G_unknown;
 
    accum_stats->M00 += input_stats->M00;
    accum_stats->M01 += input_stats->M01;
    accum_stats->M02 += input_stats->M02;
    accum_stats->M18 += input_stats->M18;
    accum_stats->M25 += input_stats->M25;
    accum_stats->M30 += input_stats->M30;
    accum_stats->M31 += input_stats->M31;
    accum_stats->M45 += input_stats->M45;
    accum_stats->M47 += input_stats->M47;
    accum_stats->M48 += input_stats->M48;
    accum_stats->M70 += input_stats->M70;
    accum_stats->M71 += input_stats->M71;
    accum_stats->M72 += input_stats->M72;
    accum_stats->M80 += input_stats->M80;
    accum_stats->M90 += input_stats->M90;
    accum_stats->M95 += input_stats->M95;
    accum_stats->M97 += input_stats->M97;
    accum_stats->M98 += input_stats->M98;
    accum_stats->M_machine_only += input_stats->M_machine_only;
    accum_stats->M_unknown += input_stats->M_unknown;
 
    accum_stats->R += input_stats->R;
 
    /* ==== Now deal with the drill list ==== */
    for (drill = input_stats->drill_list;
         drill != NULL;
        drill = drill->next) {
       DPRINTF("   In gerbv_drill_stats_add_layer, adding drill_num = %d to list\n",
              drill->drill_num);
       /* First add this input drill to the accumulated list.
        * Drills already in accum list will not be added. */
       drill_stats_add_to_drill_list(accum_stats->drill_list,
                                  drill->drill_num, 
                                  drill->drill_size,
                                  drill->drill_unit);
 
       /* Now add count of input drill to accum list */
       DPRINTF("   adding count %d of drills for drill %d\n", 
              drill->drill_count, drill->drill_num);
       drill_stats_add_to_drill_counter(accum_stats->drill_list,
                                    drill->drill_num,
                                    drill->drill_count);
       accum_stats->total_count += drill->drill_count;
    }
 
    /* ==== Now deal with the error list ==== */
    for (error = input_stats->error_list; error != NULL; error = error->next) {
       if (error->error_text != NULL)
           gerbv_stats_printf(accum_stats->error_list, error->type,
                  this_layer, "%s", error->error_text);
    }
 
    /* ==== Now deal with the misc header stuff ==== */
    tmps = NULL;
    tmps2 = NULL;
    if (input_stats->detect) {
       tmps2 = g_strdup_printf (_("Broken tool detect %s (layer %d)"), input_stats->detect, this_layer);
    }    
    if (accum_stats->detect) {
       if (tmps2) {
           tmps = g_strdup_printf ("%s\n%s", accum_stats->detect, tmps2);
           g_free (accum_stats->detect);
           accum_stats->detect = NULL;
       }
    } else {
       if (tmps2) {
           tmps = g_strdup_printf ("%s", tmps2);
       }
    }
    if (tmps2) {
       g_free (tmps2);
    }
    if (tmps != NULL) {
       accum_stats->detect = tmps;
    }
 
    for (error = input_stats->error_list;
         error != NULL;
        error = error->next) {
       if (error->error_text != NULL) {
           gerbv_stats_printf(accum_stats->error_list, error->type,
                         this_layer, "%s", error->error_text);
       }
    }
 
 
    DPRINTF("<---  .... Leaving gerbv_drill_stats_add_layer.\n");
           
    return;
}
 
 
/* ------------------------------------------------------- */
gboolean
drill_stats_in_drill_list(gerbv_drill_list_t *drill_list_in,
                       int drill_num_in) {
    gerbv_drill_list_t *drill;
    for(drill = drill_list_in; drill != NULL; drill = drill->next) {
       if (drill_num_in == drill->drill_num) {
           return TRUE;
       }
    }
    return FALSE;
 
}
 
/* ------------------------------------------------------- */
gerbv_drill_list_t *
gerbv_drill_stats_new_drill_list() {
    gerbv_drill_list_t *drill_list;
 
    /* Malloc space for new drill_list struct.  Return NULL if error. */
    if (NULL == (drill_list = g_new(gerbv_drill_list_t, 1))) {
        return NULL;
    }
 
    drill_list->drill_count = 0;
    drill_list->drill_num = -1; /* default val */
    drill_list->drill_size = 0.0;
    drill_list->drill_unit = NULL;
    drill_list->next = NULL;
    return drill_list;
} 
 
 
/* ------------------------------------------------------- */
void
drill_stats_add_to_drill_list(gerbv_drill_list_t *drill_list_in, 
                           int drill_num_in, double drill_size_in,
                           char *drill_unit_in) {
 
    gerbv_drill_list_t *drill_list_new;
    gerbv_drill_list_t *drill;
    gerbv_drill_list_t *drill_last = NULL;
 
    DPRINTF("%s(%p, %d, %g, \"%s\")\n", __FUNCTION__, drill_list_in, drill_num_in,
            drill_size_in, drill_unit_in);
 
    DPRINTF("   ---> Entering drill_stats_add_to_drill_list, first drill_num in list = %d ...\n", 
           drill_list_in->drill_num);
 
    /* First check for empty list.  If empty, then just add this drill */
    if (drill_list_in->drill_num == -1) {
       DPRINTF("    .... In drill_stats_add_to_drill_list, adding first drill, no %d\n", 
              drill_num_in);
       drill_list_in->drill_num = drill_num_in;
       drill_list_in->drill_size = drill_size_in;
       drill_list_in->drill_count = 0;
       drill_list_in->drill_unit = g_strdup_printf("%s", drill_unit_in);
       drill_list_in->next = NULL;
       return;
    }
    /* Else check to see if this drill is already in the list */
    for(drill = drill_list_in; 
       drill != NULL; 
       drill = (gerbv_drill_list_t *) drill->next) {
       DPRINTF("checking this drill_num %d against that in list %d.\n", 
              drill_num_in, drill->drill_num);
       if (drill_num_in == drill->drill_num) {
           DPRINTF("   .... In drill_stats_add_to_drill_list, drill no %d already in list\n", 
                  drill_num_in);
           return;  /* Found it in list, so return */
       }
       drill_last = drill;
    }
 
    /* Now malloc space for new drill list element */
    if (NULL == (drill_list_new = g_new(gerbv_drill_list_t, 1))) {
       GERB_FATAL_ERROR("malloc format failed in %s()", __FUNCTION__);
    }
 
    /* Now set various parameters based upon calling args */
    DPRINTF("    .... In drill_stats_add_to_drill_list, adding new drill, no %d\n", 
           drill_num_in);
    drill_list_new->drill_num = drill_num_in;
    drill_list_new->drill_size = drill_size_in;
    drill_list_new->drill_count = 0;
    drill_list_new->drill_unit = g_strdup_printf("%s", drill_unit_in);
    drill_list_new->next = NULL;
    drill_last->next = drill_list_new;
 
    DPRINTF("   <---- ... leaving drill_stats_add_to_drill_list.\n");
    return;
}
 
/* ------------------------------------------------------- */
void
drill_stats_modify_drill_list(gerbv_drill_list_t *drill_list_in, 
                           int drill_num_in, double drill_size_in,
                           char *drill_unit_in) {
 
    gerbv_drill_list_t *drill;
 
    DPRINTF("   ---> Entering drill_stats_modify_drill_list, first drill_num in list = %d ...\n", 
           drill_list_in->drill_num);
 
    /* Look for this drill num in list */
    for(drill = drill_list_in; 
       drill != NULL; 
       drill = (gerbv_drill_list_t *) drill->next) {
       DPRINTF("checking this drill_num %d against that in list %d.\n", 
              drill_num_in, drill->drill_num);
       if (drill_num_in == drill->drill_num) {
           DPRINTF("   .... Found it, now update it ....\n");
           drill->drill_size = drill_size_in;
           if (drill->drill_unit) 
              g_free(drill->drill_unit);
           drill->drill_unit = g_strdup_printf("%s", drill_unit_in);
           DPRINTF("   <---- ... Modified drill.  leaving drill_stats_modify_drill_list.\n");
           return;
       }
    }
    DPRINTF("   <---- ... Did not find drill.  leaving drill_stats_modify_drill_list.\n");
    return;
}
 
/* ------------------------------------------------------- */
void
drill_stats_increment_drill_counter(gerbv_drill_list_t *drill_list_in, 
                                int drill_num_in) {
 
    DPRINTF("   ----> Entering drill_stats_increment_drill_counter......\n");
    /* First check to see if this drill is already in the list */
    gerbv_drill_list_t *drill;
    for(drill = drill_list_in; drill != NULL; drill = drill->next) {
       if (drill_num_in == drill->drill_num) {
           drill->drill_count++;
           DPRINTF("         .... incrementing drill count.  drill_num = %d, drill_count = %d.\n",
                  drill_list_in->drill_num, drill->drill_count);
           DPRINTF("   <---- .... Leaving drill_stats_increment_drill_counter after incrementing counter.\n");
           return;
       }
    }
    DPRINTF("   <---- .... Leaving drill_stats_increment_drill_counter without incrementing any counter.\n");
 
}
 
/* ------------------------------------------------------- */
void
drill_stats_add_to_drill_counter(gerbv_drill_list_t *drill_list_in, 
                             int drill_num_in, 
                             int increment) {
 
    gerbv_drill_list_t *drill;
    for(drill = drill_list_in; drill != NULL; drill = drill->next) {
       if (drill_num_in == drill->drill_num) {
           DPRINTF("    In drill_stats_add_to_drill_counter, adding increment = %d drills to drill list\n", increment);
           drill->drill_count += increment;
           return;
       }
    }
}
 
 
/* ------------------------------------------------------- */
gerbv_error_list_t *
gerbv_drill_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
drill_stats_add_error(gerbv_error_list_t *error_list_in, 
                    int layer, const char *error_text,
                    gerbv_message_type_t type)
{
    gerbv_stats_add_error(error_list_in, layer, error_text, type);
}