Example #1
0
/// Read data and add terminating 0
void fsutil::read_file_data_ex(const char *filename, std::string& data, size_t align)
{
    // Open stream
    std::ifstream stream(filename, std::ios::binary);
    if (!stream)
        throw std::runtime_error(std::string("cannot open file ") + filename);
    stream.unsetf(std::ios::skipws);

    // Determine stream size
    stream.seekg(0, std::ios::end);
    size_t size = stream.tellg();
    stream.seekg(0);   

    // Calc Padding size
    size_t padding_size = 0;
    if(align > 0)
        padding_size = align - size % align;

    // Load data
    data.resize(size + padding_size + 1);
    stream.read(&data.front(), static_cast<std::streamsize>(size));

    // Padding data
    for(size_t offst = 0; offst < padding_size; ++offst) 
    {
        *(&data.front() + size + offst) = padding_size;
    }

    //  And add terminating
    data[size] = 0;
}
Example #2
0
long long toNum(std::string str, int type = 0)
{
	int len = str.length();
	long long ret = 0;
	if (len < 1)
		return 0;
	if (canBeNum(str) == false)
		return 0;
	std::stringstream ss;
	bool negative = false;
	if (str.front() == '-')
	{
		str.erase(0, 1);
		negative = true;
		len--;
	}
	else if (str.front() == '+')
	{
		str.erase(0, 1);
		len--;
	}
	switch (type)
	{
		case 0:
			if (len == 0)
				return 0;
			if (str.back() == 'h' || str.back() == 'H')
			{
				str.erase(len - 1, 1);
				ss << std::hex << str;
				ss >> ret;
			}
			else if (str.front() == '0' && len > 1)
Example #3
0
        std::string zusiPfadZuOsPfad(const std::string& zusiPfad, const std::string& osPfadUebergeordnet) {
            std::string result;
            if (zusiPfad.find('\\') == zusiPfad.npos && !osPfadUebergeordnet.empty()) {
                // Relativ zu uebergeordnetem Pfad
                if (zusiPfad.empty()) {
                    return osPfadUebergeordnet;
                }
                result = osPfadUebergeordnet.substr(0, osPfadUebergeordnet.rfind('/'));
            } else {
                // Relativ zum Zusi-Datenverzeichnis
                result = getZusi3Datenpfad();
                if (result.empty()) {
                    return "";
                }
            }

            if (result.back() == '\\' && zusiPfad.front() == '\\') {
                result.pop_back();
            } else if (result.back() != '\\' && zusiPfad.front() != '\\') {
                result.push_back('\\');
            }

            result += zusiPfad;
            return result;
        }
Example #4
0
void ler_comando(std::string c, ABB &arv) {
	std::string aux;
	int x;
	while (!c.empty()){
		if(c.front() == ' ') {
        	c.erase(0,1);
        	break;
        }
        else{
            aux = aux + c.front();
            c.erase(0,1);
        }
    }

    if (!c.empty()) {
    	x = std::stoi (c, nullptr, 10);
    }

    if (aux == "ENESIMO") {
    	std::cout << "O elemento na " << x << "ª posicao eh o: " << arv.enesimoElemento(x) << std::endl;
    }

    else if (aux == "POSICAO") {
    	std::cout << "O elemento " << x << " esta na " << arv.posicao(x) << "ª posicao" << std::endl;
    }


    else if (aux == "MEDIANA") {
    	std::cout << "A mediana da ABB eh o elemento: " << arv.mediana() << std::endl;
    }

    else if (aux == "CHEIA") {
    	if (arv.ehCheia()) {
    		std::cout << "A ABB eh cheia!" << std::endl;
    	}
    	
    	else
    		std::cout << "A ABB Nao eh cheia! " << std::endl;
    }

    else if (aux == "COMPLETA") {
    	if (arv.ehCompleta()) {
			std::cout << "A ABB eh completa!" << std::endl;
    	}

    	else 
    		std::cout << "A ABB nao eh completa!" << std::endl;
    }

    else if (aux == "IMPRIMA") {
    	std::cout << "Imprimindo ABB por nivel: " << arv.toString() << std::endl;
    }

    else if (aux == "REMOVA") {
    	std::cout << "Removendo o elemento: " << x << " ..." << std::endl;
    	arv.remocao(x);
    }

}
/// Test if a name (parameter's or attribute's) belongs to m_source
/// @param aName :: A name to test.
bool FunctionGenerator::isSourceName(const std::string &aName) const {
    if (aName.empty()) {
        throw std::invalid_argument(
            "Parameter or attribute name cannot be empty string.");
    }
    return (aName.front() != 'f' || aName.find('.') == std::string::npos);
}
URL::URL(const std::string& str)
    : query([&]() -> Segment {
          const auto hashPos = str.find('#');
          const auto queryPos = str.find('?');
          if (queryPos == std::string::npos || hashPos < queryPos) {
              return { hashPos != std::string::npos ? hashPos : str.size(), 0 };
          }
          return { queryPos, (hashPos != std::string::npos ? hashPos : str.size()) - queryPos };
      }()),
      scheme([&]() -> Segment {
          if (str.empty() || !isAlphaCharacter(str.front())) return { 0, 0 };
          size_t schemeEnd = 0;
          while (schemeEnd < query.first && isSchemeCharacter(str[schemeEnd])) ++schemeEnd;
          return { 0, str[schemeEnd] == ':' ? schemeEnd : 0 };
      }()),
      domain([&]() -> Segment {
          auto domainPos = scheme.first + scheme.second;
          while (domainPos < query.first && (str[domainPos] == ':' || str[domainPos] == '/')) {
              ++domainPos;
          }
          const bool isData = str.compare(scheme.first, scheme.second, "data") == 0;
          const auto endPos = str.find(isData ? ',' : '/', domainPos);
          return { domainPos, std::min(query.first, endPos) - domainPos };
      }()),
      path([&]() -> Segment {
          auto pathPos = domain.first + domain.second;
          const bool isData = str.compare(scheme.first, scheme.second, "data") == 0;
          if (isData) {
              // Skip comma
              pathPos++;
          }
          return { pathPos, query.first - pathPos };
      }()) {
}
EdifyTokenString::EdifyTokenString(std::string str, Type type)
    : EdifyToken(EdifyTokenType::String), m_type(type)
{
    switch (type) {
    case AlreadyQuoted:
        m_quoted = true;
        assert(str.size() >= 2);
        assert(str.front() == '"');
        assert(str.back() == '"');
        m_str = std::move(str);
        break;
    case NotQuoted:
        m_quoted = false;
        m_str = std::move(str);
        break;
    case MakeQuoted:
        m_quoted = true;
        std::string temp;
        escape(str, &temp);
        temp.insert(temp.begin(), '"');
        temp.push_back('"');
        m_str = std::move(str);
        break;
    }
}
 int countWays(std::string s) {
   if (s=="") return 1;
   if (memo.count(s)) return memo[s];
   
   assert(s.front()=='(');
   int N=SZ(s), res=0, d=0;
   REP(i,N) {
     if (s[i]=='(') {
       ++d; continue;
     }
     
     --d;
     string t;
     if (i==N-1) {
       t = s.substr(1,i-1);
     } else {
       t = s.substr(1,i-1) + s.substr(min(N-1,i+1));
     }
     
     res += countWays(t);
     
     if (d==0) break;
   }
   
   return memo[s] = res;
 }
Example #9
0
static std::string repeat(std::string str, size_t n)
{
	if(n == 0)
	{
		str.clear();
		str.shrink_to_fit();
		return str;
	}
	else if(n == 1 || str.empty())
	{
		return str;
	}

	auto period = str.size();
	if(period == 1)
	{
		str.append(n - 1, str.front());
		return str;
	}

	str.reserve(period * n);
	size_t m = 2;
	for(; m < n; m *= 2)
		str += str;

	str.append(str.c_str(), (n - (m / 2)) * period);

	return str;
}
Example #10
0
Pothos::BlockRegistry::BlockRegistry(const std::string &path, const Callable &factory)
{
    //check the path
    if (path.empty() or path.front() != '/')
    {
        poco_error_f1(Poco::Logger::get("Pothos.BlockRegistry"), "Invalid path: %s", path);
        return;
    }

    //parse the path
    PluginPath fullPath;
    try
    {
        fullPath = PluginPath("/blocks").join(path.substr(1));
    }
    catch (const PluginPathError &)
    {
        poco_error_f1(Poco::Logger::get("Pothos.BlockRegistry"), "Invalid path: %s", path);
        return;
    }

    //check the factory
    if (factory.type(-1) == typeid(Block*) or factory.type(-1) == typeid(Topology*))
    {
        //register
        PluginRegistry::add(fullPath, factory);
    }

    //otherwise report the error
    else
    {
        poco_error_f1(Poco::Logger::get("Pothos.BlockRegistry"), "Bad Factory, must return Block* or Topology*: %s", factory.toString());
    }
}
Example #11
0
 void ReadAttribute(char c)
 {
     if (buffer.empty())
     {
         if (!IsWhitespace(c))
         {
             if (c == '"' || c == '\'')
                 Store(c);
             else
             {
                 state = State::SkipTag;
             }
         }
     }
     else if (c == buffer.front())
     {
         StoreLink();
         ClearBuffer();
         state = State::SkipTag;
     }
     else
     {
         Store(c);
     }
 }
Example #12
0
std::string getOutputString(std::string numberString) {
	std::string lineString { };

	if (numberString.size() && numberString.front() == '-')
		numberString.front() = digitOffset + 10;

	addSpace(numberString);

	for (unsigned int i = 0; i < allDigits[0].size(); i++) {
		for (char c : numberString) {
			lineString += allDigits[c - digitOffset][i] + " ";
		}
		lineString += "\n";
	}
	return lineString;
}
Example #13
0
bool SaveToFile(const std::string& data, const std::wstring& path,
                bool take_backup) {
  if (data.empty())
    return false;

  return SaveToFile((LPCVOID)&data.front(), data.size(), path, take_backup);
}
Example #14
0
File: HDD.cpp Project: ss23/rpcs3
void vfsHDD::ReadEntry(u64 block, std::string& name)
{
	CHECK_ASSERTION(m_hdd_file.Seek(block * m_hdd_info.block_size + sizeof(vfsHDD_Entry)) != -1);
	
	name.resize(GetMaxNameLen());
	m_hdd_file.Read(&name.front(), GetMaxNameLen());
}
 void readInternal(std::string& value)
 {
     size_t size;
     visit(size);
     value.resize(size);
     mStore.read(&value.front(), size);
 }
Example #16
0
 irc_message_struct irc_message(std::string message)
 {
     if(!message.empty())
     {
         irc_message_struct message_struct;

         auto space_pos = message.find(' ',0);

         if(message.front() == ':')
         {
             message_struct.prefix = message.substr(0, space_pos);
             message.erase(0,space_pos+1);
         }

         space_pos = message.find(' ',0);
         message_struct.command = message.substr(0, space_pos);
         message.erase(0,space_pos+1);

         message_struct.parameters = message;

         return message_struct;
     }

     return irc_message_struct();
 }
Example #17
0
void vfsHDD::ReadEntry(u64 block, vfsHDD_Entry& data, std::string& name)
{
	m_hdd_file.Seek(block * m_hdd_info.block_size);
	m_hdd_file.Read(&data, sizeof(vfsHDD_Entry));
	name.resize(GetMaxNameLen());
	m_hdd_file.Read(&name.front(), GetMaxNameLen());
}
Example #18
0
	bool fortifiedString(const std::string & s)
	{
		if (isDigit(s))
			return true ;
		linbox_check(!s.empty());
		return s.front() == '\"' && s.back() ==  '\"' ;
	}
Example #19
0
void snap::Excerpt::highlight_word(std::string w) {
  if (w.size() == 0 || w == "*" || w == "**") { return; }
  bool pre_wild_card = false; bool post_wild_card = false;
  if (w.front() == '*') { pre_wild_card = true; }
  if (w.back() == '*') { post_wild_card = true; }
  this -> search_strings.push_back(w);
  std::string w_trimmed = boost::algorithm::trim_copy_if(w, boost::algorithm::is_any_of("*"));
  std::transform(w_trimmed.begin(), w_trimmed.end(), w_trimmed.begin(), ::tolower);
  std::string lower_text(text);
  std::transform(lower_text.begin(), lower_text.end(), lower_text.begin(), ::tolower);
  int offset = 0; int left_shift = 24; int right_shift = 7;
  int current_pos = 0;
  while ((current_pos = lower_text.find(w_trimmed, current_pos)) != -1) {
    bool highlight = true;
    if (current_pos != 0 && !pre_wild_card && !(isspace(lower_text[current_pos-1]) || ispunct(lower_text[current_pos-1]))) {
      highlight = false;
    }
    if (current_pos + w_trimmed.length() != lower_text.length() && 
        !post_wild_card && 
        !(isspace(lower_text[current_pos + w_trimmed.length()]) || ispunct(lower_text[current_pos + w_trimmed.length()]))) {
      highlight = false;
    }
    if (highlight) {
      (this -> text).insert(current_pos + offset, "<span style=\"color:red\">");
      offset += left_shift;
      (this -> text).insert(current_pos + w_trimmed.length() + offset, "</span>");
      offset += right_shift;
    }
    current_pos += w_trimmed.size();
  }
}
Example #20
0
// output string to console
bool cmd_easteregg(BATB& batb, const std::string& input)
{
    // ('input' is the whole command line typed)
  
    // if correct command typed, do easter egg
    // easter egg is PS1|reverse(PS1)
    

    if ( input.empty() )         return false;
    if ( input.front() != '|' )  return false;
    auto right = input.substr( 1 );
    std::reverse( std::begin( right ), std::end( right ) );
    for (auto i = std::begin( right ); i != std::end( right ); ++i)
    {
        if ( *i == '<' ) { *i = '>'; continue; }
        if ( *i == '>' ) { *i = '<'; continue; }
        if ( *i == '(' ) { *i = ')'; continue; }
        if ( *i == ')' ) { *i = '('; continue; }
        if ( *i == '[' ) { *i = ']'; continue; }
        if ( *i == ']' ) { *i = '['; continue; }
        if ( *i == '{' ) { *i = '}'; continue; }
        if ( *i == '}' ) { *i = '{'; continue; }
    }

    auto left   = batb.run.console.getPS1();
    
    if ( left == right )
    {
        demo::al::demo_play( batb, file::static_data( "easteregg.mp3" ) );

        return true;
    }
    return false;
    
}
Example #21
0
 bool check()
 {
     CHECK(value.size() == 300);
     CHECK(value.front() == 'b' && value.back() == 'b');
     CHECK(i_wanna_be_big[0] == 'k' && i_wanna_be_big[50] == 'k');
     return true;
 }
Example #22
0
std::string LLVMSymbolizer::DemangleName(const std::string &Name,
                                         const SymbolizableModule *ModInfo) {
#if !defined(_MSC_VER)
  // We can spoil names of symbols with C linkage, so use an heuristic
  // approach to check if the name should be demangled.
  if (Name.substr(0, 2) == "_Z") {
    int status = 0;
    char *DemangledName = __cxa_demangle(Name.c_str(), nullptr, nullptr, &status);
    if (status != 0)
      return Name;
    std::string Result = DemangledName;
    free(DemangledName);
    return Result;
  }
#else
  if (!Name.empty() && Name.front() == '?') {
    // Only do MSVC C++ demangling on symbols starting with '?'.
    char DemangledName[1024] = {0};
    DWORD result = ::UnDecorateSymbolName(
        Name.c_str(), DemangledName, 1023,
        UNDNAME_NO_ACCESS_SPECIFIERS |       // Strip public, private, protected
            UNDNAME_NO_ALLOCATION_LANGUAGE | // Strip __thiscall, __stdcall, etc
            UNDNAME_NO_THROW_SIGNATURES |    // Strip throw() specifications
            UNDNAME_NO_MEMBER_TYPE | // Strip virtual, static, etc specifiers
            UNDNAME_NO_MS_KEYWORDS | // Strip all MS extension keywords
            UNDNAME_NO_FUNCTION_RETURNS); // Strip function return types
    return (result == 0) ? Name : std::string(DemangledName);
  }
#endif
  if (ModInfo && ModInfo->isWin32Module())
    return std::string(demanglePE32ExternCFunc(Name));
  return Name;
}
std::unique_ptr<CAS::AbstractArithmetic> BASICARITHSHARED_EXPORT Number_jmodule(const std::string &candidate)
{
    if (candidate.size() != 1 && candidate.front() == '0') return nullptr;
    else {
        if (candidate.find_first_not_of("0123456789") != std::string::npos) return nullptr;
        else return make_unique<CAS::NumberArith>(CAS::Natural(candidate));
    }
}
Example #24
0
	Variable getVarOrObjectProperty(const Game& game, const std::string& str)
	{
		if ((str.size() > 2) && (str.front() == '|') && (str.back() == '|'))
		{
			return GameUtils::getProperty(game, str.substr(1, str.size() - 2));
		}
		return Variable(str);
	}
//remove outer quotes if they exist
static std::string unquote(const std::string &s)
{
    if (s.size() > 2 and s.front() == '"' and s.back() == '"')
    {
        return s.substr(1, s.length()-2);
    }
    else return s;
}
Example #26
0
static bench::test_class_collection get_tests_by_name(const bench::test_class_collection & tests,
                                                      const std::string & name)
{
    // All tests chosen.
    if (name == "*") return tests;

    bench::test_class_collection chosen_tests;
    if (!name.empty())
    {
        for (auto test : tests)
        {
            bool chosen = false;
            if (test->name == name)
            {
                chosen = true;
            }
            else if ((name.front() == '*') && (name.back() == '*'))
            {
                assert(name.size() >= 2);
                auto name_part = name.substr(1, name.size() - 2);
                if (test->name.find(name_part) != std::string::npos) chosen = true;
            }
            else if (name.front() == '*')
            {
                auto name_part = name.substr(1);
                if (test->name.size() >= name_part.size())
                {
                    auto test_name_part = test->name.substr(test->name.size() - name_part.size());
                    if (name_part == test_name_part) chosen = true;
                }
            }
            else if (name.back() == '*')
            {
                auto name_part = name.substr(0, name.size() - 1);
                auto test_name_part = test->name.substr(0, name.size() - 1);
                if (name_part == test_name_part) chosen = true;
            }

            if (chosen) chosen_tests.push_back(test);
        }
    }

    if (chosen_tests.empty()) throw std::runtime_error("Invalid test name: " + name);
    return chosen_tests;
}
inline std::string changeFileExtension(const std::string &file_path, const std::string &new_ext)
{
	assert(!(new_ext.empty() || new_ext.front() == '.'));
	return file_path + '.' + new_ext;
	//size_t slash_pos = file_path.find_last_of("/\\");
	//return file_path.substr(0, std::min(
	//		file_path.length(),	file_path.find_last_of('.', slash_pos == std::string::npos ? 0 : slash_pos)
	//	)) + '.' + new_ext;
}
Example #28
0
void MainController::onCharactersEntered(std::string chars)
{
	int upCase = ::toupper(static_cast<int>(chars.front() & 0xffffffff));

	if (upCase == 'O')
		_sample.toggleObserving();

	if (upCase == 'W')
		_sample.toggleWireframe();
}
std::string SancusModuleCreator::fixSymbolName(const std::string& name)
{
    assert(!name.empty() && "Empty symbol name?");

    // remove the \01 prefix that is used to mangle __asm declarations
    if (name.front() == '\01')
        return name.substr(1);
    else
        return name;
}
Example #30
0
std::shared_ptr<fs::device_base> fs::get_virtual_device(const std::string& path)
{
	// Every virtual device path must have "//" at the beginning
	if (path.size() > 2 && reinterpret_cast<const u16&>(path.front()) == "//"_u16)
	{
		return get_device_manager().get_device(path);
	}

	return nullptr;
}