uuu/buildincmd.cpp

   1 /*
   2 * Copyright 2018-2021 NXP.
   3 *
   4 * Redistribution and use in source and binary forms, with or without modification,
   5 * are permitted provided that the following conditions are met:
   6 *
   7 * Redistributions of source code must retain the above copyright notice, this
   8 * list of conditions and the following disclaimer.
   9 *
  10 * Redistributions in binary form must reproduce the above copyright notice, this
  11 * list of conditions and the following disclaimer in the documentation and/or
  12 * other materials provided with the distribution.
  13 *
  14 * Neither the name of the NXP Semiconductor nor the names of its
  15 * contributors may be used to endorse or promote products derived from this
  16 * software without specific prior written permission.
  17 *
  18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28 * POSSIBILITY OF SUCH DAMAGE.
  29 *
  30 */
  31
  32 #include "buildincmd.h"
  33
  34 #include <algorithm>
  35 #include <locale>
  36 #include <regex>
  37
  38 static std::string replace_str(std::string str, std::string key, std::string replace);
  39 static std::string str_to_upper(const std::string &str);
  40
  41 /**
  42  * @brief Parse characters between argument name and its description and check
  43  * if its an optional one
  44  * @param[in] option The characters between argument name and its description to
  45  * be parsed
  46  * @return `0` in any case
  47  */
  48 void BuiltInScript::Arg::parser(const std::string &option)
  49 {
  50         const auto pos = option.find('[');
  51         if (pos == std::string::npos)
  52         {
  53                 return;
  54         }
  55         m_fallback_option = option.substr(pos + 1, option.find(']') - pos - 1);
  56         m_flags = ARG_OPTION | ARG_OPTION_KEY;
  57 }
  58
  59 /**
  60  * @brief Create a new BuiltInScript instance by extracting information from a
  61  * BuiltInScriptRawData instance
  62  * @param[in] p The BuiltInScriptRawData containing all data of the script this
  63  * BuiltInScript instance shall represent
  64  */
  65 BuiltInScript::BuiltInScript(const BuiltInScriptRawData * const p) :
  66         m_text{p->m_text},
  67         m_desc{p->m_desc ? p->m_desc : ""},
  68         m_name{p->m_name ? p->m_name : ""}
  69 {
  70         // Regular expression to detect script argument name occurrences
  71         static const std::regex arg_name_regexp{R"####((@| )(_\S+))####"};
  72
  73         for (std::sregex_iterator it
  74                  = std::sregex_iterator{m_text.cbegin(), m_text.cend(), arg_name_regexp};
  75                                            it != std::sregex_iterator{}; ++it)
  76         {
  77                 const std::string param{it->str(2)};
  78                 if (!find_args(param))
  79                 {
  80                         Arg a;
  81                         a.m_name = param;
  82                         a.m_flags = Arg::ARG_MUST;
  83                         m_args.emplace_back(std::move(a));
  84                 }
  85         }
  86
  87         for (size_t i = 0; i < m_args.size(); i++)
  88         {
  89                 std::string str;
  90                 str += "@";
  91                 str += m_args[i].m_name;
  92                 const auto pos = m_text.find(str);
  93                 if (pos != std::string::npos) {
  94                         const auto start_descript = m_text.find('|', pos);
  95                         if (start_descript != std::string::npos)
  96                         {
  97                                 m_args[i].m_desc = m_text.substr(start_descript + 1,
  98                                                                                 m_text.find('\n', start_descript) - start_descript - 1);
  99                                 const std::string def{m_text.substr(pos, start_descript - pos)};
 100                                 m_args[i].parser(def);
 101                         }
 102                 }
 103         }
 104 }
 105
 106 /**
 107  * @brief Check if the BuiltInScript instance has an argument called `arg`
 108  * @param[in] arg The argument for which its existence in the BuiltInScript
 109  * shall be checked
 110  * @return `true` if BuiltInScript has an argument named `arg`, `false`
 111  * otherwise
 112  */
 113 bool BuiltInScript::find_args(const std::string &arg) const
 114 {
 115         return std::any_of(m_args.cbegin(), m_args.cend(),
 116                                            [&arg](const Arg &brg){ return brg.m_name == arg; });
 117 }
 118
 119 /**
 120  * @brief Replace built-in script's arguments by actual values given in `args`
 121  * @param[in] args The actual values that shall replace the arguments (the order
 122  * must fit the order of the arguments in the script)
 123  * @return A copy of the built-in script with the arguments replaced by their
 124  * actual values
 125  */
 126 std::string BuiltInScript::replace_script_args(const std::vector<std::string> &args) const
 127 {
 128         std::string script = m_text;
 129         for (size_t i = 0; i < args.size() && i < m_args.size(); i++)
 130         {
 131                 script = replace_str(script, m_args[i].m_name, args[i]);
 132         }
 133
 134         //handle option args;
 135         for (size_t i = args.size(); i < m_args.size(); i++)
 136         {
 137                 if (m_args[i].m_flags & Arg::ARG_OPTION_KEY)
 138                 {
 139                         for (size_t j = 0; j < args.size(); j++)
 140                         {
 141                                 if (m_args[j].m_name == m_args[i].m_fallback_option)
 142                                 {
 143                                         script = replace_str(script, m_args[i].m_name, args[j]);
 144                                         break;
 145                                 }
 146                         }
 147                 }
 148         }
 149         return script;
 150 }
 151
 152 /**
 153  * @brief Print the built-in script to `stdout` followed by a newline
 154  */
 155 void BuiltInScript::show() const
 156 {
 157         printf("%s\n", m_text.c_str());
 158 }
 159
 160 /**
 161  * @brief Print the script's name, its description and its arguments to stdout
 162  */
 163 void BuiltInScript::show_cmd() const
 164 {
 165         printf("\t%s%s%s\t%s\n", g_vt_boldwhite, m_name.c_str(), g_vt_default,  m_desc.c_str());
 166         for (auto i = 0u; i < m_args.size(); ++i)
 167         {
 168                 std::string desc{m_args[i].m_name};
 169                 if (m_args[i].m_flags & Arg::ARG_OPTION)
 170                 {
 171                         desc += g_vt_boldwhite;
 172                         desc += "[Optional]";
 173                         desc += g_vt_default;
 174                 }
 175                 desc += " ";
 176                 desc += m_args[i].m_desc;
 177                 printf("\t\targ%u: %s\n", i, desc.c_str());
 178         }
 179 }
 180
 181 /**
 182  * @brief Create a new map by parsing an array of BuiltInScriptRawData instances
 183  * @param[in] p Pointer to the first element of a BuiltInScriptRawData array
 184  */
 185 BuiltInScriptMap::BuiltInScriptMap(const BuiltInScriptRawData*p)
 186 {
 187         while (p->m_name)
 188         {
 189                 emplace(p->m_name, p);
 190                 ++p;
 191         }
 192 }
 193
 194 /**
 195  * @brief Auto-complete names of built-in scripts if they match `match`
 196  * @param[in] match The string against which the scripts' names will be matched
 197  * @param[in] space A separator character which shall be printed after the
 198  * completed script name
 199  */
 200 void BuiltInScriptMap::PrintAutoComplete(const std::string &match, const char *space) const
 201 {
 202         for (const auto &script_pair : *this)
 203         {
 204                 if(script_pair.first.substr(0, match.size()) == match)
 205                 {
 206                         printf("%s%s\n", script_pair.first.c_str(), space);
 207                 }
 208         }
 209 }
 210
 211 /**
 212  * @brief Print information about all contained scripts to stdout
 213  */
 214 void BuiltInScriptMap::ShowAll() const
 215 {
 216         for (const auto &script_pair : *this)
 217         {
 218                 script_pair.second.show_cmd();
 219         }
 220 }
 221
 222 /**
 223  * @brief Print the names of all contained scripts to the given stream
 224  * @param[in] file The stream to which the names shall be printed
 225  */
 226 void BuiltInScriptMap::ShowCmds(FILE * const file) const
 227 {
 228         fprintf(file, "<");
 229         for (auto iCol = begin(); iCol != end(); ++iCol)
 230         {
 231                 fprintf(file, "%s", iCol->first.c_str());
 232
 233                 auto i = iCol;
 234                 i++;
 235                 if(i != end())
 236                 {
 237                         fprintf(file, "|");
 238                 }
 239         }
 240         fprintf(file, ">");
 241 }
 242
 243 /**
 244  * @brief Replace a `key` substring of a string `str` by a replacement `replace`
 245  * @param[in] str The string of which a copy with the replacements shall be
 246  * created
 247  * @param[in] key The string which shall be replaced
 248  * @param[in] replace The string that shall replace occurrences of `key`
 249  * @return A new string instance with the replacements conducted on it
 250  */
 251 static std::string replace_str(std::string str, std::string key, std::string replace)
 252 {
 253         std::string s5, s4;
 254         std::string match[] = { ".BZ2", ".ZST" };
 255         if (replace.size() > 4)
 256         {
 257                 if (replace[replace.size() - 1] == '\"')
 258                 {
 259                         s5 = str_to_upper(replace.substr(replace.size() - 5));
 260                         for (std::string it : match)
 261                         {
 262                                 if (s5 == it)
 263                                 {
 264                                         replace = replace.substr(0, replace.size() - 1);
 265                                         replace += "/*\"";
 266                                 }
 267                         }
 268
 269                 }
 270                 else
 271                 {
 272                         s4 = str_to_upper(replace.substr(replace.size() - 4));
 273                         for (std::string it : match)
 274                         {
 275                                 if (it == s4)
 276                                 {
 277                                         replace += "/*";
 278                                 }
 279                         }
 280                 }
 281         }
 282
 283         for (size_t j = 0; (j = str.find(key, j)) != std::string::npos;)
 284         {
 285                 if (j == 0 || (j!=0 && str[j - 1] == ' '))
 286                         str.replace(j, key.size(), replace);
 287                 j += key.size();
 288         }
 289         return str;
 290 }
 291
 292 /**
 293  * @brief Returns a copy of `str` with all applicable characters converted to
 294  * uppercase
 295  * @param[in] str The string for which an uppercase copy shall be created
 296  * @return The copy of `str` converted to uppercase
 297  */
 298 static std::string str_to_upper(const std::string &str)
 299 {
 300         const std::locale loc;
 301         std::string s;
 302         s.reserve(str.size());
 303
 304         for (size_t i = 0; i < str.size(); ++i)
 305         {
 306                 s.push_back(std::toupper(str[i], loc));
 307         }
 308
 309         return s;
 310 }
 311
 312 //! Array containing raw information about all the built-in scripts of uuu
 313 static constexpr BuiltInScriptRawData g_builtin_cmd[] =
 314 {
 315         {
 316                 "emmc",
 317 #include "emmc_burn_loader.clst"
 318                 ,"burn boot loader to eMMC boot partition"
 319         },
 320         {
 321                 "emmc_all",
 322 #include "emmc_burn_all.clst"
 323                 ,"burn whole image to eMMC"
 324         },
 325         {
 326                 "fat_write",
 327 #include "fat_write.clst"
 328                 ,"update one file in fat partition, require uboot fastboot running in board"
 329         },
 330         {
 331                 "nand",
 332 #include "nand_burn_loader.clst"
 333                 ,"burn boot loader to NAND flash"
 334         },
 335         {
 336                 "qspi",
 337 #include "qspi_burn_loader.clst"
 338                 ,"burn boot loader to qspi nor flash"
 339         },
 340         {
 341                 "spi_nand",
 342 #include "fspinand_burn_loader.clst"
 343                 ,"burn boot loader to spi nand flash"
 344         },
 345         {
 346                 "sd",
 347 #include "sd_burn_loader.clst"
 348                 ,"burn boot loader to sd card"
 349         },
 350         {
 351                 "sd_all",
 352 #include "sd_burn_all.clst"
 353                 ,"burn whole image to sd card"
 354         },
 355         {
 356                 "spl",
 357 #include "spl_boot.clst"
 358                 ,"boot spl and uboot"
 359         },
 360         {
 361                 "nvme_all",
 362 #include "nvme_burn_all.clst"
 363                 ,"burn whole image io nvme storage"
 364         },
 365         {
 366                 nullptr,
 367                 nullptr,
 368                 nullptr,
 369         }
 370 };
 371
 372 //! A map of the built-in scripts' names to their BuiltInScript representations
 373 BuiltInScriptMap g_BuildScripts(g_builtin_cmd);