Exemplo n.º 1
0
int main(int argc, char * argv[])
{
  CandlProgram * program;
  CandlOptions * options;
  CandlDependence * dependence;
  CandlViolation * violation = NULL;
  FILE * input, * output;

  /* Options and input/output file setting. */
  candl_options_read(argc, argv, &input, &output, &options);

  /* Reading the program informations. */
#ifdef CANDL_SUPPORTS_SCOPLIB
  if (options->readscop)
    program = candl_program_read_scop(input);
  else if (options->scoptocandl)
    {
      program = candl_program_read_scop(input);
      candl_program_print_candl_file(output, program);
      candl_program_free(program);
      candl_options_free(options);
      return 0;
    }
  else
#endif
    program = candl_program_read(input);

  /* Calculating dependences. */
  dependence = candl_dependence(program, options);

  /* Calculating legality violations. */
  if (options->violgraph)
    violation = candl_violation(program, dependence, options);

  /* Printing data structures if asked. */
  if (options->structure)
    {
      fprintf(output, "Program:\n");
      candl_program_print(output, program);
      fprintf(output, "\nDependences:\n");
      candl_dependence_print(output, dependence);
      fprintf(output, "\nViolations:\n");
      candl_violation_print(output, violation);
    }

#ifdef CANDL_SUPPORTS_SCOPLIB
  if (options->readscop && options->writescop)
    candl_dependence_print_scop (input, output, dependence);
  else
    {
#endif
      /* Printing dependence graph if asked or if there is no transformation. */
      if (options->depgraph || (program->transformation == NULL))
	{
	  candl_dependence_pprint(output, dependence);
	  if (options->view)
	    candl_dependence_view(dependence);
	}
      /* Printing violation graph if asked and if there is a transformation. */
      if (options->violgraph && (program->transformation != NULL))
	{
	  candl_violation_pprint(output, violation);
	  if (options->view)
	    candl_violation_view(violation);
	}
#ifdef CANDL_SUPPORTS_SCOPLIB
    }
#endif

  /* Being clean. */
  candl_violation_free(violation);
  candl_dependence_free(dependence);
  candl_program_free(program);
  candl_options_free(options);
  pip_close();
  fclose(input);
  fclose(output);

  return 0;
}
Exemplo n.º 2
0
Arquivo: clay.c Projeto: periscop/clay
int main(int argc, char * argv[]) {

  osl_scop_p scop = NULL;
  osl_generic_p x, last;
  osl_clay_p clay_tag;
  clay_options_p options;
  int parsing_result = 0;

  // Read command line parameters
  options = clay_options_read(argc, argv);
  if (options->print_infos) {
    clay_options_free(options);
    exit(0);
  }

  // Open the scop file
  #ifdef CLAN_LINKED
  if (options->readc) {
    clan_options_p clan_opt = clan_options_malloc();
		clan_opt->precision = OSL_PRECISION_MP;
		clan_opt->name = options->input_name;
		clan_opt->extbody = 1;
    scop = clan_scop_extract(options->input, clan_opt);
    //clan_options_free(clan_opt); // bug, the name is also freed
    free(clan_opt);
    fclose(options->input);
  }
  else
  #endif
  {
    scop = osl_scop_read(options->input);
    if (options->input != stdin)
      fclose(options->input);
  }

  if (options->normalize) {
    clay_beta_normalize(scop);
  }

#if defined(CANDL_LINKED)
  osl_scop_p orig_scop = NULL;
  if (!options->nocandl && scop != NULL) {
          orig_scop = osl_scop_clone(scop);
  }
#endif
  
  // Execute the script ...
  // do nothing if the scop is NULL
  if (scop != NULL) {
    // Read the script file
    if (!options->from_tag) {
      parsing_result = clay_parser_file(scop, options->script, options);
      if (parsing_result != 0) {
        fprintf(stderr, "[Clay] %s\n", clay_get_error_message());
      }
      fclose(options->script);
    
    // Read the script from the extension clay
    } else {
      // equivalent to osl_generic_lookup, but we need the last extension
      // to remove the clay extension in the list
      x = scop->extension;
      last = NULL;
      while (x != NULL) {
        if (osl_generic_has_URI(x, OSL_URI_CLAY))
          break;
        last = x;
        x = x->next;
      }
     
      if (x != NULL) {
        // parse the clay string
        clay_tag = x->data;
        parsing_result = clay_parser_string(scop, clay_tag->script, options);
        if (parsing_result != 0) {
          fprintf(stderr, "[Clay] %s\n", clay_get_error_message());
        }

        // remove the extension clay
        osl_generic_remove(&scop->extension, OSL_URI_CLAY);
      }
    }
  }

#ifdef CANDL_LINKED
  int is_violated = 0;
  // Check dependencies
  if (!options->nocandl && scop != NULL && parsing_result == 0) {
    candl_options_p candl_opt = candl_options_malloc();
    if (options->candl_fullcheck)
      candl_opt->fullcheck = 1;
    candl_scop_usr_init(orig_scop);
    candl_violation_p violation = 
        candl_violation(orig_scop, scop, 0, candl_opt);

    is_violated = (violation != NULL);
    if (is_violated) {
      candl_violation_pprint(stdout, violation);
      if (options->candl_structure)
        candl_violation_dump(stdout, violation);
    }

    candl_scop_usr_cleanup(orig_scop);
    candl_options_free(candl_opt);
    candl_violation_free(violation);
    osl_scop_free(orig_scop);
  }

  if (!is_violated) // print the scop or the .c file by cloog
#endif
	
	{
    #ifdef CLOOG_LINKED
		if (options->printc && scop != NULL && parsing_result == 0) {
      clay_util_scop_export_body(scop);

			CloogState *state = cloog_state_malloc();
			CloogOptions *cloogoptions = cloog_options_malloc(state);
			cloogoptions->openscop = 1;
			CloogInput *clooginput = cloog_input_from_osl_scop(cloogoptions->state, 
                                                         scop);
			cloog_options_copy_from_osl_scop(scop, cloogoptions);
			CloogProgram *program = cloog_program_alloc(clooginput->context, 
					                            clooginput->ud, cloogoptions);
			free(clooginput);
			cloog_program_generate(program, cloogoptions);
			
			cloog_program_pprint(stdout, program, cloogoptions);
			cloog_program_free(program);
			cloogoptions->scop = NULL; // don't free the scop
			cloog_options_free(cloogoptions);
			cloog_state_free(state);
		}
		else
		#endif
		{
                  if (parsing_result == 0) {
      if (!options->keep_extbody)
        clay_util_scop_export_body(scop);

			osl_scop_print(stdout, scop);
                  }
		}
	}

  osl_scop_free(scop);
  clay_options_free(options);

  return parsing_result;
}