GdsWriter.h

Go to the documentation of this file.

 
#ifndef _GDSPARSER_GDSWRITER_H
#define _GDSPARSER_GDSWRITER_H
 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <assert.h>
#include <vector>
#include <iostream>
#include <fstream>

#define BYTESWAP 1
//#define BYTE unsigned char
 
//#define BOOL  int
//#define TRUE  1
//#define FALSE 0
 
//extern BYTE  gdsswap;
//extern short gdsword;

namespace GdsParser
{

typedef int BOOL;
typedef unsigned char BYTE;

struct gds_itemtype
{                                
    int   type;                      
    int   n;                         
    int   layer;                     
    int   dt;                         
    int   cell_number;               
    double mag;                       
    double angle;                     
    BOOL  abs_angle;                 
    BOOL  abs_mag;                   
    BOOL  reflect;                   
    int   cols;              
    int   rows;              
    int   col_pitch;             
    int   row_pitch;             
    int   col_pitchy;                
    int   row_pitchx;                
    int   path_end;          
    int   hor_present;           
    int   ver_present;           
    int   font;              
    int   width;                     
    int  *x;                         
    int  *y;                         
    char *text;                      
    struct gds_itemtype *nextitem;       
};                               

struct gds_celltype                  
{                                
    char *name;                      
    struct gds_itemtype *item;       
    struct gds_celltype *nextcell;     
};
 
// forward declaration of a writer class 
// which is flexiable to choose std::ofstream or gzstream
class GdsStream; 

struct GdsWriter
{
    public:
        GdsWriter(const char* filename);
        ~GdsWriter();
 
        /**************** high level interfaces *****************/

        void write_boundary(int layer, int datatype, std::vector<int> const& vx, std::vector<int> const& vy, bool has_last = true);
        void write_box(int layer, int datatype, int xl, int yl, int xh, int yh);
        void create_lib(const char* libname, double dbu_uu, double dbu_m);

        
        /**************** low level interfaces *****************/
        
        void gds_make_next_item( struct gds_itemtype **ci );
        /* dump one byte in binary format */
        void gds_bindump( BYTE x );
        /* Write 8 bytes after converting back to wacky GDS float format. */
        void gds_write_float( double x );
        void gds_swap4bytes( BYTE *four  );
        void gds_swap2bytes( BYTE *two );
        void gds_write_header(  );
        void gds_write_bgnlib(  );
        void gds_write_bgnstr(  );
        void gds_write_endlib(  );
        void gds_write_endstr(  );
        void gds_write_libname( const char *name );
        void gds_write_strname( const char *name );
        void gds_write_string( const char *s );
        void gds_write_sname( const char *s );
        void gds_write_boundary(  );
        void gds_write_box(  );
        void gds_write_boxtype( short int dt );
        void gds_write_path(  );
        void gds_write_sref(  );
        void gds_write_aref(  );
        void gds_write_text(  );
        void gds_write_endel(  );
        void gds_write_layer( short int layer );
        void gds_write_width( int width );
        void gds_write_datatype( short int dt );
        void gds_write_texttype( short int dt );
        void gds_write_generations( short int gens );
        void gds_write_pathtype( short int pt );
        void gds_write_presentation( int font, int vp, int hp );
        void gds_write_strans( BOOL reflect, BOOL abs_angle, BOOL abs_mag  );
        void gds_write_xy( const int *x, const int *y, int n, bool has_last = true);
        void gds_write_colrow( int ncols, int nrows );
        void gds_write_bgnextn( int bgnextn ); 
        void gds_write_endextn( int endextn ); 
        void gds_write_units( double dbu_uu, double dbu_m );
        void gds_write_mag( double mag );
        void gds_write_angle( double angle );
        void gds_create_lib( const char *libname, double dbu_um );    
        void gds_create_text( const char *str, int x, int y, int layer, int size );

 
        // add by Yibo Lin 
        char* gds_adjust_string(const char* input, int *output_length);
 
    protected:

        int gds_write(const char* b, std::size_t n); 
        void gds_flush(); 
 
        GdsStream* m_os; 
        //int out; // output gds file descriptor
        BYTE  gdsswap; 
        short gdsword; 
 
        std::size_t m_capacity; 
        std::size_t m_size; 
        char* m_buffer; 
};
 
} // namespace GdsParser
 
#endif