hscript: Convert 'int line' to a ScriptLocation object

1 files changed, 68 insertions, 108 deletions

diff --git a/hscript/network.cc b/hscript/network.cc
index 445ccbb..1e915b3 100644
--- a/hscript/network.cc
+++ b/hscript/network.cc
@@ -30,15 +30,14 @@
 using namespace Horizon::Keys;
 
 
-Key *Network::parseFromData(const std::string &data, int lineno, int *errors,
-                            int *, const Script *script) {
+Key *Network::parseFromData(const std::string &data, const ScriptLocation &pos,
+                            int *errors, int *, const Script *script) {
     bool value;
-    if(!BooleanKey::parse(data, "installfile:" + std::to_string(lineno),
-                          "network", &value)) {
+    if(!BooleanKey::parse(data, pos, "network", &value)) {
         if(errors) *errors += 1;
         return nullptr;
     }
-    return new Network(script, lineno, value);
+    return new Network(script, pos, value);
 }
 
 bool Network::execute() const {
@@ -47,7 +46,8 @@ bool Network::execute() const {
 }
 
 
-Key *NetConfigType::parseFromData(const std::string &data, int lineno,
+Key *NetConfigType::parseFromData(const std::string &data,
+                                  const ScriptLocation &pos,
                                   int *errors, int *, const Script *script) {
     std::string type = data;
     ConfigSystem system;
@@ -60,13 +60,12 @@ Key *NetConfigType::parseFromData(const std::string &data, int lineno,
         system = ENI;
     } else {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netconfigtype: invalid or missing config type",
+        output_error(pos, "netconfigtype: invalid or missing config type",
                      "one of 'netifrc', 'eni' required");
         return nullptr;
     }
 
-    return new NetConfigType(script, lineno, system);
+    return new NetConfigType(script, pos, system);
 }
 
 bool NetConfigType::validate() const {
@@ -80,8 +79,9 @@ bool NetConfigType::execute() const {
 }
 
 
-Key *NetAddress::parseFromData(const std::string &data, int lineno, int *errors,
-                               int *, const Script *script) {
+Key *NetAddress::parseFromData(const std::string &data,
+                               const ScriptLocation &pos, int *errors, int *,
+                               const Script *script) {
     long elements = std::count(data.cbegin(), data.cend(), ' ') + 1;
     std::string::size_type type_pos, addr_pos, prefix_pos, gw_pos, next_end;
     std::string iface, type, addr, prefix, gw;
@@ -90,8 +90,7 @@ Key *NetAddress::parseFromData(const std::string &data, int lineno, int *errors,
 
     if(elements < 2) {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netaddress: missing address type",
+        output_error(pos, "netaddress: missing address type",
                      "one of 'dhcp', 'slaac', 'static' required");
         return nullptr;
     }
@@ -100,8 +99,7 @@ Key *NetAddress::parseFromData(const std::string &data, int lineno, int *errors,
     iface = data.substr(0, type_pos);
     if(iface.length() > IFNAMSIZ) {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netaddress: interface name '" + iface + "' is invalid",
+        output_error(pos, "netaddress: invalid interface name '" + iface + "'",
                      "interface names must be 16 characters or less");
         return nullptr;
     }
@@ -117,27 +115,24 @@ Key *NetAddress::parseFromData(const std::string &data, int lineno, int *errors,
     if(!type.compare("dhcp")) {
         if(elements > 2) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "netaddress: address type 'dhcp' does not "
+            output_error(pos, "netaddress: address type 'dhcp' does not "
                          "accept further elements");
             return nullptr;
         }
-        return new NetAddress(script, lineno, iface, AddressType::DHCP, "", 0,
+        return new NetAddress(script, pos, iface, AddressType::DHCP, "", 0,
                               "");
     } else if(!type.compare("slaac")) {
         if(elements > 2) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "netaddress: address type 'slaac' does not "
+            output_error(pos, "netaddress: address type 'slaac' does not "
                          "accept further elements");
             return nullptr;
         }
-        return new NetAddress(script, lineno, iface, AddressType::SLAAC, "", 0,
+        return new NetAddress(script, pos, iface, AddressType::SLAAC, "", 0,
                               "");
     } else if(type.compare("static")) {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netaddress: invalid address type '" + type + "'",
+        output_error(pos, "netaddress: invalid address type '" + type + "'",
                      "one of 'dhcp', 'slaac', 'static' required");
         return nullptr;
     }
@@ -145,16 +140,14 @@ Key *NetAddress::parseFromData(const std::string &data, int lineno, int *errors,
     /* static address */
     if(elements < 4) {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netaddress: address type 'static' requires at least "
-                     "an IP address and prefix length");
+        output_error(pos, "netaddress: address type 'static' requires at "
+                     "least an IP address and prefix length");
         return nullptr;
     }
 
     if(elements > 5) {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netaddress: too many elements to address type 'static'");
+        output_error(pos, "netaddress: too many elements for static address");
         return nullptr;
     }
 
@@ -172,8 +165,7 @@ Key *NetAddress::parseFromData(const std::string &data, int lineno, int *errors,
         /* IPv6 */
         if(::inet_pton(AF_INET6, addr.c_str(), &addr_buf) != 1) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "netaddress: '" + addr + "' is not a valid IPv6 address",
+            output_error(pos, "netaddress: '" + addr + "' is not a valid IPv6 address",
                          "hint: a ':' was found, indicating this address is IPv6");
             return nullptr;
         }
@@ -182,16 +174,14 @@ Key *NetAddress::parseFromData(const std::string &data, int lineno, int *errors,
             real_prefix = std::stoi(prefix);
         } catch(const std::exception &) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "netaddress: prefix length is not a number",
+            output_error(pos, "netaddress: prefix length is not a number",
                          "prefix must be a decimal value between 1 and 128");
             return nullptr;
         }
 
         if(real_prefix < 1 || real_prefix > 128) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "netaddress: invalid IPv6 prefix length: " + prefix,
+            output_error(pos, "netaddress: invalid IPv6 prefix length: " + prefix,
                          "prefix must be a decimal value between 1 and 128");
             return nullptr;
         }
@@ -199,21 +189,19 @@ Key *NetAddress::parseFromData(const std::string &data, int lineno, int *errors,
         if(gw.size() > 0 &&
            ::inet_pton(AF_INET6, gw.c_str(), &addr_buf) != 1) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "netaddress: '" + gw +
+            output_error(pos, "netaddress: '" + gw +
                          "' is not a valid IPv6 gateway",
                          "an IPv6 address must have an IPv6 gateway");
             return nullptr;
         }
 
-        return new NetAddress(script, lineno, iface, AddressType::Static, addr,
+        return new NetAddress(script, pos, iface, AddressType::Static, addr,
                               static_cast<uint8_t>(real_prefix), gw);
     } else if(addr.find('.') != std::string::npos) {
         /* IPv4 */
         if(::inet_pton(AF_INET, addr.c_str(), &addr_buf) != 1) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "netaddress: '" + addr + "' is not a valid IPv4 address");
+            output_error(pos, "netaddress: invalid IPv4 address", addr);
             return nullptr;
         }
 
@@ -225,8 +213,7 @@ Key *NetAddress::parseFromData(const std::string &data, int lineno, int *errors,
                 real_prefix = std::stoi(prefix);
             } catch(const std::exception &) {
                 if(errors) *errors += 1;
-                output_error("installfile:" + std::to_string(lineno),
-                             "netaddress: can't parse prefix length/mask",
+                output_error(pos, "netaddress: can't parse prefix length/mask",
                              "a network mask or prefix length is required");
                 return nullptr;
             }
@@ -234,29 +221,26 @@ Key *NetAddress::parseFromData(const std::string &data, int lineno, int *errors,
 
         if(real_prefix < 1 || real_prefix > 32) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "netaddress: invalid IPv4 prefix length: " + prefix,
-                         "prefix must be between 1 and 32");
+            output_error(pos, "netaddress: invalid IPv4 prefix length: " +
+                         prefix, "prefix must be between 1 and 32");
             return nullptr;
         }
 
         if(gw.size() > 0 &&
            ::inet_pton(AF_INET, gw.c_str(), &addr_buf) != 1) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "netaddress: '" + gw +
+            output_error(pos, "netaddress: '" + gw +
                          "' is not a valid IPv4 gateway",
                          "an IPv4 address must have an IPv4 gateway");
             return nullptr;
         }
 
-        return new NetAddress(script, lineno, iface, AddressType::Static, addr,
+        return new NetAddress(script, pos, iface, AddressType::Static, addr,
                               static_cast<uint8_t>(real_prefix), gw);
     } else {
         /* IPvBad */
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netaddress: invalid address of unknown type",
+        output_error(pos, "netaddress: invalid address of unknown type",
                      "an IPv4 or IPv6 address is required");
         return nullptr;
     }
@@ -272,8 +256,7 @@ bool NetAddress::validate() const {
     struct ifreq request;
     int my_sock = ::socket(AF_INET, SOCK_STREAM, 0);
     if(my_sock == -1) {
-        output_error("installfile:" + std::to_string(this->lineno()),
-                     "netaddress: can't open socket", ::strerror(errno));
+        output_error(pos, "netaddress: can't open socket", ::strerror(errno));
         return false;
     }
     memset(&request, 0, sizeof(request));
@@ -281,12 +264,10 @@ bool NetAddress::validate() const {
     errno = 0;
     if(ioctl(my_sock, SIOCGIFFLAGS, &request) == -1) {
         if(errno == ENODEV) {
-            output_warning("installfile:" + std::to_string(this->lineno()),
-                           "netaddress: specified interface does not exist");
+            output_warning(pos, "netaddress: interface does not exist", _iface);
             return true;
         }
-        output_error("installfile:" + std::to_string(this->lineno()),
-                     "netaddress: trouble communicating with interface",
+        output_error(pos, "netaddress: trouble communicating with interface",
                      ::strerror(errno));
         return false;
     }
@@ -298,9 +279,8 @@ bool execute_address_netifrc(const NetAddress *addr) {
     std::ofstream config("/tmp/horizon/netifrc/config_" + addr->iface(),
                          std::ios_base::app);
     if(!config) {
-        output_error("installfile:" + std::to_string(addr->lineno()),
-                     "netaddress: couldn't write network configuration for "
-                     + addr->iface());
+        output_error(addr->where(), "netaddress: couldn't write network "
+                     "configuration for " + addr->iface());
         return false;
     }
 
@@ -321,9 +301,8 @@ bool execute_address_netifrc(const NetAddress *addr) {
         std::ofstream route("/tmp/horizon/netifrc/routes_" + addr->iface(),
                             std::ios_base::app);
         if(!route) {
-            output_error("installfile:" + std::to_string(addr->lineno()),
-                         "netaddress: couldn't write route configuration for "
-                         + addr->iface());
+            output_error(addr->where(), "netaddress: couldn't write route "
+                         "configuration for " + addr->iface());
             return false;
         }
         route << "default via " << addr->gateway() << std::endl;
@@ -336,9 +315,8 @@ bool execute_address_eni(const NetAddress *addr) {
     std::ofstream config("/tmp/horizon/eni/" + addr->iface(),
                          std::ios_base::app);
     if(!config) {
-        output_error("installfile:" + std::to_string(addr->lineno()),
-                     "netaddress: couldn't write network configuration for "
-                     + addr->iface());
+        output_error(addr->where(), "netaddress: couldn't write network "
+                     "configuration for " + addr->iface());
         return false;
     }
 
@@ -375,8 +353,7 @@ bool execute_address_eni(const NetAddress *addr) {
 }
 
 bool NetAddress::execute() const {
-    output_info("installfile:" + std::to_string(this->lineno()),
-                "netaddress: adding configuration for " + _iface);
+    output_info(pos, "netaddress: adding configuration for " + _iface);
 
     NetConfigType::ConfigSystem system = NetConfigType::Netifrc;
 
@@ -396,18 +373,17 @@ bool NetAddress::execute() const {
 }
 
 
-Key *Nameserver::parseFromData(const std::string &data, int lineno,
-                               int *errors, int *, const Script *script) {
+Key *Nameserver::parseFromData(const std::string &data,
+                               const ScriptLocation &pos, int *errors, int *,
+                               const Script *script) {
     char addr_buf[16];
     static const std::string valid_chars("1234567890ABCDEFabcdef:.");
 
     if(data.find_first_not_of(valid_chars) != std::string::npos) {
         if(errors) *errors += 0;
-        output_error("installfile:" + std::to_string(lineno),
-                     "nameserver: expected an IP address");
+        output_error(pos, "nameserver: expected an IP address");
         if(data.find_first_of("[]") != std::string::npos) {
-            output_info("installfile:" + std::to_string(lineno),
-                        "nameserver: hint: you don't have to enclose IPv6 "
+            output_info(pos, "nameserver: hint: you don't have to enclose IPv6 "
                         "addresses in [] brackets");
         }
         return nullptr;
@@ -417,8 +393,7 @@ Key *Nameserver::parseFromData(const std::string &data, int lineno,
         /* IPv6 */
         if(::inet_pton(AF_INET6, data.c_str(), &addr_buf) != 1) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "nameserver: '" + data + "' is not a valid IPv6 "
+            output_error(pos, "nameserver: '" + data + "' is not a valid IPv6 "
                          "address", "hint: a ':' was found, so an IPv6 "
                          "address was expected");
             return nullptr;
@@ -427,14 +402,13 @@ Key *Nameserver::parseFromData(const std::string &data, int lineno,
         /* IPv4 */
         if(::inet_pton(AF_INET, data.c_str(), &addr_buf) != 1) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "nameserver: '" + data + "' is not a valid IPv4 "
+            output_error(pos, "nameserver: '" + data + "' is not a valid IPv4 "
                          "address");
             return nullptr;
         }
     }
 
-    return new Nameserver(script, lineno, data);
+    return new Nameserver(script, pos, data);
 }
 
 bool Nameserver::execute() const {
@@ -449,8 +423,7 @@ bool Nameserver::execute() const {
     std::ofstream resolvconf(script->targetDirectory() + "/etc/resolv.conf",
                              std::ios_base::app);
     if(!resolvconf) {
-        output_error("installfile:" + std::to_string(line),
-                     "nameserver: couldn't write configuration to target");
+        output_error(pos, "nameserver: couldn't write configuration to target");
         return false;
     }
     resolvconf << "nameserver " << _value << std::endl;
@@ -459,8 +432,8 @@ bool Nameserver::execute() const {
 }
 
 
-Key *NetSSID::parseFromData(const std::string &data, int lineno, int *errors,
-                            int *, const Script *script) {
+Key *NetSSID::parseFromData(const std::string &data, const ScriptLocation &p,
+                            int *errors, int *, const Script *script) {
     std::string iface, ssid, secstr, passphrase;
     SecurityType type;
     std::string::size_type start, pos, next;
@@ -472,32 +445,28 @@ Key *NetSSID::parseFromData(const std::string &data, int lineno, int *errors,
     if(start == std::string::npos) {
         /* ok this is just ridiculous then */
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netssid: at least three elements expected");
+        output_error(p, "netssid: at least three elements expected");
         return nullptr;
     }
 
     iface = data.substr(0, start);
     if(iface.length() > IFNAMSIZ) {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netssid: interface name '" + iface + "' is invalid",
+        output_error(p, "netssid: interface name '" + iface + "' is invalid",
                      "interface names must be 16 characters or less");
         return nullptr;
     }
 
     if(data[start + 1] != '"') {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netssid: malformed SSID", "SSIDs must be quoted");
+        output_error(p, "netssid: malformed SSID", "SSIDs must be quoted");
         return nullptr;
     }
 
     pos = data.find_first_of('"', start + 2);
     if(pos == std::string::npos) {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netssid: unterminated SSID");
+        output_error(p, "netssid: unterminated SSID");
         return nullptr;
     }
 
@@ -505,8 +474,7 @@ Key *NetSSID::parseFromData(const std::string &data, int lineno, int *errors,
 
     if(data.length() < pos + 5) {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netssid: security type expected");
+        output_error(p, "netssid: security type expected");
         return nullptr;
     }
     start = data.find_first_of(' ', pos + 1);
@@ -524,8 +492,7 @@ Key *NetSSID::parseFromData(const std::string &data, int lineno, int *errors,
         type = SecurityType::WPA;
     } else {
         if(errors) *errors += 1;
-        output_error("installfile:" + std::to_string(lineno),
-                     "netssid: unknown security type '" + secstr + "'",
+        output_error(p, "netssid: unknown security type '" + secstr + "'",
                      "expected one of 'none', 'wep', or 'wpa'");
         return nullptr;
     }
@@ -533,14 +500,13 @@ Key *NetSSID::parseFromData(const std::string &data, int lineno, int *errors,
     if(type != SecurityType::None) {
         if(pos == std::string::npos || data.length() < pos + 2) {
             if(errors) *errors += 1;
-            output_error("installfile:" + std::to_string(lineno),
-                         "netssid: expected passphrase for security type '" +
+            output_error(p, "netssid: expected passphrase for security type '" +
                          secstr + "'");
             return nullptr;
         }
         passphrase = data.substr(pos + 1);
     }
-    return new NetSSID(script, lineno, iface, ssid, type, passphrase);
+    return new NetSSID(script, p, iface, ssid, type, passphrase);
 }
 
 bool NetSSID::validate() const {
@@ -553,8 +519,7 @@ bool NetSSID::validate() const {
     struct iwreq request;
     int my_sock = ::socket(AF_INET, SOCK_STREAM, 0);
     if(my_sock == -1) {
-        output_error("installfile:" + std::to_string(this->lineno()),
-                     "netssid: can't open socket", ::strerror(errno));
+        output_error(pos, "netssid: can't open socket", ::strerror(errno));
         return false;
     }
     memset(&request, 0, sizeof(request));
@@ -565,16 +530,13 @@ bool NetSSID::validate() const {
         switch(errno)
         {
         case EOPNOTSUPP:
-            output_warning("installfile:" + std::to_string(this->lineno()),
-                           "netssid: specified interface is not wireless");
+            output_warning(pos, "netssid: specified interface is not wireless");
             return true;
         case ENODEV:
-            output_warning("installfile:" + std::to_string(this->lineno()),
-                           "netssid: specified interface does not exist");
+            output_warning(pos, "netssid: specified interface does not exist");
             return true;
         default:
-            output_error("installfile:" + std::to_string(this->lineno()),
-                         "netssid: error communicating with wireless device");
+            output_error(pos, "netssid: error communicating with device");
             return false;
         }
     }
@@ -586,14 +548,12 @@ bool NetSSID::validate() const {
 }
 
 bool NetSSID::execute() const {
-    output_info("installfile:" + std::to_string(this->lineno()),
-                "netssid: configuring SSID " + _ssid);
+    output_info(pos, "netssid: configuring SSID " + _ssid);
 
     std::ofstream conf("/tmp/horizon/wpa_supplicant.conf",
                        std::ios_base::app);
     if(!conf) {
-        output_error("installfile:" + std::to_string(this->lineno()),
-                     "netssid: failed to write configuration");
+        output_error(pos, "netssid: failed to write configuration");
         return false;
     }