コード例 #1
0
ファイル: tl-parallel_for.cpp プロジェクト: drpicox/acotescc
        void OpenMPTransform::parallel_for_preorder(OpenMP::ParallelForConstruct parallel_for_construct)
        {
            ObjectList<OpenMP::ReductionSymbol> inner_reductions;
            inner_reductions_stack.push(inner_reductions);

            // Increase the parallel nesting value
            parallel_nesting++;

            common_parallel_data_sharing_code(parallel_for_construct);

            Statement construct_body = parallel_for_construct.body();
            // The construct is in fact a ForStatement in a #pragma omp parallel for
            ForStatement for_statement(construct_body);

            // The induction variable deserves special treatment
            Symbol induction_var = for_statement.get_induction_variable().get_symbol();
            induction_var_stack.push(induction_var);

            // Set it private if it was not
            if ((parallel_for_construct.get_data_attribute(induction_var) & OpenMP::DA_PRIVATE) != OpenMP::DA_PRIVATE)
            {
                ObjectList<Symbol>& private_references = 
                    parallel_for_construct.get_data<ObjectList<Symbol> >("private_references");
                // Set private
                parallel_for_construct.add_data_attribute(induction_var, OpenMP::DA_PRIVATE);

                // And insert into private references as well
                private_references.insert(induction_var);

                ObjectList<Symbol>& shared_references = 
                    parallel_for_construct.get_data<ObjectList<Symbol> >("shared_references");
                // Remove from shared references if it appears there
                shared_references = shared_references.not_find(induction_var);
            }
        }
コード例 #2
0
ファイル: grammer.cpp プロジェクト: bingone/my_compiler
/**
语句
<statement>::=<compound_statement>
            |<if_statement>
            |<return_statement>
            |<break_statement>
            |<continue_statement>
            |for_statement>
            <expression_statement>

*/
void statement(){
    switch(token){
        case TK_BEGIN:
            compound_statement();
            break;
        case KW_IF:
            if_statement();
            break;
        case KW_RETURN:
            return_statement();
            break;
        case KW_BREAK:
            break_statement();
            break;
        case KW_CONTINUE:
            continue_statement();
            break;
        case KW_FOR:
            for_statement();
            break;
        default:
            expression_statement();
            break;
    }
	get_token();	///
}
コード例 #3
0
ファイル: ubasic.c プロジェクト: CobooGuo/ubasic
/*---------------------------------------------------------------------------*/
static void
statement(void)
{
  int token;

  token = tokenizer_token();

  switch(token) {
  case TOKENIZER_PRINT:
    print_statement();
    break;
  case TOKENIZER_IF:
    if_statement();
    break;
  case TOKENIZER_GOTO:
    goto_statement();
    break;
  case TOKENIZER_GOSUB:
    gosub_statement();
    break;
  case TOKENIZER_RETURN:
    return_statement();
    break;
  case TOKENIZER_FOR:
    for_statement();
    break;
  case TOKENIZER_PEEK:
    peek_statement();
    break;
  case TOKENIZER_POKE:
    poke_statement();
    break;
  case TOKENIZER_NEXT:
    next_statement();
    break;
  case TOKENIZER_END:
    end_statement();
    break;
  case TOKENIZER_LET:
    accept(TOKENIZER_LET);
    /* Fall through. */
  case TOKENIZER_VARIABLE:
    let_statement();
    break;
  default:
    DEBUG_PRINTF("ubasic.c: statement(): not implemented %d\n", token);
    exit(1);
  }
}
コード例 #4
0
ファイル: cp_statement.c プロジェクト: AndresGG/sn-8.4
static Boolean_t statement( void )
{
/*    printf( "statement: %s\n", ident( 0 )); */
   switch( token( 0 ))
   {
   case ';'         : step( 1 ); return True;
   case '{'         : return compound_statement();
   case SN_CASE     : return case_statement();
   case SN_DEFAULT  : return default_statement();
   case SN_IF       : return if_statement();
   case SN_ELSE     : return else_statement();
   case SN_SWITCH   : return switch_statement();
   case SN_WHILE    : return while_statement();
   case SN_DO       : return do_statement();
   case SN_FOR      : return for_statement();
   case SN_BREAK    : return break_statement();
   case SN_CONTINUE : return continue_statement();
   case SN_RETURN   : return return_statement();
   case SN_THROW    : return throw_statement();
   case SN_GOTO     : return goto_statement();
   case SN_TRY      : return try_statement();

   case SN_IDENTIFIER:
      if( labeled_statement     ()) return True;
      if( declaration_statement1()) return True;
      if( expression_statement  ()) return True;
      if( declaration_statement2()) return True;
      step( 1 );
      return False;

   case SN_CHAR     :
   case SN_SHORT    :
   case SN_INT      :
   case SN_LONG     :
   case SN_SIGNED   :
   case SN_UNSIGNED :
   case SN_FLOAT    :
   case SN_DOUBLE   :
   case SN_BOOL     :
   case SN_VOID     :
      if( declaration_statement1()) return True;
      if( expression_statement  ()) return True;
      if( declaration_statement2()) return True;
      step( 1 );
      return False;

   case SN_ASM      :
   case SN_TEMPLATE :
   case SN_NAMESPACE:
   case SN_USING    :
   case SN_AUTO     :
   case SN_REGISTER :
   case SN_EXTERN   :
   case SN_STATIC   :
   case SN_INLINE   :
   case SN_VIRTUAL  :
   case SN_CONST    :
   case SN_VOLATILE :
   case SN_CLASS    :
   case SN_STRUCT   :
   case SN_UNION    :
   case SN_ENUM     :
   case SN_FRIEND   :
   case SN_TYPEDEF  :
      if( declaration_statement1()) return True;
      if( declaration_statement2()) return True;
      f_StepTo( ';', '}', 0 );
      return False;

   case SN_SIZEOF :
   case SN_NEW :
   case SN_DELETE :
   case SN_THIS :
   case SN_OPERATOR :
   case SN_STRINGliteral :
   case SN_FLOATINGconstant :
   case SN_INTEGERconstant :
   case SN_LONGconstant :
   case SN_CHARACTERconstant :
   case SN_ICR :
   case SN_DECR :
   case SN_CLCL :
   case '(':
   case '~':
   case '*':
   case '&':
   case '+':
   case '-':
   case '!':
      if( expression_statement ()) return True;
      step( 1 );
      return False;

   case 0:
      printf( "unexpected end of file\n" );
      return False;

   default:
#ifdef PRINT_STATEMENT_DEFAULT
      printf( "statement: default: %4d %s file: %s:(%d.%d)\n"
            , token( 0 )
            , ident( 0 )
            , filename_g
            , f_lineno( 0 )
            , f_charno( 0 )
            );
#endif
#ifdef BREAK_BY_STATEMENT_DEFAULT
      exit( -1 );
#endif
      if( declaration_statement1()) return True;
      if( expression_statement  ()) return True;
      if( declaration_statement2()) return True;
      step( 1 );
      return False;

/*    case SN_ARROW : */
/*    case SN_LS : */
/*    case SN_RS : */
/*    case SN_LE : */
/*    case SN_GE : */
/*    case SN_EQ : */
/*    case SN_NE : */
/*    case SN_ANDAND : */
/*    case SN_OROR : */
/*    case SN_ELLIPSIS : */
/*    case SN_DOTstar : */
/*    case SN_ARROWstar : */
/*    case SN_MULTassign : */
/*    case SN_DIVassign : */
/*    case SN_MODassign : */
/*    case SN_PLUSassign : */
/*    case SN_MINUSassign : */
/*    case SN_LSassign : */
/*    case SN_RSassign : */
/*    case SN_ANDassign : */
/*    case SN_ERassign : */
/*    case SN_ORassign : */
/*    case '=' : */
/*    case '|' : */
/*    case '^' : */
/*    case '&' : */
/*    case '<' : */
/*    case '>' : */
/*    case '/' : */
/*    case '%' : */
/*    case ')' : */
/*    case '[' : */
/*    case ']' : */
/*    case '.' : */
/*    case ',' : */
/*    case '{' : */
/*    case '}' : */
/*    case '?' : */
/*    case ':' : */
   }
}
コード例 #5
0
ファイル: ubasic.c プロジェクト: EtchedPixels/ubasic
/*---------------------------------------------------------------------------*/
static uint8_t statement(void)
{
  int token;

  string_temp_free();

  token = current_token;
  /* LET may be omitted.. */
  if (token != TOKENIZER_INTVAR && token != TOKENIZER_STRINGVAR)
    accept_tok(token);

  switch(token) {
  case TOKENIZER_QUESTION:
  case TOKENIZER_PRINT:
    print_statement();
    break;
  case TOKENIZER_IF:
    if_statement();
    break;
  case TOKENIZER_GO:
    go_statement();
    return 0;
  case TOKENIZER_RETURN:
    return_statement();
    break;
  case TOKENIZER_FOR:
    for_statement();
    break;
  case TOKENIZER_POKE:
    poke_statement();
    break;
  case TOKENIZER_NEXT:
    next_statement();
    break;
  case TOKENIZER_STOP:
    stop_statement();
    break;
  case TOKENIZER_REM:
    rem_statement();
    break;
  case TOKENIZER_DATA:
    data_statement();
    break;
  case TOKENIZER_RANDOMIZE:
    randomize_statement();
    break;
  case TOKENIZER_OPTION:
    option_statement();
    break;
  case TOKENIZER_INPUT:
    input_statement();
    break;
  case TOKENIZER_RESTORE:
    restore_statement();
    break;
  case TOKENIZER_DIM:
    dim_statement();
    break;
  case TOKENIZER_CLS:
    cls_statement();
    break;
  case TOKENIZER_LET:
  case TOKENIZER_STRINGVAR:
  case TOKENIZER_INTVAR:
    let_statement();
    break;
  default:
    DEBUG_PRINTF("ubasic.c: statement(): not implemented %d\n", token);
    syntax_error();
  }
  return 1;
}
コード例 #6
0
        void OpenMPTransform::parallel_for_postorder(PragmaCustomConstruct parallel_for_construct)
        {
            // One more parallel seen
            num_parallels++;

            // Decrease the parallel nesting level 
            parallel_nesting--;

            // Get the enclosing function definition
            FunctionDefinition function_definition = parallel_for_construct.get_enclosing_function();
            Scope function_scope = function_definition.get_scope();
            IdExpression function_name = function_definition.get_function_name();

            // This was computed in the preorder
            ObjectList<Symbol>& shared_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("shared_references");
            ObjectList<Symbol>& private_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("private_references");
            ObjectList<Symbol>& firstprivate_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("firstprivate_references");
            ObjectList<Symbol>& lastprivate_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("lastprivate_references");
            ObjectList<OpenMP::ReductionSymbol>& reduction_references =
                parallel_for_construct.get_data<ObjectList<OpenMP::ReductionSymbol> >("reduction_references");
            ObjectList<Symbol>& copyin_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("copyin_references");
            ObjectList<Symbol>& copyprivate_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("copyprivate_references");

            // Get the construct_body of the statement
            Statement construct_body = parallel_for_construct.get_statement();
            // The construct is in fact a ForStatement in a #pragma omp parallel do
            ForStatement for_statement(construct_body);
            Statement loop_body = for_statement.get_loop_body();

            // Create the replacement map and the pass_by_pointer set
            ObjectList<ParameterInfo> parameter_info_list;
            ReplaceIdExpression replace_references = 
                set_replacements(function_definition,
                        loop_body,
                        shared_references,
                        private_references,
                        firstprivate_references,
                        lastprivate_references,
                        reduction_references,
                        inner_reductions_stack.top(),
                        copyin_references,
                        copyprivate_references,
                        parameter_info_list);

            // Get the outline function name
            Source outlined_function_name = get_outlined_function_name(function_name);

            // Create the outline for parallel for
            AST_t outline_code = get_outline_parallel_for(
                    parallel_for_construct,
                    function_definition,
                    outlined_function_name, 
                    for_statement,
                    loop_body,
                    replace_references,
                    parameter_info_list,
                    private_references,
                    firstprivate_references,
                    lastprivate_references,
                    reduction_references,
                    copyin_references,
                    copyprivate_references);

            // Now prepend the outline
            function_definition.get_ast().prepend_sibling_function(outline_code);

            PragmaCustomClause if_clause = parallel_for_construct.get_clause("if");
            PragmaCustomClause num_threads = parallel_for_construct.get_clause("num_threads");
            PragmaCustomClause groups_clause = parallel_for_construct.get_clause("groups");

            Source instrument_code_before;
            Source instrument_code_after;

            AST_t spawn_code = get_parallel_spawn_code(
                    parallel_for_construct.get_ast(),
                    function_definition,
                    parallel_for_construct.get_scope(),
                    parallel_for_construct.get_scope_link(),
                    parameter_info_list,
                    reduction_references,
                    if_clause,
                    num_threads,
                    groups_clause,
                    instrument_code_before,
                    instrument_code_after
                    );

            // Discard inner reduction information
            inner_reductions_stack.pop();

            // Replace all the whole construct with spawn_code
            parallel_for_construct.get_ast().replace(spawn_code);
        }
コード例 #7
0
ファイル: grammar_parser.cpp プロジェクト: flysnowxg/sil
//未略过第一个符号
void grammar_parser::statement(set<e_word_t> follows,int& stk_index,while_context* p_while_conext)
{
	word tmp=m_words.get();
	if(tmp.m_type==ewt_ident)
	{
		m_words.push(tmp);
		if(m_expression_begs.find(tmp.m_type)!=m_expression_begs.end())
		{
			expression(_create_syms(follows,ewt_key_assign),stk_index);
			gen_pop_instruction(stk_index);
			word semicolon=m_words.get();
			if(semicolon.m_type!=ewt_key_semicolon)
			{
				report_error("语法错误:语句应以 ;结束\n");
				m_words.push(semicolon);
			}
			else grammar_debug(semicolon);
		}
	}
	else if(m_expression_begs.find(tmp.m_type)!=m_expression_begs.end())
	{
		m_words.push(tmp);
		expression(follows,stk_index);
		gen_pop_instruction(stk_index);
		word semicolon=m_words.get();
		if(semicolon.m_type!=ewt_key_semicolon) 
		{
			report_error("语法错误:语句应以 ;结束\n");
			m_words.push(semicolon);
		}
		else grammar_debug(semicolon);
	}
	else if(tmp.m_type==ewt_key_if)
	{
		grammar_debug(tmp);
		if_statement(follows,stk_index,p_while_conext);
	}
	else if(tmp.m_type==ewt_key_while)
	{
		grammar_debug(tmp);
		while_statement(follows,stk_index);
	}
	else if(tmp.m_type==ewt_key_for)
	{
		grammar_debug(tmp);
		for_statement(follows,stk_index);
	}
	else if(tmp.m_type==ewt_key_break)
	{
		grammar_debug(tmp);
		if(p_while_conext==NULL)
		{
			report_error("语法错误:不在循环中,此处不应有break;\n");
		}
		else 
		{
			gen_code(e_pop,eab_invalid,0,stk_index-p_while_conext->m_begin_stk_index);
			p_while_conext->breaks.push_back(gen_code(e_jmp,eab_relat_ip,0,0));
		}
		if(m_words.check(ewt_key_semicolon)) m_words.get();
		else 
		{
			report_error("语法错误:break语句缺少分号\n");
		}
	}
	else if(tmp.m_type==ewt_key_continue)
	{
		grammar_debug(tmp);
		if(p_while_conext==NULL)
		{
			report_error("语法错误:不在循环中,此处不应有continue;\n");
		}
		else 
		{
			gen_code(e_pop,eab_invalid,0,stk_index-p_while_conext->m_begin_stk_index);
			p_while_conext->continues.push_back(gen_code(e_jmp,eab_relat_ip,0,0));
		}
		if(m_words.check(ewt_key_semicolon)) m_words.get();
		else 
		{
			report_error("语法错误:break语句缺少分号\n");
		}
	}
	else if(tmp.m_type==ewt_key_return)
	{
		grammar_debug(tmp);
		return_statement(follows,stk_index);
	}
	else if(tmp.m_type==ewt_key_semicolon)
	{
		grammar_debug(tmp);
	}
	else 
	{
		m_words.push(tmp);
		test_and_skip(follows,_create_syms());
	}
}
コード例 #8
0
ファイル: ubasic.c プロジェクト: mizuki-tohru/stm32f4-console
//static void statement(void)
void statement(void)
{
	int token;
	token = tokenizer_token();

	switch(token) {
		case TOKENIZER_PRINT:
			print_statement();
			break;
		case TOKENIZER_IF:
			if_statement();
			break;
		case TOKENIZER_GOTO:
			goto_statement();
			break;
		case TOKENIZER_GOSUB:
			gosub_statement();
			break;
		case TOKENIZER_RETURN:
			return_statement();
			break;
		case TOKENIZER_FOR:
			for_statement();
			break;
		case TOKENIZER_NEXT:
			next_statement();
			break;
		case TOKENIZER_END:
			end_statement();
			break;
		case TOKENIZER_PSET:
			pset_statement();
			break;
		case TOKENIZER_CLS:
			cls_statement();
			break;
		case TOKENIZER_REFRESH:
			refresh_statement();
			break;
		case TOKENIZER_LIST:
			list_statement();
			break;
		case TOKENIZER_LOAD:
			load_statement();
			break;
		case TOKENIZER_SAVE:
			save_statement();
			break;
		case TOKENIZER_FILES:
			files_statement();
			break;
		case TOKENIZER_PEEK:
			peek_statement();
			break;
		case TOKENIZER_POKE:
			poke_statement();
			break;
		case TOKENIZER_WAIT:
			wait_statement();
			break;
		case TOKENIZER_INPUT:
			input_statement();
			break;
		case TOKENIZER_INP:
			inp_statement();
			break;
		case TOKENIZER_INR:
			inr_statement();
			break;
		case TOKENIZER_INA:
			ina_statement();
			break;
		case TOKENIZER_REM:
			rem_statement();
			break;
		case TOKENIZER_RUN:
			run_statement();
			break;
		case TOKENIZER_ERROR:
			tokenizer_error_print();
			ended = 1;
			glcd_DrawCursor();
			break;
		case TOKENIZER_LET:
			accept(TOKENIZER_LET);
			accept(TOKENIZER_VARIABLE);
			accept(TOKENIZER_CR);
			break;
			/* Fall through. */
		case TOKENIZER_VARIABLE:
			let_statement();
			break;
		default:
			exit(1);
	}
}
コード例 #9
0
ファイル: tl-parallel_for.cpp プロジェクト: drpicox/acotescc
        void OpenMPTransform::parallel_for_postorder(OpenMP::ParallelForConstruct parallel_for_construct)
        {
            // One more parallel seen
            num_parallels++;

            // Remove the induction var from the stack
            induction_var_stack.pop();

            // Decrease the parallel nesting level 
            parallel_nesting--;

            // Get the directive
            OpenMP::Directive directive = parallel_for_construct.directive();

            // Get the enclosing function definition
            FunctionDefinition function_definition = parallel_for_construct.get_enclosing_function();
            Scope function_scope = function_definition.get_scope();
            IdExpression function_name = function_definition.get_function_name();

            // This was computed in the preorder
            ObjectList<Symbol>& shared_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("shared_references");
            ObjectList<Symbol>& private_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("private_references");
            ObjectList<Symbol>& firstprivate_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("firstprivate_references");
            ObjectList<Symbol>& lastprivate_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("lastprivate_references");
            ObjectList<OpenMP::ReductionSymbol>& reduction_references =
                parallel_for_construct.get_data<ObjectList<OpenMP::ReductionSymbol> >("reduction_references");
            ObjectList<Symbol>& copyin_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("copyin_references");
            ObjectList<Symbol>& copyprivate_references = 
                parallel_for_construct.get_data<ObjectList<Symbol> >("copyprivate_references");

            // Get the construct_body of the statement
            Statement construct_body = parallel_for_construct.body();
            // The construct is in fact a ForStatement in a #pragma omp parallel do
            ForStatement for_statement(construct_body);
            Statement loop_body = for_statement.get_loop_body();

            // Create the replacement map and the pass_by_pointer set
            ObjectList<ParameterInfo> parameter_info_list;
            ReplaceIdExpression replace_references = 
                set_replacements(function_definition,
                        directive,
                        loop_body,
                        shared_references,
                        private_references,
                        firstprivate_references,
                        lastprivate_references,
                        reduction_references,
                        inner_reductions_stack.top(),
                        copyin_references,
                        copyprivate_references,
                        parameter_info_list);

            // Get the outline function name
            Source outlined_function_name = get_outlined_function_name(function_name);

            // Create the outline for parallel for
            AST_t outline_code = get_outline_parallel_for(
                    parallel_for_construct,
                    function_definition,
                    outlined_function_name, 
                    for_statement,
                    loop_body,
                    replace_references,
                    parameter_info_list,
                    private_references,
                    firstprivate_references,
                    lastprivate_references,
                    reduction_references,
                    copyin_references,
                    copyprivate_references,
                    directive);

            // Now prepend the outline
            function_definition.get_ast().prepend_sibling_function(outline_code);

            OpenMP::Clause num_threads = directive.num_threads_clause();
            OpenMP::CustomClause groups_clause = directive.custom_clause("groups");

            Source instrument_code_before;
            Source instrument_code_after;
            if (instrumentation_requested())
            {
                instrument_code_before
                    << "const int EVENT_PARALLEL = 60000001;"
                    << "const int VALUE_PARALLEL_FOR = 1;"
                    << "mintaka_event(EVENT_PARALLEL, VALUE_PARALLEL_FOR);"
                    << "mintaka_state_schedule();"
                    ;
                instrument_code_after
                    << "const int VALUE_PARALLEL_CLOSE = 0;"
                    << "mintaka_event(EVENT_PARALLEL, VALUE_PARALLEL_CLOSE);"
                    << "mintaka_state_run();"
                    ;
            }

            AST_t spawn_code = get_parallel_spawn_code(
                    parallel_for_construct.get_ast(),
                    function_definition,
                    parallel_for_construct.get_scope(),
                    parallel_for_construct.get_scope_link(),
                    parameter_info_list,
                    reduction_references,
                    num_threads,
                    groups_clause,
                    instrument_code_before,
                    instrument_code_after
                    );

            // Discard inner reduction information
            inner_reductions_stack.pop();

            // Replace all the whole construct with spawn_code
            parallel_for_construct.get_ast().replace(spawn_code);
        }