Changeset a136346 in rtems-tools


Ignore:
Timestamp:
08/05/14 13:01:15 (8 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, 5, master
Children:
4fd758e
Parents:
058d502
Message:

Fix temporary file handling and add tempfile write support.

Move the static objects into the rld-process file and change the
clean up to a call.

Add support to write to tempfiles.

Location:
linkers
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • linkers/rld-cc.cpp

    r058d502 ra136346  
    100100        {
    101101          std::string line;
    102           out.getline (line);
     102          out.read_line (line);
    103103          if (line.size () == 0)
    104104            break;
     
    144144          out.output ("cc", std::cout, true);
    145145        out.open ();
    146         out.get (path);
     146        out.read (path);
    147147        out.close ();
    148148        if (rld::verbose () >= RLD_VERBOSE_DETAILS)
  • linkers/rld-process.cpp

    r058d502 ra136346  
    6060  namespace process
    6161  {
     62    /**
     63     * Keep the temporary files if true. Used to help debug a system.
     64     */
     65    bool keep_temporary_files = false;
     66
     67    /**
     68     * The temporary files.
     69     */
     70    temporary_files temporaries;
     71
    6272    temporary_files::temporary_files ()
    6373    {
     
    7080
    7181    const std::string
    72     temporary_files::get ()
    73     {
    74       char* temp = ::make_temp_file ("rldXXXXXX");
     82    temporary_files::get (const std::string& suffix)
     83    {
     84      char* temp = ::make_temp_file (suffix.c_str ());
    7585
    7686      if (!temp)
    77         throw rld::error ("bad temp name", "pex");
     87        throw rld::error ("bad temp name", "temp-file");
    7888
    7989      std::string name = temp;
     
    8797    temporary_files::unlink (const std::string& name)
    8898    {
    89       struct stat sb;
    90       if ((::stat (name.c_str (), &sb) >= 0) && S_ISREG (sb.st_mode))
    91       {
    92         int r;
     99      if (!keep_temporary_files)
     100      {
     101        struct stat sb;
     102        if ((::stat (name.c_str (), &sb) >= 0) && S_ISREG (sb.st_mode))
     103        {
     104          int r;
    93105#if _WIN32
    94         r = ::remove(name.c_str ());
     106          r = ::remove(name.c_str ());
    95107#else
    96         r = ::unlink (name.c_str ());
    97 #endif
    98         if (r < 0)
    99         {
    100           std::cerr << "error: unlinking temp file: " << name << std::endl;
    101           ::exit (100);
     108          r = ::unlink (name.c_str ());
     109#endif
     110          if (r < 0)
     111          {
     112            std::cerr << "error: unlinking temp file: " << name << std::endl;
     113            ::exit (100);
     114          }
    102115        }
    103116      }
     
    131144    }
    132145
    133     tempfile::tempfile ()
    134       : fd (-1),
     146    tempfile::tempfile (const std::string& suffix)
     147      : suffix (suffix),
     148        fd (-1),
    135149        level (0)
    136150    {
    137       _name = temporaries.get ();
     151      _name = temporaries.get (suffix);
    138152    }
    139153
     
    145159
    146160    void
    147     tempfile::open ()
     161    tempfile::open (bool writable)
    148162    {
    149163      if ((fd < 0) && rld::files::check_file (_name))
    150164      {
    151165        level = 0;
    152         fd = ::open (_name.c_str (), O_RDONLY);
     166        fd = ::open (_name.c_str (), writable ? O_RDWR : O_RDONLY);
    153167        if (fd < 0)
    154168          throw rld::error (::strerror (errno), "tempfile open:" + _name);
     
    187201
    188202    void
    189     tempfile::get (std::string& all)
     203    tempfile::read (std::string& all)
    190204    {
    191205      all.clear ();
     
    209223
    210224    void
    211     tempfile::getline (std::string& line)
     225    tempfile::read_line (std::string& line)
    212226    {
    213227      line.clear ();
     
    243257
    244258    void
     259    tempfile::write (const std::string& s)
     260    {
     261      const char* p = s.c_str ();
     262      size_t      l = s.length ();
     263      while (l)
     264      {
     265        int written = ::write (fd, p, l);
     266        if (written < 0)
     267            throw rld::error (::strerror (errno), "tempfile write:" + _name);
     268        if (written == 0)
     269          break;
     270        l -= written;
     271      }
     272    }
     273
     274    void
     275    tempfile::write_line (const std::string& s)
     276    {
     277      write (s);
     278      write (RLD_LINE_SEPARATOR);
     279    }
     280
     281    void
     282    tempfile::write_lines (const rld::strings& ss)
     283    {
     284      for (rld::strings::const_iterator ssi = ss.begin ();
     285           ssi != ss.end ();
     286           ++ssi)
     287      {
     288        write_line (*ssi);
     289      }
     290    }
     291
     292    void
    245293    tempfile::output (std::ostream& out)
    246294    {
     
    261309        while (true)
    262310        {
    263           getline (line);
     311          read_line (line);
    264312          ++lc;
    265313          if (line.empty ())
     
    275323    }
    276324
     325    void
     326    set_keep_temporary_files ()
     327    {
     328      keep_temporary_files = true;
     329    }
     330
     331    void
     332    temporaries_clean_up ()
     333    {
     334      temporaries.clean_up ();
     335    }
     336
    277337    status
    278338    execute (const std::string& pname,
  • linkers/rld-process.h

    r058d502 ra136346  
    11/*
    2  * Copyright (c) 2011, Chris Johns <chrisj@rtems.org> 
     2 * Copyright (c) 2011, Chris Johns <chrisj@rtems.org>
    33 *
    44 * Permission to use, copy, modify, and/or distribute this software for any
    55 * purpose with or without fee is hereby granted, provided that the above
    66 * copyright notice and this permission notice appear in all copies.
    7  * 
     7 *
    88 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    99 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     
    4545       */
    4646      typedef std::list < std::string > tempfile_container;
    47      
     47
    4848      /**
    4949       * Construct the temporary files.
     
    5959       * Get a new temporary file name.
    6060       */
    61       const std::string get ();
     61      const std::string get (const std::string& suffix = ".rldxx");
    6262
    6363      /**
     
    8181
    8282    };
    83 
    84     /**
    85      * The temporary files.
    86      */
    87     static temporary_files temporaries;
    8883
    8984    /**
     
    9792       * Get a temporary file name.
    9893       */
    99       tempfile ();
     94      tempfile (const std::string& suffix = ".rldxx");
    10095
    10196      /**
     
    105100
    106101      /**
    107        * Open the temporary file.
    108        */
    109       void open ();
     102       * Open the temporary file. It can optionally be written too.
     103       */
     104      void open (bool writable = false);
    110105
    111106      /**
     
    125120
    126121      /**
    127        * Get all the file.
    128        */
    129       void get (std::string& all);
    130 
    131       /**
    132        * Get time.
    133        */
    134       void getline (std::string& line);
     122       * Read all the file.
     123       */
     124      void read (std::string& all);
     125
     126      /**
     127       * Read a line at a time.
     128       */
     129      void read_line (std::string& line);
     130
     131      /**
     132       * Write the string to the file.
     133       */
     134      void write (const std::string& s);
     135
     136      /**
     137       * Write the string as a line to the file.
     138       */
     139      void write_line (const std::string& s);
     140
     141      /**
     142       * Write the strings to the file using a suitable line separator.
     143       */
     144      void write_lines (const rld::strings& ss);
    135145
    136146      /**
    137147       * Output the file.
    138148       */
    139       void output (const std::string& prefix, 
    140                    std::ostream&      out, 
     149      void output (const std::string& prefix,
     150                   std::ostream&      out,
    141151                   bool               line_numbers = false);
    142152
     
    148158    private:
    149159
    150       std::string _name;    //< The name of the file.
    151       int         fd;       //< The file descriptor
    152       char        buf[256]; //< The read buffer.
    153       int         level;    //< The level of data in the buffer.
     160      std::string       _name;    //< The name of the file.
     161      const std::string suffix;   //< The temp file's suffix.
     162      int               fd;       //< The file descriptor
     163      char              buf[256]; //< The read buffer.
     164      int               level;    //< The level of data in the buffer.
    154165    };
    155    
     166
     167    /**
     168     * Keep the temporary files.
     169     */
     170    void set_keep_temporary_files ();
     171
     172    /**
     173     * Clean up the temporaryes.
     174     */
     175    void temporaries_clean_up ();
     176
    156177    /**
    157178     * The arguments containter has a single argument per element.
     
    170191        stopped //< The process has not terminated, but has stopped and can be restarted.
    171192      };
    172      
     193
    173194      types type; //< Type of status.
    174195      int   code; //< The status code returned.
     
    179200     * the program name to run. Return an error code.
    180201     */
    181     status execute (const std::string&   pname, 
     202    status execute (const std::string&   pname,
    182203                    const arg_container& args,
    183204                    const std::string&   outname,
     
    188209     * string. Return an error code.
    189210     */
    190     status execute (const std::string& pname, 
     211    status execute (const std::string& pname,
    191212                    const std::string& command,
    192213                    const std::string& outname,
  • linkers/rtems-ld.cpp

    r058d502 ra136346  
    133133  signal (signum, SIG_DFL);
    134134
    135   rld::process::temporaries.clean_up ();
     135  rld::process::temporaries_clean_up ();
    136136
    137137  /*
  • linkers/rtems-ra.cpp

    r058d502 ra136346  
    118118  signal (signum, SIG_DFL);
    119119
    120   rld::process::temporaries.clean_up ();
     120  rld::process::temporaries_clean_up ();
    121121
    122122  /*
     
    316316       */
    317317      rld::files::find_libraries (libraries, libpaths, libs);
    318  
     318
    319319      /*
    320320       * Are we to load standard libraries ?
     
    331331        rld::symbols::table  symbols;
    332332        rld::files::cache*   cache = new rld::files::cache ();
    333  
     333
    334334        library.clear ();
    335335        library.push_back (*p);
    336  
     336
    337337        /*
    338338        * Open the cache.
    339339        */
    340340        cache->open ();
    341  
     341
    342342        /*
    343343         * Load the library to the cache.
    344344         */
    345345        cache->add_libraries (library);
    346  
     346
    347347        cache->load_symbols (symbols);
    348  
     348
    349349        try
    350350        {
    351  
     351
    352352          rld::files::objects& objs = cache->get_objects ();
    353353          rld::files::paths    raobjects;
    354  
     354
    355355          int pos = -1;
    356356          std::string rap_name;
     
    360360          {
    361361            rld::files::object* obj = (*obi).second;
    362  
     362
    363363            dependents.clear ();
    364  
     364
    365365            rap_name = obj->name ().oname ();
    366  
     366
    367367            pos = obj->name ().oname ().rfind ('.', rap_name.length ());
    368368            if (pos != -1)
     
    370370              rap_name.erase (pos, rap_name.length ());
    371371            }
    372  
     372
    373373            rap_name += ".rap";
    374  
     374
    375375            dependents.push_back (obj);
    376  
     376
    377377            raobjects.push_back (rap_name);
    378  
     378
    379379            /* Todo: include absolute name for rap_name */
    380  
     380
    381381            rld::outputter::application (rap_name, entry, exit,
    382382                                         dependents, *cache, symbols,
    383383                                         true);
    384384          }
    385  
     385
    386386          dependents.clear ();
    387387          for (rld::files::paths::iterator ni = raobjects.begin (); ni != raobjects.end (); ++ni)
     
    390390            dependents.push_back (obj);
    391391          }
    392  
     392
    393393          bool ra_rap = true;
    394394          bool ra_exist = false;
    395395          rld::files::cache cachera;
    396396          std::string raname = *p;
    397  
     397
    398398          pos = -1;
    399399          pos = raname.rfind ('/', raname.length ());
     
    402402            raname.erase (0, pos);
    403403          }
    404  
     404
    405405          pos = -1;
    406406          pos = raname.rfind ('.', raname.length ());
     
    410410          }
    411411          raname += ".ra";
    412  
     412
    413413          raname = output_path + raname;
    414  
     414
    415415          rld::outputter::archivera (raname, dependents, cachera,
    416416                                     ra_exist, ra_rap);
    417417          std::cout << "Generated: " << raname << std::endl;
    418  
    419  
     418
     419
    420420          for (rld::files::object_list::iterator oi = dependents.begin ();
    421421               oi != dependents.end ();
     
    431431          throw;
    432432        }
    433  
     433
    434434        cache->archives_end ();
    435435        delete cache;
     
    439439    {
    440440     /*
    441       * Add, replace, delete files from the ra file. 
     441      * Add, replace, delete files from the ra file.
    442442      */
    443443      for (rld::files::paths::iterator pl = libs.begin (); pl != libs.end (); ++pl)
     
    445445        rld::files::paths    library;
    446446        rld::files::cache*   cache = new rld::files::cache ();
    447  
     447
    448448        library.clear ();
    449449        library.push_back (*pl);
    450  
     450
    451451        /*
    452452        * Open the cache.
    453453        */
    454454        cache->open ();
    455  
     455
    456456        /*
    457457         * Load the library to the cache.
    458458         */
    459459        cache->add_libraries (library);
    460  
     460
    461461        rld::files::objects& objs = cache->get_objects ();
    462462        rld::files::paths    raobjects;
    463  
     463
    464464        std::string rap_name;
    465465        bool rap_delete = false;
    466  
     466
    467467        dependents.clear ();
    468468        /*
     
    474474        {
    475475          rld::files::object* obj = (*obi).second;
    476  
     476
    477477          rap_name = obj->name ().oname ();
    478478          rap_delete = false;
    479  
     479
    480480          for (rld::files::paths::iterator pa = raps_delete.begin ();
    481481               pa != raps_delete.end ();
     
    488488            }
    489489          }
    490  
     490
    491491          if (!rap_delete)
    492492            dependents.push_back (obj);
    493493        }
    494  
     494
    495495        /*
    496496         * Add rap files into ra file, add supports replace.
     
    503503        {
    504504          rap_exist = false;
    505  
     505
    506506          for (rld::files::object_list::iterator oi = dependents.begin ();
    507507               oi != dependents.end ();
     
    516516            }
    517517          }
    518  
     518
    519519          if (!rap_exist)
    520520            rap_objects.push_back (*pa);
    521521        }
    522  
     522
    523523        for (rld::files::paths::iterator pa = rap_objects.begin ();
    524524             pa != rap_objects.end ();
     
    533533          else dependents.push_back (obj);
    534534        }
    535  
     535
    536536        /*
    537537         * Replace rap files in ra file
     
    539539        bool rap_replace = false;
    540540        rld::files::cache cachera;
    541  
     541
    542542        rap_objects.clear ();
    543543        cachera.open ();
    544  
     544
    545545        for (rld::files::paths::iterator pa = raps_replace.begin ();
    546546             pa != raps_replace.end ();
     
    548548        {
    549549          rap_replace = false;
    550  
     550
    551551          for (rld::files::object_list::iterator oi = dependents.begin ();
    552552               oi != dependents.end ();
     
    562562            ++oi;
    563563          }
    564  
     564
    565565          if (rap_replace)
    566566            rap_objects.push_back (*pa);
    567567        }
    568  
     568
    569569        for (rld::files::paths::iterator pa = rap_objects.begin ();
    570570             pa != rap_objects.end ();
     
    579579          else dependents.push_back (obj);
    580580        }
    581  
     581
    582582        rld::outputter::archivera (*pl, dependents, cachera,
    583583                                   true, true);
    584584        std::cout << "End" << std::endl;
    585  
     585
    586586        cache->archives_end ();
    587587        delete cache;
  • linkers/rtems-rapper.cpp

    r058d502 ra136346  
    11121112  signal (signum, SIG_DFL);
    11131113
    1114   rld::process::temporaries.clean_up ();
     1114  rld::process::temporaries_clean_up ();
    11151115
    11161116  /*
  • linkers/rtems-syms.cpp

    r058d502 ra136346  
    9393  signal (signum, SIG_DFL);
    9494
    95   rld::process::temporaries.clean_up ();
     95  rld::process::temporaries_clean_up ();
    9696
    9797  /*
Note: See TracChangeset for help on using the changeset viewer.