示例#1
0
void CustomXmlDataWriter::writeValue(const Variant& value)
{
	CustomXmlData data;
	bool isOk = value.tryCast(data);
	assert(isOk);
	if (!isOk)
	{
		stream_.setState(std::ios_base::failbit);
		return;
	}
	beginOpenTag("name");
	endOpenTag();
	stream_ << quoted(data.name_);
	closeTag("name");

	beginOpenTag("filename");
	endOpenTag();
	stream_ << quoted(data.filename_);
	closeTag("filename");

	beginOpenTag("createdBy");
	endOpenTag();
	stream_ << quoted(data.createdBy_);
	closeTag("createdBy");

	beginOpenTag("visibility");
	endOpenTag();
	stream_ << data.visibility_;
	closeTag("visibility");

	beginOpenTag("position");
	endOpenTag();
	stream_ << data.position_;
	closeTag("position");
}
示例#2
0
文件: parse.cpp 项目: shaurz/amp
Value
Parser::parse()
{
	switch (eats()) {
	case '(':
		read(); return list();
	case '\'':
		read(); return quoted(sym_quote);
	case '`':
		read(); return quoted(sym_quasiquote);
	case ',':
		read();
		if (c == '@') {
			read();
			return quoted(sym_unquote_splicing);
		}
		else
			return quoted(sym_unquote);
	case ')':
		parse_error("too many right-parens");
	case EOF:
		parse_error("unexpected end of file");
	}
	return atom();
}
示例#3
0
文件: b.c 项目: edgar-pek/PerspicuOS
char *cclenter(const char *argp)	/* add a character class */
{
	int i, c, c2;
	int j;
	uschar *p = (uschar *) argp;
	uschar *op, *bp;
	static uschar *buf = 0;
	static int bufsz = 100;

	op = p;
	if (buf == 0 && (buf = (uschar *) malloc(bufsz)) == NULL)
		FATAL("out of space for character class [%.10s...] 1", p);
	bp = buf;
	for (i = 0; (c = *p++) != 0; ) {
		if (c == '\\') {
			c = quoted(&p);
		} else if (c == '-' && i > 0 && bp[-1] != 0) {
			if (*p != 0) {
				c = bp[-1];
				c2 = *p++;
				if (c2 == '\\')
					c2 = quoted(&p);
				if (collate_range_cmp(c, c2) > 0) {
					bp--;
					i--;
					continue;
				}
				for (j = 0; j < NCHARS; j++) {
					if ((collate_range_cmp(c, j) > 0) ||
					    collate_range_cmp(j, c2) > 0)
						continue;
					if (!adjbuf((char **) &buf, &bufsz, bp-buf+2, 100, (char **) &bp, "cclenter1"))
						FATAL("out of space for character class [%.10s...] 2", p);
					*bp++ = j;
					i++;
				}
				continue;
			}
		}
		if (!adjbuf((char **) &buf, &bufsz, bp-buf+2, 100, (char **) &bp, "cclenter2"))
			FATAL("out of space for character class [%.10s...] 3", p);
		*bp++ = c;
		i++;
	}
	*bp = 0;
	dprintf( ("cclenter: in = |%s|, out = |%s|\n", op, buf) );
	xfree(op);
	return (char *) tostring((char *) buf);
}
std::string quote(const std::string& str)
{
	std::string quoted("\"");
	quoted += str;
	quoted += "\"";
	return quoted;
}
示例#5
0
 SQRESULT tostring(HSQUIRRELVM sqvm) {
     native_string result("[");
     
     sqxtd::vm vm{sqvm};
     
     try {
         sqxtd::array array{validate<sqxtd::array>(vm.stack.at(-1))
             .with_error(_SC("array::tostring: invalid receiver of type `%s` "
                             "(are you calling the _tostring() metamethod on "
                             "the `array` default delegate directly?)"),
                         vm.stack.typename_at(-1)).value()};
         
         for (auto &object : array) {
             result += quoted(object).tostring();
             result += ", ";
         }
     } catch (object::invalid_cast) {
         return SQ_ERROR;
     }
     
     // no commas to delete for empty array
     if (result.length() > 1) {
         result.erase(result.length()-2, result.length());
     }
     
     result += "]";
     
     vm.stack.push(result);
     return 1;
 }
示例#6
0
 SQRESULT tostring(HSQUIRRELVM sqvm) {
     sqxtd::vm vm{sqvm};
     
     native_string result("{\n");
     
     try {
         sqxtd::table table
             {validate<sqxtd::table>(vm.stack.at(-1))
                 .with_error(_SC("table::tostring: invalid receiver of type `%s` "
                                 "(are you calling the _tostring() metamethod on "
                                 "the `table` default delegate directly?)"),
                             vm.stack.typename_at(-1)).value()};
         
         for (auto &pair : table) {
             auto key_value = format_key_value(pair.first.tostring(), quoted(pair.second).tostring());
             
             result += indent_string(key_value);
             result += "\n";
         }
     } catch (object::invalid_cast) {
         return SQ_ERROR;
     }
     
     result += "}";
     
     vm.stack.push(result);
     return 1;
 }
csv_line_grammar<Iterator, Skipper>::csv_line_grammar()
    : csv_line_grammar::base_type(line)
{
    qi::_r1_type _r1;
    qi::_r2_type _r2;
    qi::lit_type lit;
    qi::char_type char_;
    unesc_char.add
        ("\\a", '\a')
        ("\\b", '\b')
        ("\\f", '\f')
        ("\\n", '\n')
        ("\\r", '\r')
        ("\\t", '\t')
        ("\\v", '\v')
        ("\\\\",'\\')
        ("\\\'", '\'')
        ("\\\"", '\"')
        ("\"\"", '\"') // double quote
        ;
    line = -lit("\r") > -lit("\n") > column(_r1, _r2) % lit(_r1)
        ;
    column = quoted(_r2) | *(char_ - lit(_r1))
        ;
    quoted = lit(_r1) > text(_r1) > lit(_r1) // support unmatched quotes or not (??)
        ;
    text = *(unesc_char | (char_ - lit(_r1)))
        ;
    BOOST_SPIRIT_DEBUG_NODES((line)(column)(quoted));
}
示例#8
0
文件: parser.c 项目: mewo2/gertie
tokenlist* parse(tokenlist* tl, sexp** ps) {
  sexp* s;
  token* tok = tl->tok;
  switch (tok->type) {
    case OPENPAR_TOKEN:
      if (tl->next == NULL) {
        error("Unexpected end of input");
      }
      if (tl->next->tok->type == CLOSEPAR_TOKEN) {
        *ps = &nil_sexp;
        return tl->next->next;
      }
      tl = tl->next;
      s = new_sexp(PAIR_SEXP);
      *ps = s;
      while (1) {
        tl = parse(tl, &car(s));
        if (tl == NULL) {
          error("Unexpected end of input");
        }
        if (tl->tok->type == CLOSEPAR_TOKEN) {
          cdr(s) = &nil_sexp;
          return tl->next;
        }
        cdr(s) = new_sexp(PAIR_SEXP);
        s = cdr(s);
      }
    case CLOSEPAR_TOKEN:
      error("Unexpected ')'");
    case SYMBOL_TOKEN:
      *ps = symbol_sexp(tok->symbol);
      return tl->next;
    case NUMBER_TOKEN:
      *ps = number_sexp(tok->number);
      return tl->next;
    case BOOLEAN_TOKEN:
      *ps = boolean_sexp(tok->number);
      return tl->next;
    case QUOTE_TOKEN:
      tl = parse(tl->next, &s);
      *ps = quoted(s);
      return tl;
    case QQ_TOKEN:
      tl = parse(tl->next, &s);
      *ps = quasiquoted(s);
      return tl;
    case UNQUOTE_TOKEN:
      tl = parse(tl->next, &s);
      *ps = unquoted(s);
      return tl;
    case SPLICE_TOKEN:
      tl = parse(tl->next, &s);
      *ps = unquote_spliced(s);
      return tl;
    case STRING_TOKEN:
      *ps = string_sexp(tok->symbol);
      return tl->next;
  }
}
示例#9
0
char *cclenter(const char *argp)	/* add a character class */
{
    int i, c, c2;
    uschar *p = (uschar *) argp;
    uschar *op, *bp;
    static uschar *buf = 0;
    static int bufsz = 100;

    op = p;
    if (buf == 0 && (buf = (uschar *) malloc(bufsz)) == NULL)
        FATAL("out of space for character class [%.10s...] 1", p);
    bp = buf;
    for (i = 0; (c = *p++) != 0; ) {
        if (c == '\\') {
            c = quoted((char **) &p);
        } else if (c == '-' && i > 0 && bp[-1] != 0) {
            if (*p != 0) {
                c = bp[-1];
                c2 = *p++;
                if (c2 == '\\')
                    c2 = quoted((char **) &p);
                if (c > c2) {	/* empty; ignore */
                    bp--;
                    i--;
                    continue;
                }
                while (c < c2) {
                    if (!adjbuf((char **) &buf, &bufsz, bp-buf+2, 100, (char **) &bp, "cclenter1"))
                        FATAL("out of space for character class [%.10s...] 2", p);
                    *bp++ = ++c;
                    i++;
                }
                continue;
            }
        }
        if (!adjbuf((char **) &buf, &bufsz, bp-buf+2, 100, (char **) &bp, "cclenter2"))
            FATAL("out of space for character class [%.10s...] 3", p);
        *bp++ = c;
        i++;
    }
    *bp = 0;
    dprintf( ("cclenter: in = |%s|, out = |%s|\n", op, buf) );
    xfree(op);
    return (char *) tostring((char *) buf);
}
示例#10
0
/** handle nested comments and simple minded attributes
  */
void lqGvSynCol::highlightBlock(const QString &text)
{
    QString begComm("/\\*");
    QString number("\\d+(?:\\.\\d+)?");
    QString symbol("\\w+");
    QString quoted("\"[^\"]*\"");
    QString edges("--|->");

    QRegExp tokens(QString("(%1)|(%2)|(%3)|(%4)|(%5)|#").arg(begComm, number, symbol, quoted, edges));
    QRegExp endComm("\\*/");

    // simple state machine
    if (currentBlock().blockNumber() > 0)
        setCurrentBlockState(previousBlockState());
    else
        setCurrentBlockState(0);

    for (int i = 0, j, l; ; i = j + l)
        if (currentBlockState()) {              // in multiline comment
            if ((j = endComm.indexIn(text, i)) == -1) {
                setFormat(i, text.length() - i, fmt[Comm]);
                break;
            }
            setFormat(i, j - i + (l = 2), fmt[Comm]);
            setCurrentBlockState(0);
        } else {
            if ((j = tokens.indexIn(text, i)) == -1)
                break;
            QStringList ml = tokens.capturedTexts();
            Q_ASSERT(ml.length() == 5+1);
            if ((l = ml[1].length())) {         // begin multiline comment
                setFormat(j, l, fmt[Comm]);
                setCurrentBlockState(1);
            } else if ((l = ml[2].length())) {  // number
                setFormat(j, l, fmt[Number]);
            } else if ((l = ml[3].length())) {  // symbol
                if (keyws.contains(ml[3]))
                    setFormat(j, l, fmt[Keyw]);
                else if (attrs.contains(ml[3]))
                    setFormat(j, l, fmt[Attr]);
                else
                    setFormat(j, l, fmt[Unknown]);
            } else if ((l = ml[4].length())) {  // quoted
                setFormat(j, l, fmt[Quoted]);
            } else if ((l = ml[5].length())) {  // edge
                setFormat(j, l, fmt[Edge]);
            } else {                            // single line comment
                setFormat(j, text.length() - i, fmt[Comm]);
                break;
            }
        }

    // rather useless - anyway textChanged will fire after completion
    if (currentBlock().blockNumber() == document()->blockCount() - 1)
        emit completed();
}
示例#11
0
object_t *eval(object_t *exp, object_t *env) { 
  object_t *ret = NULL;
  
  if (evaluate_to_self(exp)) {
    ret = exp;
  }
  else if (quoted(exp)) {
    ret = car(cdr(exp));
  }
  else if (definition(exp)) {
    object_t *symb = car(cdr(exp)),
      *val = car(cdr(cdr(exp)));
    
    if (val == NULL) {
      create_new_variable(symb, get_nil(), env);
    } else {
      create_new_variable(symb,
			  eval(val, env),
			  env);
    }
    ret = symb;
  }
  else if (is_symbol(exp)) {
    //printf("\nfound symbol: %s\n\n", exp->values.symbol.value);
    ret = find_variable_value(exp, env);
  }
  else if (function(exp)) {
    object_t *arguments = make_arguments(cdr(exp), env);
    object_t *func = eval(car(exp), env);

    if (func == NULL || func == get_nil() ||
	func->type != t_primitive) {
      fprintf(stderr, "func: %d\n", (unsigned int)func);
      //fprintf(stderr, "type: %d\n", func->type);
      die("Not a primitive!\n");
    } else {
      ret = (func->values.primitive.function)(arguments);
    }
  } else if (maybe_eval_to_function(exp)) {
    object_t *c = car(exp);
    object_t *func = eval(c, env);
    if (!(func == NULL || nilp(func))) {
      object_t *arguments = make_arguments(cdr(exp), env);
      ret = (func->values.primitive.function)(arguments);
    }
    else {
      die("Not a function!\n");
    }
  }
  else {
    die("Can't eval!\n");
  }
  
  return ret;
}
示例#12
0
inline std::ostream & operator<<(std::ostream & os, const if_not_empty & s) {
	if(s.value.length() > 100) {
		color::shell_command prev = color::current;
		return os << s.name << ": " << color::white << s.value.length() << prev
		          << " bytes" << '\n';
	} else if(!s.value.empty()) {
		return os << s.name << ": " << quoted(s.value) << '\n';
	} else {
		return os;
	}
}
示例#13
0
文件: imapparser.cpp 项目: aox/aox
EString ImapParser::string()
{
    char c = nextChar();

    if ( c == '"' )
        return quoted();
    else if ( c == '{' || c == '~' )
        return literal();

    setError( "Expected string, but saw: " + following() );
    return "";
}
// import - prints the preamble, then loops over all files and import them one by one
void SpectraSTMs2LibImporter::import() {

  for (vector<string>::iterator i = m_impFileNames.begin(); i != m_impFileNames.end(); i++) {
    string fullName(*i);
    makeFullPath(fullName);
    string quoted("\"" + fullName + "\"");
    string desc = m_params.constructDescrStr(quoted, ".ms2");
    m_preamble.push_back(desc);
  }
  
  m_lib->writePreamble(m_preamble);
  
  for (vector<string>::iterator i = m_impFileNames.begin(); i != m_impFileNames.end(); i++) {
    readFromFile(*i);
  } 
}
示例#15
0
/**
 * Quotes the given string, escaping special characters as necessary.
 */
QString LuaTableWriter::quote(const QString &str)
{
    QString quoted("\"");

    for (const QChar c : str) {
        switch (c.unicode()) {
        case '\\':  quoted.append(QLatin1String("\\\\"));  break;
        case '"':   quoted.append(QLatin1String("\\\""));  break;
        case '\n':  quoted.append(QLatin1String("\\n"));   break;
        default:    quoted.append(c);
        }
    }

    quoted.append(QLatin1Char('"'));
    return quoted;
}
示例#16
0
void RxCompile::element()
	{
	if (match('^'))
		emit(&startOfLine);
	else if (match('$'))
		emit(&endOfLine);
	else if (match("\\A"))
		emit(&startOfString);
	else if (match("\\Z"))
		emit(&endOfString);
	else if (match("\\<"))
		emit(&startOfWord);
	else if (match("\\>"))
		emit(&endOfWord);
	else if (match("(?i)"))
		ignoringCase = true;
	else if (match("(?-i)"))
		ignoringCase = false;
	else if (match("(?q)"))
		quoted();
	else if (match("(?-q)"))
		;
	else
		{
		int start = pat.size();
		simple();
		int len = pat.size() - start;
		if (match("??"))
			insert(start, new Branch(len + 1, 1));
		else if (match('?'))
			insert(start, new Branch(1, len + 1));
		else if (match("+?"))
			emit(new Branch(1, -len));
		else if (match('+'))
			emit(new Branch(-len, 1));
		else if (match("*?"))
			{
			emit(new Branch(1, -len));
			insert(start, new Branch(len + 2, 1));
			}
		else if (match('*'))
			{
			emit(new Branch(-len, 1));
			insert(start, new Branch(1, len + 2));
			}
		}
	}
示例#17
0
/** this is a very limited - and much bugged - approach to
  * highlighting Prolog syntax.
  * Just a quick alternative to properly interfacing SWI-Prolog goodies,
  * that proved much more difficult to do rightly than I foreseen
  */
void plMiniSyntax::setup() {
    QString number("\\d+(?:\\.\\d+)?");
    QString symbol("[a-z][A-Za-z0-9_]*");
    QString var("[A-Z_][A-Za-z0-9_]*");
    QString quoted("\"[^\"]*\"");
    QString oper("[\\+\\-\\*\\/\\=\\^<>~:\\.,;\\?@#$\\\\&{}`]+");

    tokens = QRegExp(QString("(%1)|(%2)|(%3)|(%4)|(%5)|%").arg(number, symbol, var, quoted, oper));

    fmt[Comment].setForeground(Qt::darkGreen);
    fmt[Number].setForeground(QColor("blueviolet"));
    fmt[Atom].setForeground(Qt::blue);
    fmt[String].setForeground(Qt::magenta);
    fmt[Variable].setForeground(QColor("brown"));
    fmt[Operator].setFontWeight(QFont::Bold);
    fmt[Unknown].setForeground(Qt::darkRed);
}
示例#18
0
std::string IFunction::Attribute::asQuotedString()const
{
  std::string attr;

  try
  {
    attr = boost::get<std::string>(m_data);
  }
  catch(...)
  {
    throw std::runtime_error("Trying to access a "+type()+" attribute "
      "as string");
  }
  std::string quoted(attr);
  if( *(attr.begin()) != '\"' ) quoted = "\"" + attr;
  if( *(quoted.end() - 1) != '\"' ) quoted += "\"";

  return quoted;
}
示例#19
0
void tst_qregexp::escape_new4()
{
    QFETCH(QString, pattern);
    QFETCH(QString, expected);

    QBENCHMARK {
        const int n = pattern.size();
        const QChar *patternData = pattern.data();
        // try to prevent copy if no escape is needed
        int i = 0;
        for (int i = 0; i != n; ++i) {
            const QChar c = patternData[i];
            if (needsEscaping(c.unicode()))
                break;
        }
        if (i == n) {
            verify(pattern, expected);
            // no escaping needed, "return pattern" should be done here.
            return;
        }
        const QLatin1Char backslash('\\');
        QString quoted(n * 2, backslash);
        QChar *quotedData = quoted.data();
        for (int j = 0; j != i; ++j) 
            *quotedData++ = *patternData++;
        int escaped = 0;
        for (; i != n; ++i) {
            const QChar c = *patternData;
            if (needsEscaping(c.unicode())) {
                ++escaped;
                ++quotedData;
            }
            *quotedData = c;
            ++quotedData;
            ++patternData;
        }
        quoted.resize(n + escaped); 
        verify(quoted, expected);
        // "return quoted"
    }
}
示例#20
0
void tst_qregexp::escape_new2()
{
    QFETCH(QString, pattern);
    QFETCH(QString, expected);

    QBENCHMARK {
        int count = pattern.count();
        const QLatin1Char backslash('\\');
        QString quoted(count * 2, backslash);
        const QChar *patternData = pattern.data();
        QChar *quotedData = quoted.data();
        int escaped = 0;
        for ( ; --count >= 0; ++patternData) {
            const QChar c = *patternData;
            switch (c.unicode()) {
            case '$':
            case '(':
            case ')':
            case '*':
            case '+':
            case '.':
            case '?':
            case '[':
            case '\\':
            case ']':
            case '^':
            case '{':
            case '|':
            case '}':
                ++escaped;
                ++quotedData;
            }
            *quotedData = c;
            ++quotedData;
        }
        quoted.resize(pattern.size() + escaped); 

        verify(quoted, expected);
    }
}
示例#21
0
bool option_parser::run(std::istream &is, bool ignore_errors)
{
	// quoted value. leftmost and rightmost quotation marks are the delimiters.
	boost::regex quoted("(\\w+)\\h*=\\h*\"(.*)\"[^\"]*");
	// unquoted value. whitespaces get trimmed.
	boost::regex unquoted("(\\w+)\\h*=\\h*(.*?)\\h*");
	boost::smatch match;
	std::string line;
	while (std::getline(is, line))
	{
		if (boost::regex_match(line, match, quoted)
		||  boost::regex_match(line, match, unquoted))
		{
			std::string option = match[1];
			auto it = m_parsers.find(option);
			if (it != m_parsers.end())
			{
				try
				{
					it->second.parse(match[2]);
				}
				catch (std::exception &e)
				{
					std::cerr << "Error while processing option \"" << option
					          << "\": " << e.what() << "\n";
					if (!ignore_errors)
						return false;
				}
			}
			else
			{
				std::cerr << "Unknown option: " << option << "\n";
				if (!ignore_errors)
					return false;
			}
		}
	}
	return true;
}
示例#22
0
	string load_string( const string& filename )
	{
#if 0
		// read file contents into char array
		FILE* f = fopen( filename.c_str(), "rb" );
		flut_error_if( f == NULL, "Could not open " + quoted( filename ) );

		fseek( f, 0, SEEK_END );
		int file_len = ftell( f );
		rewind( f );

		string s( file_len, '\0' );
		fread( reinterpret_cast< void* >( &s[ 0 ] ), sizeof( char ), file_len, f );

		return s;
#else
		// this method uses a stringbuf, which may be slower but more stable
		std::ifstream ifstr( filename );
		std::stringstream buf;
		buf << ifstr.rdbuf();
		return buf.str();
#endif
	}
示例#23
0
void SQLSyntaxHighligter::highlightBlock(const QString &text)
{
    highlightBlockHelper(text, m_keyword_list, m_sql_keyword_format);
    highlightBlockHelper(text, m_function_list, m_sql_function_format);

    foreach(QString command, m_commant_list) {
        if(text.startsWith(command, Qt::CaseInsensitive))
            setFormat(0, command.length(), m_sql_command_format);
    }

    if (m_database) {
        QStringList tables = m_database->tables(QSql::AllTables);
        QStringList foundTables = highlightBlockHelper(text, tables, m_sql_table_format);

        if (!m_table.isEmpty())
            foundTables << m_table;

        QStringList columns;
        foreach(QString oneTable, foundTables) {
            QSqlRecord record = m_database->record(oneTable);
            for (int i = 0; i < record.count(); ++i) {
                columns << record.fieldName(i);
            }
        }

        highlightBlockHelper(text, columns, m_sql_column_format);

        { // highlight quote
            QRegExp quoted("\"[^\"]*\"");
            int pos = -1;
            while ((pos = text.indexOf(quoted, pos+1)) >= 0) {
                setFormat(pos, quoted.matchedLength(), m_sql_quoted_format);
                pos += quoted.matchedLength();
            }
        }
    }
示例#24
0
    std::string
    Value::iterateFormatted(const Value& value, const int indent)
    {
        std::stringstream stream;

        if (value.size() > 0)
        {
            //    Stream a table begin
            if (indent > 0)
            {
                stream << "{\n";
            }

            unsigned count = 0;
            for (auto& pair : value)
            {
                ///    pair.first is the key, which is a string
                ///    pair.second is the value, which may be a table

                //    Set the initial indent
                stream << indented(indent);

                //    Stream the key
                stream << pair.first << " = ";

                //    Process any children this table has
                stream << iterateFormatted(pair.second, indent + 1);

                //    Commas are required between elements, but not after the last one
                if (indent > 0 && count < value.size() - 1)
                {
                    stream << ", ";
                }

                stream << "\n";
                ++count;
            }

            //    Stream a table end
            if (indent > 0)
            {
                stream << indented(indent - 1);
                stream << "}";
            }
        }
        else
        {
            switch (value.type)
            {
                case Boolean:
                    stream << std::boolalpha << value.b;
                    break;
                case Number:
                    stream << value.n;
                    break;
                case String:
                    stream << quoted(value.s);
                    break;
                default:
                    break;
                    // wrong
                    // also could be an empty table
            }
        }

        return stream.str();
    }
示例#25
0
文件: re.c 项目: carriercomm/legacy
	/* Compile a pattern */
void
*compre(char *pat)
{
	int i, j, inclass;
	char c, *p, *s;
	Reprog *program;

	if (!compile_time) {	/* search cache for dynamic pattern */
		for (i = 0; i < npats; i++)
			if (!strcmp(pat, pattern[i].re)) {
				pattern[i].use++;
				return((void *) pattern[i].program);
			}
	}
		/* Preprocess Pattern for compilation */
	p = re;
	s = pat;
	inclass = 0;
	while (c = *s++) {
		if (c == '\\') {
			quoted(&s, &p, re+MAXRE);
			continue;
		}
		else if (!inclass && c == '(' && *s == ')') {
			if (p < re+MAXRE-2) {	/* '()' -> '[]*' */
				*p++ = '[';
				*p++ = ']';
				c = '*';
				s++;
			}
			else overflow();
		}
		else if (c == '['){			/* '[-' -> '[\-' */
			inclass = 1;
			if (*s == '-') {
				if (p < re+MAXRE-2) {
					*p++ = '[';
					*p++ = '\\';
					c = *s++;
				}
				else overflow();
			}				/* '[^-' -> '[^\-'*/
			else if (*s == '^' && s[1] == '-'){
				if (p < re+MAXRE-3) {
					*p++ = '[';
					*p++ = *s++;
					*p++ = '\\';
					c = *s++;
				}
				else overflow();
			}
			else if (*s == '['){		/* skip '[[' */
				if (p < re+MAXRE-1)
					*p++ = c;
				else overflow();
				c = *s++;
			}
			else if (*s == '^' && s[1] == '[') {	/* skip '[^['*/
				if (p < re+MAXRE-2) {
					*p++ = c;
					*p++ = *s++;
					c = *s++;
				}
				else overflow();
			}
			else if (*s == ']') {		/* '[]' -> '[]*' */
				if (p < re+MAXRE-2) {
					*p++ = c;
					*p++ = *s++;
					c = '*';
					inclass = 0;
				}
				else overflow();
			}
		}
		else if (c == '-' && *s == ']') {	/* '-]' -> '\-]' */
			if (p < re+MAXRE-1)
				*p++ = '\\';
			else overflow();
		}
		else if (c == ']')
			inclass = 0;
		if (p < re+MAXRE-1)
			*p++ = c;
		else overflow();
	}
	*p = 0;
	program = regcomp(re);		/* compile pattern */
	if (!compile_time) {
		if (npats < NPATS)	/* Room in cache */
			i = npats++;
		else {			/* Throw out least used */
			int use = pattern[0].use;
			i = 0;
			for (j = 1; j < NPATS; j++) {
				if (pattern[j].use < use) {
					use = pattern[j].use;
					i = j;
				}
			}
			xfree(pattern[i].program);
			xfree(pattern[i].re);
		}
		pattern[i].re = tostring(pat);
		pattern[i].program = program;
		pattern[i].use = 1;
	}
	return((void *) program);
}
示例#26
0
int relex(void)		/* lexical analyzer for reparse */
{
    int c, n;
    int cflag;
    static uschar *buf = 0;
    static int bufsz = 100;
    uschar *bp;
    struct charclass *cc;
    int i;

    switch (c = *prestr++) {
    case '|':
        return OR;
    case '*':
        return STAR;
    case '+':
        return PLUS;
    case '?':
        return QUEST;
    case '.':
        return DOT;
    case '\0':
        prestr--;
        return '\0';
    case '^':
    case '$':
    case '(':
    case ')':
        return c;
    case '\\':
        rlxval = quoted((char **) &prestr);
        return CHAR;
    default:
        rlxval = c;
        return CHAR;
    case '[':
        if (buf == 0 && (buf = (uschar *) malloc(bufsz)) == NULL)
            FATAL("out of space in reg expr %.10s..", lastre);
        bp = buf;
        if (*prestr == '^') {
            cflag = 1;
            prestr++;
        }
        else
            cflag = 0;
        n = 2 * strlen((const char *) prestr)+1;
        if (!adjbuf((char **) &buf, &bufsz, n, n, (char **) &bp, "relex1"))
            FATAL("out of space for reg expr %.10s...", lastre);
        for (; ; ) {
            if ((c = *prestr++) == '\\') {
                *bp++ = '\\';
                if ((c = *prestr++) == '\0')
                    FATAL("nonterminated character class %.20s...", lastre);
                *bp++ = c;
                /* } else if (c == '\n') { */
                /* 	FATAL("newline in character class %.20s...", lastre); */
            } else if (c == '[' && *prestr == ':') {
                /* POSIX char class names, Dag-Erling Smorgrav, [email protected] */
                for (cc = charclasses; cc->cc_name; cc++)
                    if (strncmp((const char *) prestr + 1, (const char *) cc->cc_name, cc->cc_namelen) == 0)
                        break;
                if (cc->cc_name != NULL && prestr[1 + cc->cc_namelen] == ':' &&
                        prestr[2 + cc->cc_namelen] == ']') {
                    prestr += cc->cc_namelen + 3;
                    for (i = 0; i < NCHARS; i++) {
                        if (!adjbuf((char **) &buf, &bufsz, bp-buf+1, 100, (char **) &bp, "relex2"))
                            FATAL("out of space for reg expr %.10s...", lastre);
                        if (cc->cc_func(i)) {
                            *bp++ = i;
                            n++;
                        }
                    }
                } else
                    *bp++ = c;
            } else if (c == '\0') {
                FATAL("nonterminated character class %.20s", lastre);
            } else if (bp == buf) {	/* 1st char is special */
                *bp++ = c;
            } else if (c == ']') {
                *bp++ = 0;
                rlxstr = (uschar *) tostring((char *) buf);
                if (cflag == 0)
                    return CCL;
                else
                    return NCCL;
            } else
                *bp++ = c;
        }
    }
}
示例#27
0
int run(int argc, char **argv, int is_gui) {

    char python[256];   /* python executable's filename*/
    char *pyopt;        /* Python option */
    char script[256];   /* the script's filename */

    int scriptf;        /* file descriptor for script file */

    char **newargs, **newargsp, **parsedargs; /* argument array for exec */
    char *ptr, *end;    /* working pointers for string manipulation */
    char *cmdline;
    int i, parsedargc;              /* loop counter */

    /* compute script name from our .exe name*/
    GetModuleFileNameA(NULL, script, sizeof(script));
    end = script + strlen(script);
    while( end>script && *end != '.')
        *end-- = '\0';
    *end-- = '\0';
    strcat(script, (GUI ? "-script.pyw" : "-script.py"));

    /* figure out the target python executable */

    scriptf = open(script, O_RDONLY);
    if (scriptf == -1) {
        return fail("Cannot open %s\n", script);
    }
    end = python + read(scriptf, python, sizeof(python));
    close(scriptf);

    ptr = python-1;
    while(++ptr < end && *ptr && *ptr!='\n' && *ptr!='\r') {;}

    *ptr-- = '\0';

    if (strncmp(python, "#!", 2)) {
        /* default to python.exe if no #! header */
        strcpy(python, "#!python.exe");
    }

    parsedargs = parse_argv(python+2, &parsedargc);

    /* Using spawnv() can fail strangely if you e.g. find the Cygwin
       Python, so we'll make sure Windows can find and load it */

    ptr = find_exe(parsedargs[0], script);
    if (!ptr) {
        return fail("Cannot find Python executable %s\n", parsedargs[0]);
    }

    /* printf("Python executable: %s\n", ptr); */

    /* Argument array needs to be
       parsedargc + argc, plus 1 for null sentinel */

    newargs = (char **)calloc(parsedargc + argc + 1, sizeof(char *));
    newargsp = newargs;

    *newargsp++ = quoted(ptr);
    for (i = 1; i<parsedargc; i++) *newargsp++ = quoted(parsedargs[i]);

    *newargsp++ = quoted(script);
    for (i = 1; i < argc; i++)     *newargsp++ = quoted(argv[i]);

    *newargsp++ = NULL;

    /* printf("args 0: %s\nargs 1: %s\n", newargs[0], newargs[1]); */

    if (is_gui) {
        /* Use exec, we don't need to wait for the GUI to finish */
        execv(ptr, (const char * const *)(newargs));
        return fail("Could not exec %s", ptr);   /* shouldn't get here! */
    }

    /*
     * distribute-issue207: using CreateProcessA instead of spawnv
     */
    cmdline = join_executable_and_args(ptr, newargs, parsedargc + argc);
    return create_and_wait_for_subprocess(cmdline);
}
示例#28
0
	TextStream& operator<<(TextStream& stream, const Base& v)
	{
		stream << v.i << ' ' << v.f << ' ' << quoted( v.s );
		return stream;
	}
示例#29
0
文件: b.c 项目: ajallooeian/libawkcpp
int relex(void)		/* lexical analyzer for reparse */
{
	int c, n;
	int cflag;
	static char *buf = 0;
	static int bufsz = 100;
	char *bp;

	switch (c = *prestr++) {
	case '|': return OR;
	case '*': return STAR;
	case '+': return PLUS;
	case '?': return QUEST;
	case '.': return DOT;
	case '\0': prestr--; return '\0';
	case '^':
	case '$':
	case '(':
	case ')':
		return c;
	case '\\':
		rlxval = quoted(&prestr);
		return CHAR;
	default:
		rlxval = c;
		return CHAR;
	case '[': 
		if (buf == 0 && (buf = (char *) malloc(bufsz)) == NULL)
			ERROR "out of space in reg expr %.10s..", lastre FATAL;
		bp = buf;
		if (*prestr == '^') {
			cflag = 1;
			prestr++;
		}
		else
			cflag = 0;
		n = 2 * strlen(prestr)+1;
		if (!adjbuf(&buf, &bufsz, n, n, &bp, 0))
			ERROR "out of space for reg expr %.10s...", lastre FATAL;
		for (; ; ) {
			if ((c = *prestr++) == '\\') {
				*bp++ = '\\';
				if ((c = *prestr++) == '\0')
					ERROR "nonterminated character class %.20s...", lastre FATAL;
				*bp++ = c;
			} else if (c == '\n') {
				ERROR "newline in character class %.20s...", lastre FATAL;
			} else if (c == '\0') {
				ERROR "nonterminated character class %.20s", lastre FATAL;
			} else if (bp == buf) {	/* 1st char is special */
				*bp++ = c;
			} else if (c == ']') {
				*bp++ = 0;
				rlxstr = tostring(buf);
				if (cflag == 0)
					return CCL;
				else
					return NCCL;
			} else
				*bp++ = c;
		}
	}
}
示例#30
0
  /*!
   *  \brief  二重引用符で囲まれた文字列を展開する。
   */
  std::string expand_quote( std::string const& str )
  {
    // boost-1.35.x以上対策
    std::string::size_type n = str.find_first_not_of( " \t\r\n" );
    std::string quoted( str, n );

    if ( quoted.size() < 2 || quoted[0] != '"' || quoted[quoted.size() - 1] != '"' )
    {
      throw std::invalid_argument( "argument is not quoted" );
    }
    std::string result;
    for ( std::string::const_iterator iter( quoted.begin() + 1 ), last( quoted.end() - 1 );
          iter != last;
          ++iter )
    {
      if ( *iter == '\\' )
      {
        if ( ++iter == last )
        {
          throw std::invalid_argument( "argument is not quoted" );
        }
        char c = *iter;
        switch ( c )
        {
        case 'a':
          c = '\a';
          break;
        case 'b':
          c = '\b';
          break;
        case 'f':
          c = '\f';
          break;
        case 'n':
          c = '\n';
          break;
        case 'r':
          c = '\r';
          break;
        case 't':
          c = '\t';
          break;
        case 'v':
          c = '\v';
          break;
        case 'x':
          if ( std::isxdigit( static_cast< unsigned char >( *iter ) ) )
          {
            c = 0;
            for ( std::string::const_iterator bound( iter + 2 );
                  iter != bound && std::isxdigit( static_cast< unsigned char >( *iter ) );
                  ++iter )
            {
              c <<= 4;
              int t = std::tolower( static_cast< unsigned char >( *iter ) );
              static char const xdigits[] = "0123456789abcdef";
              c += std::strchr( xdigits, t ) - xdigits;
            }
          }
          break;
        default:
          if ( '0' <= c && c <= '7' ) // '\ooo'
          {
            c = 0;
            for ( std::string::const_iterator bound( iter + 3 );
                  iter != bound && ( '0' <= *iter && *iter <= '7' );
                  ++iter )
            {
              c = ( c << 3 ) + *iter - '0';
            }
          }
          // 国際文字名(\uhhhh, \Uhhhhhhhh)未対応
          // 二文字表記(<:等)未対応
          // 三文字表記(??/等)未対応
          break;
        }
        result.push_back( c );
      }
      else
      {
        result.push_back( *iter );
      }
    }
    return result;
  }