gerbview cleanup, and working towards aperture macro support

change_log.txt

@@ -5,6 +5,17 @@ Started 2007-June-11
 Please add newer entries at the top, list the date and your name with
 email address.
 
+2008-Nov-8 UPDATE Dick Hollenbeck <dick@softplc.com>
+================================================================================
++gerview
+    Added support for reading in aperture macros embedded in a RS274X compatible file.
+    Cannot display them yet.
+    General cleanup of gerbview.  GERBER_Descr replaced with class GERBER.
+    ReturnToolDescr() replaced with GERBER::GetDCODE().
+    D_CODEs are created lazily now.  pcbnew's gerber plotting needs testing, might
+    have broke something there, accidentally.
+
+
 2008-nov-5 UPDATE Andrey Fedorushkov <andrf@mail.ru>
 ================================================================================
 +all:

gerbview/affiche.cpp

@@ -31,14 +31,14 @@ void Affiche_Infos_PCB_Texte( WinEDA_BasePcbFrame* frame, TEXTE_PCB* pt_texte )
     else
         Affiche_1_Parametre( frame, 1, _( "PCB Text" ), pt_texte->m_Text, DARKGREEN );
 
-    Line = _( "Layer " ); 
+    Line = _( "Layer " );
     Line << pt_texte->GetLayer() + 1;
-    
+
     Affiche_1_Parametre( frame, 28, _( "Layer:" ), Line,
                          g_DesignSettings.m_LayerColor[pt_texte->GetLayer()] );
 
     Affiche_1_Parametre( frame, 36, _( "Mirror" ), wxEmptyString, GREEN );
-    
+
     if( (pt_texte->m_Miroir & 1) )
         Affiche_1_Parametre( frame, -1, wxEmptyString, _( "No" ), DARKGREEN );
     else
@@ -58,58 +58,3 @@ void Affiche_Infos_PCB_Texte( WinEDA_BasePcbFrame* frame, TEXTE_PCB* pt_texte )
     Affiche_1_Parametre( frame, 70, _( "V Size" ), Line, RED );
 }
 
-
-/*********************************************************************/
-void Affiche_Infos_Piste( WinEDA_BasePcbFrame* frame, TRACK* pt_piste )
-/*********************************************************************/
-/* Affiche les caract principales d'un segment de piste en bas d'ecran */
-{
-    int      d_index, ii = -1;
-    D_CODE*  pt_D_code;
-	
-    int      layer = ((PCB_SCREEN*)(frame->GetScreen()))->m_Active_Layer; 
-    wxString msg;
-
-    frame->MsgPanel->EraseMsgBox();
-
-    d_index   = pt_piste->GetNet();
-    pt_D_code = ReturnToolDescr( layer, d_index, &ii );
-
-    switch( pt_piste->Type() )
-    {
-    case TYPETRACK:
-        if( pt_piste->m_Shape < S_SPOT_CIRCLE )
-            msg = wxT( "LINE" );
-        else
-            msg = wxT( "FLASH" );
-        break;
-
-    case TYPEZONE:
-        msg = wxT( "ZONE" ); break;
-
-    default:
-        msg = wxT( "????" ); break;
-    }
-
-    Affiche_1_Parametre( frame, 1, _( "Type" ), msg, DARKCYAN );
-
-    msg.Printf( wxT( "%d" ), ii + 1 );
-    Affiche_1_Parametre( frame, 10, _( "Tool" ), msg, RED );
-
-    if( pt_D_code )
-    {
-        msg.Printf( wxT( "D%d" ), d_index );
-        Affiche_1_Parametre( frame, 20, _( "D-code" ), msg, BLUE );
-
-        Affiche_1_Parametre( frame, 30, _( "D-type" ),
-                             pt_D_code ? g_GERBER_Tool_Type[pt_D_code->m_Shape] : _( "????" ),
-                             BLUE );
-    }
-
-    msg.Printf( wxT( "%d" ), pt_piste->GetLayer() + 1 );
-    Affiche_1_Parametre( frame, 40, _( "Layer" ), msg, BROWN );
-
-    /* Affiche Epaisseur */
-    valeur_param( (unsigned) (pt_piste->m_Width), msg );
-    Affiche_1_Parametre( frame, 50, _( "Width" ), msg, DARKCYAN );
-}

gerbview/dcode.cpp

@@ -63,34 +63,64 @@
     D10 ... = Indentification d'outils ( d'ouvertures )
 */
 
+
 /*********************************/
 /* class GERBER : Methodes */
 /*********************************/
 
-GERBER::GERBER( int layer )
+GERBER::GERBER( int aLayer )
 {
-    int ii;
+    m_Layer = aLayer;            // Layer Number
 
-    m_Layer = layer;            // Layer Number
     m_Selected_Tool = FIRST_DCODE;
+
     ResetDefaultValues();
-    for( ii = 0; ii <= MAX_TOOLS; ii++ )
-        m_Aperture_List[ii] = new D_CODE( ii + FIRST_DCODE );
+
+    for( unsigned ii = 0; ii < DIM( m_Aperture_List );  ii++ )
+        m_Aperture_List[ii] = 0;
 }
 
 
 GERBER::~GERBER()
 {
-    int ii;
+    for( unsigned ii = 0; ii < DIM(m_Aperture_List); ii++ )
+    {
+        delete m_Aperture_List[ii];
+        // m_Aperture_List[ii] = NULL;
+    }
+}
+
 
-    if( m_Aperture_List )
+D_CODE* GERBER::GetDCODE( int aDCODE, bool create )
+{
+    unsigned ndx = aDCODE - FIRST_DCODE;
+
+    if( ndx < (unsigned) DIM(m_Aperture_List) )
     {
-        for( ii = 0; ii < MAX_TOOLS; ii++ )
+        // lazily create the D_CODE if it does not exist.
+        if( create )
         {
-            delete m_Aperture_List[ii];
-            m_Aperture_List[ii] = NULL;
+            if( m_Aperture_List[ndx] == NULL )
+                m_Aperture_List[ndx] = new D_CODE( ndx + FIRST_DCODE );
         }
+
+        return m_Aperture_List[ndx];
     }
+    return NULL;
+}
+
+
+APERTURE_MACRO* GERBER::FindApertureMacro( const APERTURE_MACRO& aLookup )
+{
+    APERTURE_MACRO_SET::iterator iter = m_aperture_macros.find( aLookup );
+
+    if( iter != m_aperture_macros.end() )
+    {
+        APERTURE_MACRO* pam = (APERTURE_MACRO*) &(*iter);
+        return pam;
+    }
+
+    return NULL;    // not found
 }
 
 
@@ -107,8 +137,9 @@ void GERBER::ResetDefaultValues()
     m_NoTrailingZeros = FALSE;          // True: zeros a droite supprim�s
     m_MirorA   = FALSE;                 // True: miror / axe A (X)
     m_MirorB   = FALSE;                 // True: miror / axe B (Y)
-    m_As_DCode = FALSE;                 // TRUE = DCodes in file (FALSE = no DCode->
-                                // separate DCode file
+    m_Has_DCode = FALSE;                // TRUE = DCodes in file (FALSE = no DCode->
+                                        // separate DCode file
+
     m_Offset.x = m_Offset.y = 0;        // Coord Offset
 
     m_FmtScale.x = m_FmtScale.y = g_Default_GERBER_Format % 10;
@@ -136,36 +167,27 @@ void GERBER::ResetDefaultValues()
 int GERBER::ReturnUsedDcodeNumber()
 /********************************************/
 {
-    int ii, jj;
+    int count = 0;
 
-    jj = 0;
-    if( m_Aperture_List )
+    for( unsigned ii = 0; ii < DIM(m_Aperture_List); ii++ )
     {
-        for( ii = 0; ii < MAX_TOOLS; ii++ )
-        {
+        if( m_Aperture_List[ii] )
             if( m_Aperture_List[ii]->m_InUse || m_Aperture_List[ii]->m_Defined )
-                jj++;
-        }
+                ++count;
     }
-    return jj;
+    return count;
 }
 
 
 /******************************/
 void GERBER::InitToolTable()
 /******************************/
-
-/* Creation du tableau des MAX_TOOLS DCodes utilisables, si il n'existe pas,
-  * et Init des DCodes � une valeur raisonnable
- */
 {
-    int count;
-
-    /* Init du buffer des D_CODES a des valeurs raisonnables */
-    for( count = 0; count < MAX_TOOLS; count++ )
+    for( int count = 0; count < MAX_TOOLS; count++ )
     {
         if( m_Aperture_List[count] == NULL )
             continue;
+
         m_Aperture_List[count]->m_Num_Dcode = count + FIRST_DCODE;
         m_Aperture_List[count]->Clear_D_CODE_Data();
     }
@@ -184,7 +206,6 @@ void GERBER::InitToolTable()
 D_CODE::D_CODE( int num_dcode )
 {
     m_Num_Dcode = num_dcode;
-    m_Macro = 0;
     Clear_D_CODE_Data();
 }
 
@@ -203,6 +224,25 @@ void D_CODE::Clear_D_CODE_Data()
     m_DrillShape = 0;
     m_InUse   = FALSE;
     m_Defined = FALSE;
+    m_Macro = 0;
+}
+
+const wxChar* D_CODE::ShowApertureType( APERTURE_T aType )
+{
+    const wxChar* ret;
+
+    switch( aType )
+    {
+    case APT_CIRCLE:    ret = wxT( "Round" );   break;
+    case APT_LINE:      ret = wxT( "Line" );    break;
+    case APT_RECT:      ret = wxT( "Rect" );    break;
+    case APT_OVAL:      ret = wxT( "Oval" );    break;
+    case APT_POLYGON:   ret = wxT( "Poly" );    break;
+    case APT_MACRO:     ret = wxT( "Macro" );   break;
+    default:            ret = wxT( "???" );     break;
+    }
+
+    return ret;
 }
 
 
@@ -217,7 +257,7 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
     char     c_type_outil[256];
     char     line[GERBER_BUFZ];
     wxString msg;
-    D_CODE*  pt_Dcode;
+    D_CODE*  dcode;
     FILE*    dest;
     int      layer = GetScreen()->m_Active_Layer;
     int      type_outil;
@@ -227,6 +267,9 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
         g_GERBER_List[layer] = new GERBER( layer );
     }
 
+    GERBER* gerber = g_GERBER_List[layer];
+
+
     /* Mise a jour de l'echelle gerber : */
     dcode_scale   = 10; /* ici unit dcode = mil, unit interne = 0.1 mil
                           *  -> 1 unite dcode = 10 unit PCB */
@@ -243,16 +286,18 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
         return -1;
     }
 
-    g_GERBER_List[layer]->InitToolTable();
+    gerber->InitToolTable();
 
     while( fgets( line, sizeof(line) - 1, dest ) != NULL )
     {
         if( *line == ';' )
             continue;                       /* Commentaire */
+
         if( strlen( line ) < 10 )
             continue;                       /* Probablemant ligne vide */
 
-        pt_Dcode = NULL; current_Dcode = 0;
+        dcode = NULL;
+        current_Dcode = 0;
 
         /* Determination du type de fichier D_Code */
         ptcar = line;
@@ -277,7 +322,9 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
         }
         else        /* valeurs en inches a convertir en mils */
         {
-            fdrill = 0; current_Dcode = 0; fdrill = 0;
+            fdrill = 0;
+            current_Dcode = 0;
+
             sscanf( line, "%f,%f,%1s", &fdimV, &fdimH, c_type_outil );
             ptcar = line;
             while( *ptcar )
@@ -311,12 +358,12 @@ int WinEDA_GerberFrame::Read_D_Code_File( const wxString& D_Code_FullFileName )
         if( current_Dcode >= MAX_TOOLS )
             continue;
 
-        pt_Dcode = ReturnToolDescr( layer, current_Dcode );
-        pt_Dcode->m_Size.x  = dimH;
-        pt_Dcode->m_Size.y  = dimV;
-        pt_Dcode->m_Shape   = (APERTURE_T) type_outil;
-        pt_Dcode->m_Drill.x = pt_Dcode->m_Drill.y = drill;
-        pt_Dcode->m_Defined = TRUE;
+        dcode = gerber->GetDCODE( current_Dcode );
+        dcode->m_Size.x  = dimH;
+        dcode->m_Size.y  = dimV;
+        dcode->m_Shape   = (APERTURE_T) type_outil;
+        dcode->m_Drill.x = dcode->m_Drill.y = drill;
+        dcode->m_Defined = TRUE;
     }
 
     fclose( dest );
@@ -332,14 +379,15 @@ void WinEDA_GerberFrame::CopyDCodesSizeToItems()
 /* Set Size Items (Lines, Flashes) from DCodes List
  */
 {
-    TRACK*  track;
-    D_CODE* pt_Dcode; /* Pointeur sur le D code*/
-
-    track = m_Pcb->m_Track;
-    for( ; track != NULL; track = (TRACK*) track->Pnext )
+    for( TRACK* track = m_Pcb->m_Track;  track;  track = track->Next() )
     {
-        pt_Dcode = ReturnToolDescr( track->GetLayer(), track->GetNet() );
-        pt_Dcode->m_InUse = TRUE;
+        GERBER* gerber = g_GERBER_List[track->GetLayer()];
+        wxASSERT( gerber );
+
+        D_CODE* dcode  = gerber->GetDCODE( track->GetNet(), false );
+        wxASSERT( dcode );
+
+        dcode->m_InUse = TRUE;
 
         if(                                     // Line Item
             (track->m_Shape == S_SEGMENT )      /* segment rectiligne */
@@ -349,12 +397,12 @@ void WinEDA_GerberFrame::CopyDCodesSizeToItems()
             || (track->m_Shape == S_ARC_RECT )  /* segment en arc de cercle (bouts droits) (GERBER)*/
             )
         {
-            track->m_Width = pt_Dcode->m_Size.x;
+            track->m_Width = dcode->m_Size.x;
         }
         else        // Spots ( Flashed Items )
         {
             int    width, len;
-            wxSize size = pt_Dcode->m_Size;
+            wxSize size = dcode->m_Size;
 
             width = MIN( size.x, size.y );
             len   = MAX( size.x, size.y ) - width;
@@ -365,7 +413,7 @@ void WinEDA_GerberFrame::CopyDCodesSizeToItems()
             track->m_Start.y = (track->m_Start.y + track->m_End.y) / 2;
             track->m_End = track->m_Start;  // m_Start = m_End = Spot center
 
-            switch( pt_Dcode->m_Shape )
+            switch( dcode->m_Shape )
             {
             case APT_LINE:          // ne devrait pas etre utilis� ici
             case APT_CIRCLE:        /* spot round (for GERBER)*/
@@ -397,26 +445,6 @@ void WinEDA_GerberFrame::CopyDCodesSizeToItems()
 }
 
 
-/*********************************************************/
-D_CODE* ReturnToolDescr( int layer, int Dcode, int* index )
-/*********************************************************/
-{
-    GERBER*     gerber = g_GERBER_List[layer];
-    D_CODE*     pt_dcode  = NULL;
-
-    if( index )
-        *index = 0;
-
-    if( gerber && Dcode >= FIRST_DCODE && Dcode < MAX_TOOLS )
-    {
-        pt_dcode = gerber->m_Aperture_List[Dcode - FIRST_DCODE];
-        if( index )
-            *index = Dcode - FIRST_DCODE + 1;
-    }
-    return pt_dcode;
-}
-
-
 /************************************************/
 void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
 /************************************************/
@@ -427,15 +455,13 @@ void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
     WinEDA_TextFrame*   List;
     int                 scale      = 10000;
     int                 curr_layer = GetScreen()->m_Active_Layer;
-    int                 layer;
-    GERBER*             gerber;
 
     /* Construction de la liste des messages */
     List = new WinEDA_TextFrame( this, _( "List D codes" ) );
 
-    for( layer = 0; layer < 32; layer++ )
+    for( int layer = 0; layer < 32; layer++ )
     {
-        gerber = g_GERBER_List[layer];
+        GERBER* gerber = g_GERBER_List[layer];
         if( gerber == NULL )
             continue;
 
@@ -450,7 +476,7 @@ void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
 
         for( ii = 0, jj = 1; ii < MAX_TOOLS; ii++ )
         {
-            pt_D_code = gerber->m_Aperture_List[ii];
+            pt_D_code = gerber->GetDCODE( ii + FIRST_DCODE, false );
             if( pt_D_code == NULL )
                 continue;
 
@@ -463,7 +489,8 @@ void WinEDA_GerberFrame::Liste_D_Codes( wxDC* DC )
                 pt_D_code->m_Num_Dcode,
                 (float) pt_D_code->m_Size.y / scale,
                 (float) pt_D_code->m_Size.x / scale,
-                g_GERBER_Tool_Type[pt_D_code->m_Shape] );
+                D_CODE::ShowApertureType( pt_D_code->m_Shape )
+                );
 
             if( !pt_D_code->m_Defined )
                 Line += wxT( " ?" );

gerbview/gerbview.h

@@ -58,16 +58,6 @@ enum APERTURE_T
     APT_MACRO = 'M'
 };
 
-/* replaced by APERTURE_T
-enum Gerb_StandardShape {
-    GERB_CIRCLE = 1,
-    GERB_RECT,
-    GERB_LINE,
-    GERB_OVALE,
-    GERB_SPECIAL_SHAPE
-};
-*/
-
 
 // Interpolation type
 enum Gerb_Interpolation {
@@ -111,22 +101,50 @@ enum Gerb_Analyse_Cmd {
     ENTER_RS274X_CMD
 };
 
+class D_CODE;
+
 
 /**
- * Struct DCODE_PARAM
+ * Class DCODE_PARAM
  * holds a parameter for a DCODE or an "aperture macro" as defined within standard RS274X.
  * The \a value field can be either a constant or a place holder for a DCODE
  * parameter.
  */
-struct DCODE_PARAM
+class DCODE_PARAM
 {
+public:
     DCODE_PARAM() :
-        isImmediate(true),
+        index(-1),
         value(0.0)
     {}
 
-    bool    isImmediate;    ///< the \a value field is an actual value, not a parameter place holder.
-    double  value;          ///< if immediate then the value, else an integer index into D_CODE.m_am_params.
+    double  GetValue( const D_CODE* aDcode );
+    void SetValue( double aValue )
+    {
+        value = aValue;
+        index = -1;
+    }
+
+    /**
+     * Function IsImmediate
+     * tests if this DCODE_PARAM holds an immediate parameter or is a pointer into
+     * a parameter held by an owning D_CODE.
+     */
+    bool IsImmediate() { return index == -1; }
+
+    int GetIndex()
+    {
+        return index;
+    }
+
+    void SetIndex( int aIndex )
+    {
+        index = aIndex;
+    }
+
+private:
+    int     index;      ///< if -1, then \a value field is an immediate value, else this is an index into a D_CODE parameter.
+    double  value;      ///< if immediate then the value, else an integer index into D_CODE.m_am_params.
 };
 
 
@@ -183,7 +201,7 @@ struct APERTURE_MACRO
  */
 struct APERTURE_MACRO_less_than
 {
-    // a "less than" test on two wxStrings
+    // a "less than" test on two APERTURE_MACROs (.name wxStrings)
     bool operator()( const APERTURE_MACRO& am1, const APERTURE_MACRO& am2) const
     {
         return am1.name.Cmp( am2.name ) < 0;  // case specific wxString compare
@@ -206,6 +224,14 @@ typedef std::pair<APERTURE_MACRO_SET::iterator, bool> APERTURE_MACRO_SET_PAIR;
  */
 class D_CODE
 {
+    APERTURE_MACRO* m_Macro;    ///< no ownership, points to GERBER.m_aperture_macros element
+
+    /**
+     * parameters used only when this D_CODE holds a reference to an aperture
+     * macro, and these parameters would customize the macro.
+     */
+    DCODE_PARAMS   m_am_params;
+
 public:
     wxSize      m_Size;        /* Dimensions horiz et Vert */
     APERTURE_T  m_Shape;       /* shape ( Line, rect , circulaire , ovale .. ) */
@@ -216,27 +242,55 @@ public:
     bool        m_Defined;     /* FALSE si non defini */
     wxString    m_SpecialDescr;
 
-    APERTURE_MACRO* m_Macro;    ///< no ownership, points to GERBER.m_aperture_macros element
-
-    /**
-     * parameters used only when this D_CODE holds a reference to an aperture
-     * macro, and these parameters would customize the macro.
-     */
-    DCODE_PARAMS   m_am_params;
-
 public:
     D_CODE( int num_dcode );
     ~D_CODE();
     void Clear_D_CODE_Data();
+
+    void AppendParam( double aValue )
+    {
+        DCODE_PARAM param;
+
+        param.SetValue( aValue );
+
+        m_am_params.push_back( param );
+    }
+
+    void SetMacro( APERTURE_MACRO* aMacro )
+    {
+        m_Macro = aMacro;
+    }
+
+    /**
+     * Function ShowApertureType
+     * returns a character string telling what type of aperture type \a aType is.
+     * @param aType The aperture type to show.
+     */
+    static const wxChar* ShowApertureType( APERTURE_T aType );
 };
 
 
+inline double DCODE_PARAM::GetValue( const D_CODE* aDcode )
+{
+    if( IsImmediate() )
+        return value;
+    else
+    {
+        // get the parameter from aDcode
+        return 0.0;
+    }
+}
+
+
 /**
  * Class GERBER
  * holds the data for one gerber file or layer
  */
 class GERBER
 {
+    D_CODE*       m_Aperture_List[MAX_TOOLS];                   ///< Dcode (Aperture) List for this layer
+
+
 public:
     wxString      m_FileName;                                   // Full File Name for this layer
     wxString      m_Name;                                       // Layer name
@@ -247,7 +301,7 @@ public:
     bool          m_NoTrailingZeros;                            // True: zeros a droite supprims
     bool          m_MirorA;                                     // True: miror / axe A (X)
     bool          m_MirorB;                                     // True: miror / axe B (Y)
-    bool          m_As_DCode;                                   // TRUE = DCodes in file (FALSE = no DCode->
+    bool          m_Has_DCode;                                  // TRUE = DCodes in file (FALSE = no DCode->
     // separate DCode file
     wxPoint       m_Offset;                                     // Coord Offset
     wxSize        m_FmtScale;                                   // Fmt 2.3: m_FmtScale = 3, fmt 3.4: m_FmtScale = 4
@@ -262,7 +316,6 @@ public:
     wxPoint       m_CurrentPos;                                 // current specified coord for plot
     wxPoint       m_PreviousPos;                                // old current specified coord for plot
     wxPoint       m_IJPos;                                      // IJ coord (for arcs & circles )
-    D_CODE*       m_Aperture_List[MAX_TOOLS + FIRST_DCODE + 1]; // Dcode (Aperture) List for this layer
 
     FILE*         m_Current_File;                               // Current file to read
     FILE*         m_FilesList[12];                              // Files list
@@ -283,6 +336,11 @@ public:
     void    Clear_GERBER();
     int     ReturnUsedDcodeNumber();
     void    ResetDefaultValues();
+
+
+    /**
+     * Function InitToolTable
+     */
     void    InitToolTable();
 
     // Routines utilises en lecture de ficher gerber
@@ -324,6 +382,26 @@ public:
      * @return bool - true if a macro was read in successfully, else false.
      */
     bool    ReadApertureMacro( char aBuff[GERBER_BUFZ], char*& text, FILE* gerber_file );
+
+
+    /**
+     * Function GetDCODE
+     * returns a pointer to the D_CODE within this GERBER for the given
+     * \a aDCODE.
+     * @param aDCODE The numeric value of the D_CODE to look up.
+     * @param createIfNoExist If true, then create the D_CODE if it does not exist.
+     * @return D_CODE* - the one implied by the given \a aDCODE, or NULL
+     *            if the requested \a aDCODE is out of range.
+     */
+    D_CODE* GetDCODE( int aDCODE, bool createIfNoExist=true );
+
+    /**
+     * Function FindApertureMacro
+     * looks up a previously read in aperture macro.
+     * @param aLookup A dummy APERTURE_MACRO with [only] the name field set.
+     * @return APERTURE_MACRO* - the one with a matching name, or NULL if not found.
+     */
+    APERTURE_MACRO* FindApertureMacro( const APERTURE_MACRO& aLookup );
 };
 
 
@@ -334,27 +412,6 @@ public:
 bool GetEndOfBlock( char buff[GERBER_BUFZ], char*& text, FILE* gerber_file );
 
 
-/**
- * Function ReturnToolDescr
- * returns a D_CODE given a global layer index and Dcode value.
- * @param aLayer The index into the global array of GERBER called g_GERBER_List[].
- * @param aDcode The dcode value to look up.
- * @param aIndex If not null, where to put a one basedindex into the GERBER's m_Aperture_List[] array.
- * @return D_CODE* - the looked up D_CODE or NULL if none was encountered in the gerber file for given \a aDcode.
- */
-D_CODE * ReturnToolDescr( int layer, int Dcode, int * index = NULL );
-
-
-eda_global const wxChar* g_GERBER_Tool_Type[6]
-#ifdef MAIN
-= {
-    wxT( "????" ), wxT( "Round" ), wxT( "Rect" ), wxT( "Line" ), wxT( "Oval" ), wxT( "Macro" )
-}
-
-
-#endif
-;
-
 eda_global GERBER* g_GERBER_List[32];
 
 

gerbview/readgerb.cpp

@@ -261,7 +261,7 @@ bool WinEDA_GerberFrame::Read_GERBER_File( wxDC*           DC,
     /* Init  DCodes list and perhaps read a DCODES file,
      * if the gerber file is only a RS274D file (without any aperture information)
      */
-    if( !gerber->m_As_DCode )
+    if( !gerber->m_Has_DCode )
     {
         wxString DCodeFileName;
         if( D_Code_FullFileName.IsEmpty() )

gerbview/rs274x.cpp

@@ -92,7 +92,7 @@ static int ReadInt( char*& text )
 
 /**
  * Function ReadDouble
- * reads a double in from a character buffer. If there is a comma after the double,
+ * reads a double from an ASCII character buffer. If there is a comma after the double,
  * then skip over that.
  * @param text A reference to a character pointer from which the ASCII double
  *          is read from and the pointer advanced for each character read.
@@ -171,9 +171,7 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
 {
     int      code;
     int      xy_seq_len, xy_seq_char;
-    char     ctmp;
     bool     ok = TRUE;
-    D_CODE*  dcode;
     char     line[GERBER_BUFZ];
     wxString msg;
     double   fcoord;
@@ -221,19 +219,21 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
 
             case 'X':
             case 'Y':           // Valeurs transmises :2 (really xy_seq_len : FIX ME) digits
-                code = *(text++);
-                ctmp = *(text++) - '0';
-                if( code == 'X' )
                 {
-                    m_FmtScale.x = *text - '0';                 // = nb chiffres apres la virgule
-                    m_FmtLen.x   = ctmp + m_FmtScale.x;         // = nb total de chiffres
-                }
-                else
-                {
-                    m_FmtScale.y = *text - '0';
-                    m_FmtLen.y   = ctmp + m_FmtScale.y;
+                    code = *(text++);
+                    char ctmp = *(text++) - '0';
+                    if( code == 'X' )
+                    {
+                        m_FmtScale.x = *text - '0';                 // = nb chiffres apres la virgule
+                        m_FmtLen.x   = ctmp + m_FmtScale.x;         // = nb total de chiffres
+                    }
+                    else
+                    {
+                        m_FmtScale.y = *text - '0';
+                        m_FmtLen.y   = ctmp + m_FmtScale.y;
+                    }
+                    text++;
                 }
-                text++;
                 break;
 
             case '*':
@@ -321,10 +321,6 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
             m_LayerNegative = FALSE;
         break;
 
-    case AP_MACRO:
-        ReadApertureMacro( buff, text, m_Current_File );
-        break;
-
     case INCLUDE_FILE:
         if( m_FilesPtr >= 10 )
         {
@@ -349,29 +345,45 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
         m_FilesPtr++;
         break;
 
+    case AP_MACRO:
+        ok = ReadApertureMacro( buff, text, m_Current_File );
+        if( !ok )
+            break;
+        break;
+
     case AP_DEFINITION:
-        if( *text != 'D' )
+
+        // input example:  %ADD30R,0.081800X0.101500*%
+        // at this point, text points to 2nd 'D'
+
+        if( *text++ != 'D' )
         {
             ok = FALSE;
             break;
         }
-        m_As_DCode = TRUE;
-        text++;
+
+        m_Has_DCode = TRUE;
 
         code  = ReadInt( text );
-        ctmp  = *text;
 
-        dcode = ReturnToolDescr( m_Layer, code );
+        D_CODE*  dcode;
+        dcode = GetDCODE( code );
         if( dcode == NULL )
             break;
 
-        if( text[1] == ',' )        // Tool usuel (C,R,O,P)
+        // at this point, text points to character after the ADD<num>, i.e. R in example above
+
+        // if text[0] is one of the usual apertures: (C,R,O,P), there is a comma after it.
+        if( text[1] == ',' )
         {
-            text += 2;              // text pointe size ( 1er modifier)
+            char     stdAperture = *text;
+
+            text += 2;              // skip "C," for example
+
             dcode->m_Size.x = dcode->m_Size.y =
                                   (int) round( ReadDouble( text ) * conv_scale );
 
-            switch( ctmp )
+            switch( stdAperture )
             {
             case 'C':               // Circle
                 dcode->m_Shape = APT_CIRCLE;
@@ -402,7 +414,7 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
 
             case 'O':               // oval
             case 'R':               // rect
-                dcode->m_Shape = (ctmp == 'O') ? APT_OVAL : APT_RECT;
+                dcode->m_Shape = (stdAperture == 'O') ? APT_OVAL : APT_RECT;
 
                 while( *text == ' ' )
                     text++;
@@ -444,6 +456,40 @@ bool GERBER::ExecuteRS274XCommand( int command, char buff[GERBER_BUFZ], char*& t
                 break;
             }
         }
+
+        else    // text[0] starts an aperture macro name
+        {
+            APERTURE_MACRO  am_lookup;
+
+            while( *text && *text!='*' && *text!=',' )
+                am_lookup.name.Append( *text++ );
+
+            if( *text && *text==',' )
+            {
+                while( *text && *text!='*' )
+                {
+                    double param = ReadDouble( text );
+                    if( *text == 'X' )
+                        ++text;
+
+                    dcode->AppendParam( param );
+                }
+            }
+
+            // lookup the aperture macro here.
+            APERTURE_MACRO* pam = FindApertureMacro( am_lookup );
+            if( !pam )
+            {
+                // @todo not found, don't know how to report an error
+                D( printf("aperture macro %s not found\n", CONV_TO_UTF8(am_lookup.name) );)
+                ok = false;
+                break;
+            }
+
+            D(printf("pam has %d parameters\n", pam->primitives.size() );)
+
+            dcode->SetMacro( (APERTURE_MACRO*) pam );
+        }
         break;
 
     default:
@@ -531,7 +577,6 @@ bool GERBER::ReadApertureMacro( char buff[GERBER_BUFZ], char*& text, FILE* gerbe
 
         switch( prim.primitive_id )
         {
-        default:
         case AMP_CIRCLE:
             paramCount = 4;
             break;
@@ -558,43 +603,48 @@ bool GERBER::ReadApertureMacro( char buff[GERBER_BUFZ], char*& text, FILE* gerbe
         case AMP_THERMAL:
             paramCount = 6;
             break;
+        default:
+            // @todo, there needs to be a way of reporting the line number and character offset.
+            D(printf("Invalid primitive id code %d\n", prim.primitive_id );)
+            return false;
         }
 
-        DCODE_PARAM param;
-
         for( int i=0;  i<paramCount && *text && *text!='*';  ++i )
         {
+            DCODE_PARAM param;      // construct it on each loop iteration
+
             if( *text == '$' )
             {
                 ++text;
-                param.isImmediate = false;
+                param.SetIndex( ReadInt( text ) );
             }
             else
-            {
-                param.isImmediate = true;
-            }
+                param.SetValue( ReadDouble( text ) );
 
-            param.value = ReadDouble( text );
             prim.params.push_back( param );
         }
 
+        // there are more parameters to read if this is an AMP_OUTLINE
         if( prim.primitive_id == AMP_OUTLINE )
         {
-            paramCount = (int) prim.params[1].value * 2 + 1;
+            // params[1] is a count of polygon points, so it must be given
+            // in advance, i.e. be immediate.
+            wxASSERT( prim.params[1].IsImmediate() );
+
+            paramCount = (int) prim.params[1].GetValue(0) * 2 + 1;
 
             for( int i=0; i<paramCount && *text && *text!='*';  ++i )
             {
+                DCODE_PARAM param;      // construct it on each loop
+
                 if( *text == '$' )
                 {
                     ++text;
-                    param.isImmediate = false;
+                    param.SetIndex( ReadInt( text ) );
                 }
                 else
-                {
-                    param.isImmediate = true;
-                }
+                    param.SetValue( ReadDouble( text ) );
 
-                param.value = ReadDouble( text );
                 prim.params.push_back( param );
             }
         }

include/macros.h

@@ -25,6 +25,10 @@
 #define ABS( y ) ( (y) >= 0 ? (y) : ( -(y) ) )
 #endif
 
+/// # of elements in an arrray
+#define DIM(x)           (sizeof(x)/sizeof((x)[0]))
+
+
 #define DEG2RAD( Deg ) ( (Deg) * M_PI / 180.0 )
 #define RAD2DEG( Rad ) ( (Rad) * 180.0 / M_PI )
 

pcbnew/plotgerb.h

-		/************/
-		/* pcbplot.h*/
-		/************/
+        /************/
+        /* pcbplot.h*/
+        /************/
 
 #ifndef PLOTGERB_H
 #define PLOTGERB_H
@@ -8,81 +8,84 @@
 
 /* Format Gerber : NOTES :
 Fonctions preparatoires:
-	Gn =
-	G01			interpolation lineaire ( trace de droites )
-	G02,G20,G21	Interpolation circulaire , sens trigo < 0
-	G03,G30,G31	Interpolation circulaire , sens trigo > 0
-	G04			commentaire
-	G06			Interpolation parabolique
-	G07			Interpolation cubique
-	G10			interpolation lineaire ( echelle 10x )
-	G11			interpolation lineaire ( echelle 0.1x )
-	G12			interpolation lineaire ( echelle 0.01x )
-	G36			Start polygon description
-	G37			End polygon description
-	G52			plot symbole reference par Dnn code
-	G53			plot symbole reference par Dnn ; symbole tourne de -90 degres
-	G54			Selection d'outil
-	G55			Mode exposition photo
-	G56			plot symbole reference par Dnn A code
-	G57			affiche le symbole reference sur la console
-	G58			plot et affiche le symbole reference sur la console
-	G60			interpolation lineaire ( echelle 100x )
-	G70			Unites = Inches
-	G71			Unites = Millimetres
-	G74			supprime interpolation circulaire sur 360 degre, revient a G01
-	G75			Active interpolation circulaire sur 360 degre
-	G90			Mode Coordonnees absolues
-	G91			Mode Coordonnees Relatives
+    Gn =
+    G01			interpolation lineaire ( trace de droites )
+    G02,G20,G21	Interpolation circulaire , sens trigo < 0
+    G03,G30,G31	Interpolation circulaire , sens trigo > 0
+    G04			commentaire
+    G06			Interpolation parabolique
+    G07			Interpolation cubique
+    G10			interpolation lineaire ( echelle 10x )
+    G11			interpolation lineaire ( echelle 0.1x )
+    G12			interpolation lineaire ( echelle 0.01x )
+    G36			Start polygon description
+    G37			End polygon description
+    G52			plot symbole reference par Dnn code
+    G53			plot symbole reference par Dnn ; symbole tourne de -90 degres
+    G54			Selection d'outil
+    G55			Mode exposition photo
+    G56			plot symbole reference par Dnn A code
+    G57			affiche le symbole reference sur la console
+    G58			plot et affiche le symbole reference sur la console
+    G60			interpolation lineaire ( echelle 100x )
+    G70			Unites = Inches
+    G71			Unites = Millimetres
+    G74			supprime interpolation circulaire sur 360 degre, revient a G01
+    G75			Active interpolation circulaire sur 360 degre
+    G90			Mode Coordonnees absolues
+    G91			Mode Coordonnees Relatives
 
 Coordonnees X,Y
-	X,Y sont suivies de + ou - et de m+n chiffres (non separes)
-			m = partie entiere
-			n = partie apres la virgule
-			 formats classiques : 	m = 2, n = 3 (format 2.3)
-			 						m = 3, n = 4 (format 3.4)
- 	ex:
-	G__ X00345Y-06123 D__*
+    X,Y sont suivies de + ou - et de m+n chiffres (non separes)
+            m = partie entiere
+            n = partie apres la virgule
+             formats classiques : 	m = 2, n = 3 (format 2.3)
+                                    m = 3, n = 4 (format 3.4)
+    ex:
+    G__ X00345Y-06123 D__*
 
 Outils et D_CODES
-	numero d'outil ( identification des formes )
-	1 a 99 	(classique)
-	1 a 999
-	D_CODES:
-
-	D01 ... D9 = codes d'action:
-	D01			= activation de lumiere ( baisser de plume)
-	D02			= extinction de lumiere ( lever de plume)
-	D03			= Flash
-	D09			= VAPE Flash
-	D51			= precede par G54 -> Select VAPE
-
-	D10 ... D255 = Indentification d'outils ( d'ouvertures )
-				Ne sont pas tj dans l'ordre ( voir tableau ci dessous)
+    numero d'outil ( identification des formes )
+    1 a 99 	(classique)
+    1 a 999
+    D_CODES:
+
+    D01 ... D9 = codes d'action:
+    D01			= activation de lumiere ( baisser de plume)
+    D02			= extinction de lumiere ( lever de plume)
+    D03			= Flash
+    D09			= VAPE Flash
+    D51			= precede par G54 -> Select VAPE
+
+    D10 ... D255 = Indentification d'outils ( d'ouvertures )
+                Ne sont pas tj dans l'ordre ( voir tableau ci dessous)
 */
 
 
-	/*************************************/
-	/* Constantes utiles en trace GERBER */
-	/*************************************/
+    /*************************************/
+    /* Constantes utiles en trace GERBER */
+    /*************************************/
 
 /* codes de type de forme d'outils */
+
+/*
 #define GERB_CIRCLE 1
 #define GERB_RECT 2
 #define GERB_LINE 3
 #define GERB_OVALE 4
 #define GERB_DONUT 5
+*/
 
 /* liste des D_CODES en fonction de leur numero d'ordre (numero d'outil)
-	(l'ordre 0 n'est pas utilise) ;
-	Tools have D_CODES >= 10
-	D_CODES <= 9 are used for commands only:
-		D01 ... D9 = command codes for photo plotting:
-		D01			= Light on
-		D02			= Light off
-		D03			= Flash
-		D04 .. D08	= ?
-		D09			= VAPE Flash
+    (l'ordre 0 n'est pas utilise) ;
+    Tools have D_CODES >= 10
+    D_CODES <= 9 are used for commands only:
+        D01 ... D9 = command codes for photo plotting:
+        D01			= Light on
+        D02			= Light off
+        D03			= Flash
+        D04 .. D08	= ?
+        D09			= VAPE Flash
 */
 
 #define FIRST_DCODE_VALUE 10
@@ -91,17 +94,17 @@ Outils et D_CODES
 class D_CODE
 {
 public:
-	D_CODE * m_Pnext, * m_Pback;	/* for  a linked list */
-	wxSize m_Size;					/* horiz and Vert size*/
-	int m_Type;						/* Type ( Line, rect , circulaire , ovale .. ); -1 = not used (free) descr */
-	int m_NumDcode;					/* code number ( >= 10 ); 0 = not in use */
-
-	D_CODE()
-	{
-		m_Pnext = m_Pback = NULL;
-		m_Type = -1;
-		m_NumDcode = 0;
-	}
+    D_CODE * m_Pnext, * m_Pback;	/* for  a linked list */
+    wxSize m_Size;					/* horiz and Vert size*/
+    int m_Type;						/* Type ( Line, rect , circulaire , ovale .. ); -1 = not used (free) descr */
+    int m_NumDcode;					/* code number ( >= 10 ); 0 = not in use */
+
+    D_CODE()
+    {
+        m_Pnext = m_Pback = NULL;
+        m_Type = -1;
+        m_NumDcode = 0;
+    }
 } ;