src/support/js-embedded-module.cpp

/*
 * Copyright 2026 WebAssembly Community Group participants
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "support/js-embedded-module.h"

#include <cctype>
#include <cstdint>

namespace wasm {

namespace {

// Advances `pos` past a `//` single-line comment (leaving `pos` at the newline
// character or end of `js`). Assumes `js.substr(pos, 2) == "//"`.
void skipSingleLineComment(std::string_view js, size_t& pos) {
  pos += 2;
  while (pos < js.size() && js[pos] != '\n') {
    ++pos;
  }
}

// Advances `pos` past a `/* ... */` multi-line comment (or to the end of `js`
// if the comment is unterminated). Assumes `js.substr(pos, 2) == "/*"`.
void skipMultiLineComment(std::string_view js, size_t& pos) {
  pos += 2;
  while (pos + 1 < js.size() && !(js[pos] == '*' && js[pos + 1] == '/')) {
    ++pos;
  }
  if (pos + 1 < js.size()) {
    pos += 2;
  } else {
    pos = js.size();
  }
}

// Advances `pos` past any contiguous ASCII whitespace, single-line comments,
// and multi-line comments.
void skipWhitespaceAndComments(std::string_view js, size_t& pos) {
  while (pos < js.size()) {
    if (std::isspace(static_cast<unsigned char>(js[pos]))) {
      ++pos;
    } else if (pos + 1 < js.size() && js[pos] == '/' && js[pos + 1] == '/') {
      skipSingleLineComment(js, pos);
    } else if (pos + 1 < js.size() && js[pos] == '/' && js[pos + 1] == '*') {
      skipMultiLineComment(js, pos);
    } else {
      break;
    }
  }
}

// Parses a single integer literal representing an 8-bit byte at `pos` (in
// decimal, `0x` hex, `0o` octal, or `0b` binary, with optional `+`/`-` sign and
// `_` numeric separators). Accepts unsigned values in [0, 255] and signed
// negative values in [-128, -1]. On success, advances `pos` past the literal,
// writes the byte to `outByte`, and returns true.
bool parseByteLiteral(std::string_view js, size_t& pos, char& outByte) {
  if (pos >= js.size()) {
    return false;
  }

  bool negative = false;
  if (js[pos] == '-' || js[pos] == '+') {
    negative = (js[pos] == '-');
    ++pos;
    if (pos >= js.size()) {
      return false;
    }
  }

  int base = 10;
  if (js[pos] == '0' && pos + 1 < js.size()) {
    char next = js[pos + 1];
    if (next == 'x' || next == 'X') {
      base = 16;
      pos += 2;
    } else if (next == 'o' || next == 'O') {
      base = 8;
      pos += 2;
    } else if (next == 'b' || next == 'B') {
      base = 2;
      pos += 2;
    }
  }

  uint32_t value = 0;
  bool hasDigits = false;
  while (pos < js.size()) {
    char c = js[pos];
    if (c == '_') {
      ++pos;
      continue;
    }
    int digit = -1;
    if (c >= '0' && c <= '9') {
      digit = c - '0';
    } else if (c >= 'a' && c <= 'f') {
      digit = 10 + (c - 'a');
    } else if (c >= 'A' && c <= 'F') {
      digit = 10 + (c - 'A');
    } else {
      break;
    }
    if (digit >= base) {
      return false;
    }
    hasDigits = true;
    value = value * base + digit;
    if ((!negative && value > 255) || (negative && value > 128)) {
      return false;
    }
    ++pos;
  }

  if (!hasDigits) {
    return false;
  }

  // Ensure the literal is not immediately followed by an identifier character.
  if (pos < js.size() &&
      (std::isalnum(static_cast<unsigned char>(js[pos])) || js[pos] == '_')) {
    return false;
  }

  if (negative) {
    outByte = static_cast<char>(static_cast<uint8_t>(-static_cast<int>(value)));
  } else {
    outByte = static_cast<char>(static_cast<uint8_t>(value));
  }
  return true;
}

// Attempts to parse a JavaScript array literal starting at index `start`
// (`js[start] == '['`) as an embedded WebAssembly module. Rejects early if the
// first 4 elements do not match the `\0asm` magic bytes (`0x00, 0x61, 0x73,
// 0x6d`) or if any element is not a valid byte literal.
bool tryParseWasmByteArray(std::string_view js,
                           size_t start,
                           EmbeddedModule& outModule) {
  static constexpr uint8_t WasmMagic[4] = {0x00, 0x61, 0x73, 0x6d};

  size_t pos = start + 1;
  std::vector<char> bytes;

  while (true) {
    skipWhitespaceAndComments(js, pos);
    if (pos >= js.size()) {
      return false;
    }
    if (js[pos] == ']') {
      if (bytes.size() < 4) {
        return false;
      }
      outModule = EmbeddedModule{start, pos + 1, std::move(bytes)};
      return true;
    }

    char byteVal = 0;
    if (!parseByteLiteral(js, pos, byteVal)) {
      return false;
    }

    // Early rejection if the first 4 bytes do not match \0asm.
    if (bytes.size() < 4 &&
        static_cast<uint8_t>(byteVal) != WasmMagic[bytes.size()]) {
      return false;
    }

    bytes.push_back(byteVal);

    skipWhitespaceAndComments(js, pos);
    if (pos >= js.size()) {
      return false;
    }
    if (js[pos] == ',') {
      ++pos;
    } else if (js[pos] != ']') {
      return false;
    }
  }
}

} // namespace

std::vector<EmbeddedModule> findEmbeddedModules(std::string_view js) {
  std::vector<EmbeddedModule> modules;
  size_t pos = 0;

  while (pos < js.size()) {
    char c = js[pos];

    // Skip single-line and multi-line comments.
    if (c == '/' && pos + 1 < js.size()) {
      if (js[pos + 1] == '/') {
        skipSingleLineComment(js, pos);
        continue;
      }
      if (js[pos + 1] == '*') {
        skipMultiLineComment(js, pos);
        continue;
      }
    }

    // Skip string and template literals.
    if (c == '\'' || c == '"' || c == '`') {
      char quote = c;
      ++pos;
      while (pos < js.size()) {
        if (js[pos] == '\\') {
          pos += 2;
          continue;
        }
        if (js[pos] == quote) {
          ++pos;
          break;
        }
        if (quote != '`' && (js[pos] == '\n' || js[pos] == '\r')) {
          // Single- and double-quoted JS strings cannot span unescaped lines.
          ++pos;
          break;
        }
        ++pos;
      }
      continue;
    }

    if (c == '[') {
      EmbeddedModule mod;
      if (tryParseWasmByteArray(js, pos, mod)) {
        pos = mod.end;
        modules.push_back(std::move(mod));
        continue;
      }
    }

    ++pos;
  }

  return modules;
}

std::string formatByteArray(const std::vector<char>& bytes) {
  if (bytes.empty()) {
    return "[]";
  }

  static constexpr char HexDigits[] = "0123456789abcdef";
  std::string out = "[\n";
  // Each byte takes ~6 chars ("0x00, "), plus indentation and brackets.
  out.reserve(bytes.size() * 6 + (bytes.size() / 16 + 1) * 4 + 4);

  for (size_t i = 0; i < bytes.size(); ++i) {
    if (i % 16 == 0) {
      out += "  ";
    }
    uint8_t b = static_cast<uint8_t>(bytes[i]);
    out += "0x";
    out += HexDigits[b >> 4];
    out += HexDigits[b & 0x0f];
    if (i + 1 < bytes.size()) {
      if ((i + 1) % 16 == 0) {
        out += ",\n";
      } else {
        out += ", ";
      }
    } else {
      out += "\n]";
    }
  }

  return out;
}

} // namespace wasm