wchar_t *GetExtensions(JNIEnv *env, jobject jFilter)
{
    JLObjectArray jExts(env, (jobjectArray)env->CallObjectMethod(jFilter,
                               javaIDs.CommonDialogs.ExtensionFilter.extensionsToArray));
    CheckAndClearException(env);

    jsize size = env->GetArrayLength(jExts);
    BOOL isHeading = TRUE; // extension without semicolon

    JLString jExt(env, CreateJString(env, _T("")));
    JLString semicolon(env, CreateJString(env, _T(";")));

    for (int j = 0; j < size; j++) {
        if (!isHeading) {
            jExt.Attach( ConcatJStrings(env, jExt, semicolon) );
        }
        isHeading = FALSE;

        JLString jExtension(env, (jstring)env->GetObjectArrayElement(jExts, j));
        jExt.Attach( ConcatJStrings(env, jExt, jExtension) );
    }

    JString ext(env, jExt, false);
    return ext;
}
TEST(CSSTokenizerTest, CommentToken)
{
    TEST_TOKENS("/*comment*/a", ident("a"));
    TEST_TOKENS("/**\\2f**//", delim('/'));
    TEST_TOKENS("/**y*a*y**/ ", whitespace());
    TEST_TOKENS(",/* \n :) \n */)", comma(), rightParenthesis());
    TEST_TOKENS(":/*/*/", colon());
    TEST_TOKENS("/**/*", delim('*'));
    TEST_TOKENS(";/******", semicolon());
}
TEST(CSSTokenizerTest, SingleCharacterTokens)
{
    TEST_TOKENS("(", leftParenthesis());
    TEST_TOKENS(")", rightParenthesis());
    TEST_TOKENS("[", leftBracket());
    TEST_TOKENS("]", rightBracket());
    TEST_TOKENS(",", comma());
    TEST_TOKENS(":", colon());
    TEST_TOKENS(";", semicolon());
    TEST_TOKENS(")[", rightParenthesis(), leftBracket());
    TEST_TOKENS("[)", leftBracket(), rightParenthesis());
    TEST_TOKENS("{}", leftBrace(), rightBrace());
    TEST_TOKENS(",,", comma(), comma());
}
Пример #4
0
 // FIXME: don't discard the qualifier in namespace definitions
 void Parser::namespaceDefinition(int flags, Qualifier* /*qual*/)
 {
     uint32_t pos = position();
     if (!(flags & (SFLAG_Function|SFLAG_Toplevel))) // no classes yet...
         compiler->syntaxError(pos, SYNTAXERR_KWD_NOT_ALLOWED, "namespace");
     eat(T_Identifier);
     Str * name = identifier();
     if (match(T_Assign)) {
         if (hd() == T_Identifier || hd() == T_StringLiteral)
             addNamespaceBinding(name, primaryExpression());
         else
             compiler->syntaxError(pos, SYNTAXERR_ILLEGAL_NAMESPACE);
     }
     else
         addNamespaceBinding(name, NULL);
     semicolon();
 }
Пример #5
0
		// FIXME: don't discard the qualifier in namespace definitions
		void Parser::namespaceDefinition(int flags, Qualifier* /*qual*/)
		{
			uint32_t pos = position();
			if (!(flags & (SFLAG_Function|SFLAG_Toplevel)))	// no classes yet...
				compiler->syntaxError(pos, "'namespace' definition not allowed here");
			eat(T_Identifier);
			Str * name = identifier();
			if (match(T_Assign)) {
				if (hd() == T_Identifier || hd() == T_StringLiteral)
					addNamespaceBinding(name, primaryExpression());
				else
					compiler->syntaxError(pos, "Illegal 'namespace' definition");
			}
			else
				addNamespaceBinding(name, NULL);
			semicolon();
		}
Пример #6
0
        void Parser::includeDirective()
        {
            eat(T_Identifier);
            Str* newFile = stringValue();
            uint32_t pos = position();
            eat(T_StringLiteral);
            semicolon();
            if (!compiler->origin_is_file)
                compiler->syntaxError(pos, SYNTAXERR_INCLUDE_ORIGIN);
            
            // The current lexer state - including the state variables that are a part of the
            // parser object - gets pushed onto a stack, a new lexer is created for the new
            // input, and is installed.  Then we return, the caller must continue parsing as
            // if nothing had happened.  When the current lexer sees EOS it calls onEOS()
            // on the parser, which pops the lexer stack and generates a token from the popped
            // lexer.  The normal token processing path does not slow down at all and the
            // machinery is almost entirely transparent to the parser.
            
            pushLexerState();
            T0 = T1 = T_LAST;
            LP = L0 = L1 = 0;

            uint32_t inputlen;
            const wchar* input = compiler->context->readFileForEval(compiler->filename, newFile->s, &inputlen);
            if (input == NULL)
                compiler->syntaxError(pos, SYNTAXERR_INCLUDE_INACCESSIBLE);
            
            included_input = input;     // freed in onEOS below
#ifdef DEBUG
            bool doTrace = lexer->getTrace();
#endif
            lexer = ALLOC(Lexer, (compiler, input, inputlen));
#ifdef DEBUG
            if (doTrace) lexer->trace();
#endif
            start();
        }
Пример #7
0
void	ft_doublecoms(t_env *env, t_main *w)
{
	char		**coms;
	int 		i;

	i = 0;
	coms = NULL;
	w->line = NULL;
	ft_selectinit(w);
	while (ft_select(w, &w->line))
		;
	ft_selectend(w);
	w = ft_keep_main(*w, 0);
	if (ft_strchr(w->line, '>') != 0 || ft_strchr(w->line, '<') != 0)
		ft_redirect(w, env);
	if (ft_strchr(w->line, ';') == 0 && ft_strchr(w->line, '|') == 0)
		ft_minishell(env, w);
	else if (ft_strchr(w->line, '|') == 0 && ft_strchr(w->line, ';') != 0)
		semicolon(w, env, coms);
	else if (ft_strchr(w->line, '|') != 0)
		com_pipes(w, env, coms);
	if (i == 0)
		ft_doublecoms(env, w);
}
Пример #8
0
// Returns the next token in the character stream.
// If no next token can be identified, an error
// is emitted and we return the error token.
Token
Lexer::scan()
{
  // Keep consuming characters until we find
  // a token.
  while (true) {
    space();

    // Update the position of the current source location.
    // This denotes the beginning of the current token.
    loc_ = in_.location();

    switch (peek()) {
      case 0: return eof();

      case '{': return lbrace();
      case '}': return rbrace();
      case '(': return lparen();
      case ')': return rparen();
      case '[': return lbrack();
      case ']': return rbrack();
      case ',': return comma();
      case ':': return colon();
      case ';': return semicolon();
      case '.': return dot();
      case '+': return plus();
      case '-': return minus();
      case '*': return star();

      case '/':
        get();
        if (peek() == '/') {
          comment();
          continue;
        } else {
          return slash();
        }

      case '%': return percent();
      case '=': return equal();
      case '!': return bang();
      case '<': return langle();
      case '>': return rangle();
      case '&': return ampersand();
      case '|': return bar();
      case '^': return hat();

      case '0':
        // if the next character is a 'b' then this
        // is a binary literal
        if (peek(1) == 'b')
          return binary_integer();
        // if the next character is an 'x' then this
        // is a hexadecimal integer
        if (peek(1) == 'x')
          return hexadecimal_integer();
        // otherwise proceed to regular integer lexing
      case '1': case '2': case '3': case '4':
      case '5': case '6': case '7': case '8': case '9':
        return integer();

      case 'a': case 'b': case 'c': case 'd': case 'e':
      case 'f': case 'g': case 'h': case 'i': case 'j':
      case 'k': case 'l': case 'm': case 'n': case 'o':
      case 'p': case 'q': case 'r': case 's': case 't':
      case 'u': case 'v': case 'w': case 'x': case 'y':
      case 'z':
      case 'A': case 'B': case 'C': case 'D': case 'E':
      case 'F': case 'G': case 'H': case 'I': case 'J':
      case 'K': case 'L': case 'M': case 'N': case 'O':
      case 'P': case 'Q': case 'R': case 'S': case 'T':
      case 'U': case 'V': case 'W': case 'X': case 'Y':
      case 'Z':
      case '_':
        return word();

      case '\'': return character();
      case '"': return string();

      default:
        return error();
    }
  }
}