Example #1
0
	void Parser_XML::number_list(std::string& chaine, std::string& number)
	{
		const char current_token = read_current_token(chaine);
	
		if(ASCII_NUM(current_token)) {
			destroy_current_token(chaine, current_token);
			number.push_back(current_token);

			number_list(chaine, number);
		} else if(current_token == '<') {
		} else if(current_token == '.') {
			destroy_current_token(chaine, current_token);
			number.push_back(current_token);

			number_float(chaine, number);
		} else {
			std::cerr << "Error when reading a number." << std::endl;
		}
	}
bool HashMap::set( const std::string& key, const std::string& value)
{
	uint32_t id = m_symtab.getOrCreate( key);
	if (!m_symtab.isNew()) throw strus::runtime_error(_TXT("duplicate definition of symbol '%s'"), key.c_str());
	if (id != m_value_refs.size()+1) throw std::runtime_error( _TXT("internal: inconsistency in data"));
	m_value_strings.push_back('\0');
	m_value_refs.push_back( m_value_strings.size());
	m_value_strings.append( value);
	return true;
}
 void readString(std::string& utf8)
 {
   uint32_t i = readUInt32BE();
   utf8.clear();
   utf8.reserve(i);
   while (i--) {
     utf8.push_back(readUInt8BE());
   }
   align(4);
 }
Example #4
0
    void setResourcePath(const std::string& path)
    {
        TGUI_ResourcePath = path;

        if (!TGUI_ResourcePath.empty())
        {
            if (TGUI_ResourcePath[TGUI_ResourcePath.length()-1] != '/')
                TGUI_ResourcePath.push_back('/');
        }
    }
Example #5
0
		CgroupManager() {
			std::mt19937 rd{std::random_device{}()};
			std::uniform_int_distribution<int> dist{0, 61};

			groupName.reserve(31);
			groupName.push_back('/');
			for(int i = 0; i < 30; ++ i) {
				int r = dist(rd);

				// Only ASCII and UTF-8 Support
				if(r < 26) {
					groupName.push_back('a' + r);
				}else if(r < 52) {
					groupName.push_back('A' + r - 26);
				}else {
					groupName.push_back('0' + r - 52);
				}
			}
		}
Example #6
0
 inline void clear() {
     St.clear();
     s.clear();
     last=1;
     n=0;
     St.push_back(0);
     St.push_back(-1);
     St[0].sufflink=1;
     s.push_back(-1);
 }
static inline void getGifMask(std::string &mask, const std::string &front)
{
    mask = front;
    //Make mask filename
    size_t dotPos = mask.find_last_of('.');
    if(dotPos == std::string::npos)
        mask.push_back('m');
    else
        mask.insert(mask.begin() + dotPos, 'm');
}
Example #8
0
	void serialize(std::string& out) const
	{
		if (Action == ACT_BAN)
			out.push_back('*');
		else if (Action == ACT_BLOCK)
			out.push_back('~');

		out.append(ConvToStr(Lines)).push_back(':');
		out.append(ConvToStr(Seconds));
		if (Diff)
		{
			out.push_back(':');
			out.append(ConvToStr(Diff));
			if (Backlog)
			{
				out.push_back(':');
				out.append(ConvToStr(Backlog));
			}
		}
	}
Example #9
0
void WideStrToUTF8(std::string& dest, wstring& src)
{
	wchar_t w;
	
	dest.clear();
    
	for (size_t i = 0; i < src.size(); i++)
	{
		w = src[i];
        
		if (w <= 0x7f)
		{
			dest.push_back((char)w);
		}
		else if (w <= 0x7ff)
		{
			dest.push_back(0xc0 | ((w >> 6)& 0x1f));
			dest.push_back(0x80| (w & 0x3f));
		}
		else if (w <= 0xffff)
Example #10
0
/* all words with prefix recursive helper method */
void Trie::awwhelper(std::string word, Node* cur, std::vector<std::string>* wl){
    for(int i=0; i<26; i++){
        if(cur->galpha()[i]){
            word.push_back((char)(i + 97)); 
            if(cur->galpha()[i]->isend())
                wl->push_back(word);
            this->awwhelper(word, cur->galpha()[i], wl);
            word.pop_back(); 
        }
    }
}
Example #11
0
void StdinReader::operator()()
{
    while(std::cin)
    {
        char c;
        std::cin.get(c);

        std::lock_guard<std::mutex> lock(m_mutex);
        if(std::cin) m_data.push_back(c);
    }
}
Example #12
0
File: multv.cpp Project: blandw/cpm
 // Finds all occurrences of a circular pattern.
 std::set<int> Multv::cmatch(std::string &pattern) {
   assert(st_ != NULL);
   std::set<char> pattern_alpha = alphabet(pattern);
   assert(pattern_alpha.find('$') == pattern_alpha.end() && pattern_alpha.find('#') == pattern_alpha.end());
   pattern += pattern; // form PP
   pattern.push_back('#'); // add termination character
   st_->insertPattern(pattern, false);
   std::set<int> matches(st_->getMatches());
   st_->removePattern();
   return matches;
 }
Example #13
0
	std::string escape_username(std::string username)
	{
		if (username.find('@') == username.npos &&
		    !config_file.defdomain.empty())
		{
			username.push_back('@');
			username += config_file.defdomain;
		}

		return escape(username);
	}
Example #14
0
bool istream_t::getline(std::string& line)
{
        /// \todo not very efficient: should buffer larger chunks (1K ?!) and check for endline there!
        char c;
        while (read(&c, 1) && isendl(c)) {}

        line.clear();
        while (read(&c, 1) && !isendl(c)) { line.push_back(c); }

        return m_status != io_status::error && !line.empty();
}
Example #15
0
void Cliente::getDireccionYPuerto(char const * dir_puerto, \
                                               std::string& direccion,\
                                               t_puerto& puerto){
    std::stringstream puerto_str;
    char c;
    while ((c=*(dir_puerto++)) && c!=':')
       direccion.push_back(c);
    while ((c=*(dir_puerto++)) && c!='\0')
       puerto_str << c;
       puerto_str >> puerto;
}
Example #16
0
void AIStateMachine::StateTimer::TimeData::DumpTimer(std::ostringstream& msg, std::string prefix)
{
	F64 const tfactor = 1000 / calc_clock_frequency();
	msg << prefix << mName << " " << (mEnd - mStart)*tfactor << "ms" << std::endl;
	prefix.push_back(' ');
	std::vector<TimeData>::iterator it;
	for (it = mChildren.begin(); it != mChildren.end(); ++it)
	{
		it->DumpTimer(msg, prefix);
	}
}
Example #17
0
static void preprocessFile(std::string& source, const std::string& fname, std::vector<std::string>& file_list) {
	static const std::string shader_path("data/shaders/");
	std::ifstream f(shader_path + fname);
	if (!f) {
		source.append("#error File not found: ");
		source.append(fname);
		source.append(".\n");
	}

	unsigned int file_n = file_list.size();
	file_list.push_back(fname);

	if (file_n > 0) {
		source.append("#line 1 ");
		source.append(std::to_string((unsigned long long)file_n));
		source.push_back('\n');
	}

	std::string line;
	unsigned int line_n = 1;
	while (std::getline(f, line)) {
		line_n += 1;
		if (line.substr(0, 8) == "#include") {
			std::smatch results;
			if (std::regex_match(line, results, include_re)) {
				preprocessFile(source, results[1].str(), file_list);
				
				source.append("#line ");
				source.append(std::to_string((unsigned long long)line_n));
				source.push_back(' ');
				source.append(std::to_string((unsigned long long)file_n));
				source.push_back('\n');
			} else {
				source.append("#error Malformed include directive.\n");
			}
		} else {
			source.append(line);
			source.push_back('\n');
		}
	}
}
Example #18
0
bool AParser::read_until(std::string& in, const std::string& delim) {
	unsigned int i = 0;

	while (!eof() && !peek(delim)) {
		in.push_back(getChar());
		i++;
		_index++;
	}
	if (i > 0)
		return true;
	return false;
}
Example #19
0
bool AParser::read_some(std::string& in, unsigned int size) {
	if (_index + size < _buffer.size()) {
		unsigned int i = 0;
		while (i < size) {
			in.push_back(getChar());
			_index++;
			i++;
		}
		return true;
	}
	return false;
}
Example #20
0
bool AParser::read_until_func(std::string& in, const boost::function< bool() >& delim) {
	unsigned int i = 0;
	
	while (!eof() && !delim()) {
		in.push_back(getChar());
		i++;
		_index++;
	}
	if (i > 0)
		return true;
	return false;
}
Example #21
0
  void dfs(char u) {
    m_seen[u] = true;
    // traverse neightbor
    if (m_G.count(u)) {
      for (char v : m_G[u]) {
        if (m_seen[v] == false)
          dfs(v);
      }
    }

    m_order.push_back(u);
  }
Example #22
0
void parseVecStr2Str(const std::vector<std::string>& vec_str, std::string& str,char div)
{
	str.clear();
	for(size_t i=0;i<vec_str.size();++i)
	{
		if(!str.empty())
		{
			str.push_back(div);
		}
		str+=vec_str[i];
	}
}
Example #23
0
    virtual int_type underflow() {
        while (m_curr == m_high) {
            char * line = readline("");
            if (!line) {
                // EOF received
                return traits_type::eof();
            } else if (strlen(line) == 0) {
                // ignore blank line
                m_buffer.push_back('\n');
                free(line);
            } else {
                add_history(line);
                m_buffer += line;
                m_buffer.push_back('\n');
                free(line);
                m_high = m_buffer.size();
            }
        }

        return traits_type::to_int_type(m_buffer[m_curr]);
    }
Example #24
0
	void nextword(std::string& rv)
	{
		int ch = next();
		while (isspace(ch))
			ch = next();
		while (isalnum(ch) || ch == '_'|| ch == '-')
		{
			rv.push_back(ch);
			ch = next();
		}
		unget(ch);
	}
Example #25
0
	bool InputReader::read_quoted_string(std::string& str) {
		//input_stream_ >> str;		// not sure if this works
		char curr_c;
		input_stream_.get(curr_c);
		if(!input_stream_.good()) return false;	// premature end of file reached
		while(curr_c != '"') {
			str.push_back(curr_c);
			input_stream_.get(curr_c);
		} // while
		// not ungetting because last read character is '"'
		return true;
	} // InputReader::read_quoted_string()
Example #26
0
void File::readString(std::string& str, size_t maxChar, bool seekToEnd) {
	size_t temp = cursor;
	str.clear();
	
	char c;
	size_t count = 1;
	read(c);
	
	while (c && count < maxChar && !eof()) {
		str.push_back(c);
		read(c);
		count++;
	}

	if (c)
		str.push_back(c);

	if (seekToEnd) {
		seek(temp+maxChar);
	}
}
Example #27
0
int multiply(const std::string strMultiplierA, const std::string strMultiplierB, std::string &strRst)
{

	/* 在这里实现功能 */
	if (strMultiplierA.length() == 0 || strMultiplierB.length() == 0)
		return -1;

	vector<int> multiA, multiB, result;
	for (int i = strMultiplierA.length() - 1; i >= 0; --i)
		multiA.push_back(strMultiplierA[i] - '0');
	for (int i = strMultiplierB.length() - 1; i >= 0; --i)
		multiB.push_back(strMultiplierB[i] - '0');

	for (int i = 0; i < multiB.size(); ++i)
	{

		vector<int> tempMulti;
		for (int k = 0; k < i; ++k)
			tempMulti.push_back(0);

		int carry = 0;
		for (int j = 0; j < multiA.size(); ++j)
		{
			int temp = multiB[i] * multiA[j] + carry;
			tempMulti.push_back(temp % 10);
			carry = temp / 10;
		}

		if (carry)
			tempMulti.push_back(carry);

		vector<int> tempResult = result;
		result = ArrayAdd(tempMulti, tempResult);
	}

	int pos = -1;
	for (int i = result.size() - 1; i >= 0; --i)
	{
		if (result[i] != 0)
		{
			pos = i;
			break;
		}
	}

	if (pos == -1)
		strRst = "0";

	for (int i = pos; i >= 0; --i)
		strRst.push_back(result[i] + '0');

	return 0;
}
Example #28
0
void PATH_INFO::init_base_path(std::string path)
{
    if (!path.empty()) {
        char ch = path.at(path.length() - 1);
        if (ch != '/' && ch != '\\') {
            path.push_back('/');
        }
    }

    //FILENAMES.insert(std::pair<std::string,std::string>("base_path", path));
    FILENAMES["base_path"] = path;
}
Example #29
0
	ModResult OnUserPreJoin(User* user, Channel* chan, const char* cname, std::string& privs, const std::string& keygiven)
	{
		/* The user may have the +H umode on himself, but +H does not necessarily correspond
		 * to the +H of m_hideoper.
		 * However we only add the modewatcher when m_hideoper is loaded, so these
		 * conditions (mw_added and the user being +H) together mean the user is a hidden oper.
		 */

		if (IS_OPER(user) && (!mw_added || !user->IsModeSet('H')))
			privs.push_back('y');
		return MOD_RES_PASSTHRU;
	}
Example #30
0
void print_dictionary(std::ostream& os, const bnode<symbol>* root, std::string& s) {

    //std::cout << "traversing root "  << root->value.count <<std::endl;
    if ((root->left == 0) && (root->right == 0)) {
        os << root->value.value << " " << s << std::endl;
        return;
    } else if ((root->left == 0) || (root->right == 0)) {
        std::cout << "incorrect tree" << std::endl;
        throw std::runtime_error("incorrect tree");
    }

    // visit left '0' path
    s.push_back('0');
    print_dictionary(os, root->left, s);
    s.resize(s.size() - 1);

    // visit right '1' path
    s.push_back('1');
    print_dictionary(os, root->right, s);
    s.resize(s.size() - 1);
} // print_dictionary