예제 #1
0
파일: test00.c 프로젝트: dgu123/dc-lib
int main() {

    dc_init();

    rm_make_dump_file("test00-start-"OPT".log");

    int* p = (int*)dc_malloc(sizeof(int));

    dc_begin_at();

    dc_dump_cell(stdout, p);

    *p = 10;        // write reactive cell

    dc_dump_cell(stdout, p);

    dc_end_at();

/*
    int x = *p;     // read reactive cell

    printf("x = %d\n", x);
*/

    //dc_free(p);

    //rm_make_dump_file("test00-end-"OPT".log");

    return 0;
}
예제 #2
0
int main(int argc, char* argv[]) {
    // Start the Dark Core Reactor!    
    dc_init(640, 480);

    world = dc_world_create();
    generate_map(&world);
    
    dc_object obj = dc_object_create();
    dc_object_set_x(&obj, 10);
    dc_object_set_y(&obj, 1);
    dc_object_set_on_key_press(&obj, obj_on_key_press);
    
    dc_world_add_object(&world, &obj);
    
    // Load the texture
    struct dc_texture tex;
    dc_texture_create(&tex, "resources/grass-tiles-2-small.png", "png");
    dc_world_add_texture(&world, &tex);
    
    // Map tiles to texture 
    dc_tile t1, t2, t3;
    dc_texture_map(&world, &t1, "Grass", 0, 0, 6, 2, 0);
    dc_world_add_tile(&world, &t1);
    dc_texture_map(&world, &t2, "Grass", 5, 0, 6, 2, 0);
    dc_world_add_tile(&world, &t2);
    dc_texture_map(&world, &t3, "Dirt", 4, 0, 6, 2, 1);
    dc_world_add_tile(&world, &t3);
    
    dc_run(&world);
            
    dc_texture_destory(&tex);

    return 0;
}
예제 #3
0
// ---------------------------------------------------------------------
//  main
// ---------------------------------------------------------------------
int main() {

    unsigned long long count = 0; // number of executed constraints

    puts("--starting program");

    dc_init();

#if MAKE_DUMP_FILE
    rm_make_dump_file("logs/"_sorter_name"-start.dump");
#endif

    srand(131);

#ifndef LARGE_TEST
    test_small(&count);
#else
    test_large(&count);
#endif

#if MAKE_DUMP_FILE
    rm_make_dump_file("logs/"_sorter_name"-end.dump");
#endif

    printf ("--total number of cached instructions executed = %u\n",
            g_stats.exec_cache_instr_count);

    return 0;
}
예제 #4
0
void dc_start(struct channel *sc)
{
	u32 val;

	if (!(sc->r.flags & SBE_2T3E3_FLAG_NETWORK_UP))
		return;

	dc_init(sc);

	/* get actual LOS and OOF status */
	switch (sc->p.frame_type) {
	case SBE_2T3E3_FRAME_TYPE_E3_G751:
	case SBE_2T3E3_FRAME_TYPE_E3_G832:
		val = exar7250_read(sc, SBE_2T3E3_FRAMER_REG_E3_RX_CONFIGURATION_STATUS_2);
		dev_dbg(&sc->pdev->dev, "Start Framer Rx Status = %02X\n", val);
		sc->s.OOF = val & SBE_2T3E3_FRAMER_VAL_E3_RX_OOF ? 1 : 0;
		break;
	case SBE_2T3E3_FRAME_TYPE_T3_CBIT:
	case SBE_2T3E3_FRAME_TYPE_T3_M13:
		val = exar7250_read(sc, SBE_2T3E3_FRAMER_REG_T3_RX_CONFIGURATION_STATUS);
		dev_dbg(&sc->pdev->dev, "Start Framer Rx Status = %02X\n", val);
		sc->s.OOF = val & SBE_2T3E3_FRAMER_VAL_T3_RX_OOF ? 1 : 0;
		break;
	default:
		break;
	}
	cpld_LOS_update(sc);

	/* start receive and transmit processes */
	dc_transmitter_onoff(sc, SBE_2T3E3_ON);
	dc_receiver_onoff(sc, SBE_2T3E3_ON);

	/* start interrupts */
	dc_start_intr(sc);
}
예제 #5
0
//
// Native thread that runs the actual nullDC emulator
//
static void *ThreadHandler(void *UserData)
{
  char *Args[3];
  const char *P;

  // Make up argument list
  P       = (const char *)UserData;
  Args[0] = "dc";
  Args[1] = "-config";
  Args[2] = P&&P[0]? (char *)malloc(strlen(P)+32):0;

  if(Args[2])
  {
    strcpy(Args[2],"config:image=");
    strcat(Args[2],P);
  }

  // Add additonal controllers
  for (int i = 0; i < 3; i++)
  {
    if (add_controllers[i])
      mcfg_Create(MDT_SegaController,i+1,5);
  }

  // Run nullDC emulator
  dc_init(Args[2]? 3:1,Args);
}
예제 #6
0
struct datacenter *
server_get_dc(struct server_pool *pool, struct string *dcname)
{
	struct datacenter *dc;
	uint32_t i, len;

	if (log_loggable(LOG_DEBUG)) {
		log_debug(LOG_DEBUG, "server_get_dc pool  '%.*s'",
				dcname->len, dcname->data);
	}

	for (i = 0, len = array_n(&pool->datacenters); i < len; i++) {
		dc = (struct datacenter *) array_get(&pool->datacenters, i);
		ASSERT(dc != NULL);
		ASSERT(dc->name != NULL);

		if (string_compare(dc->name, dcname) == 0) {
			return dc;
		}
	}

	dc = array_push(&pool->datacenters);
	dc_init(dc);
	string_copy(dc->name, dcname->data, dcname->len);

	if (log_loggable(LOG_DEBUG)) {
		log_debug(LOG_DEBUG, "server_get_dc pool about to exit  '%.*s'",
				dc->name->len, dc->name->data);
	}

	return dc;
}
예제 #7
0
파일: main.c 프로젝트: fillods/whdd
static int global_init(void) {
    int r;
    // TODO check all retcodes
    setlocale(LC_ALL, "");
    initscr();
    init_dialog(stdin, stdout);
    dialog_vars.item_help = 0;

    start_color();
    init_my_colors();
    noecho();
    cbreak();
    scrollok(stdscr, FALSE);
    keypad(stdscr, TRUE);

    clear_body();
    // init libdevcheck
    r = dc_init();
    assert(!r);
    RENDERER_REGISTER(sliding_window);
    RENDERER_REGISTER(whole_space);
    dc_log_set_callback(log_cb, NULL);
    r = atexit(global_fini);
    assert(r == 0);
    return 0;
}
예제 #8
0
파일: test07.c 프로젝트: kuettler/dc-lib
int main() {

    dc_init();

    rm_make_dump_file("test07-start-"OPT".log");

    volatile size_t*   size = dc_malloc(sizeof(size_t));
    node_t** head = dc_malloc(sizeof(node_t*));

    *size = 5;

    i_list* l = i_list_new((size_t*)size, head);

    *size = 3;

    *size = 9;

    *size = 0;

    *size = 13;

    i_list_delete(l);

    rm_make_dump_file("test07-end-"OPT".log");

    return 0;
}
예제 #9
0
void t3e3_init(struct channel *sc)
{
	cpld_init(sc);
	dc_reset(sc);
	dc_init(sc);
	exar7250_init(sc);
	exar7300_init(sc);
}
예제 #10
0
int main(int argc, wchar* argv[])
{
    //if (argc==2)
        //ndcid=atoi(argv[1]);

    if (setup_curses() < 0) die("failed to setup curses!\n");
#ifdef TARGET_PANDORA
    signal(SIGSEGV, clean_exit);
    signal(SIGKILL, clean_exit);
#endif

#if defined(USES_HOMEDIR) && HOST_OS != OS_DARWIN
    string home = (string)getenv("HOME");
    if(home.c_str())
    {
        home += "/.reicast";
        mkdir(home.c_str(), 0755); // create the directory if missing
        SetHomeDir(home);
    }
    else
        SetHomeDir(".");
#else
    SetHomeDir(".");
#endif

 /* #if defined(SUPPORT_X11)
        x11_keymap[113] = DPad_Left;
        x11_keymap[114] = DPad_Right;

        x11_keymap[111] = DPad_Up;
        x11_keymap[116] = DPad_Down;

        x11_keymap[52] = Btn_Y;
        x11_keymap[53] = Btn_X;
        x11_keymap[54] = Btn_B;
        x11_keymap[55] = Btn_A;

        x11_keymap[36] = Btn_Start;
    #endif */

    printf("Home dir is: %s\n",GetPath("/").c_str());

    common_linux_setup();

    SetupInput();

    settings.profile.run_counts=0;

    dc_init(argc,argv);

    dc_run();

#ifdef TARGET_PANDORA
    clean_exit(0);
#endif

    return 0;
}
예제 #11
0
void dc_restart(struct channel *sc)
{
	dev_warn(&sc->pdev->dev, "SBE 2T3E3: 21143 restart\n");

	dc_stop(sc);
	dc_reset(sc);
	dc_init(sc);	/* stop + reset + init */
	dc_start(sc);
}
예제 #12
0
void* emuthread(void* ) {
  printf("Emu thread starting up");
  char *Args[3];
  Args[0] = "dc";
  
	set_user_config_dir("/http");
	set_user_data_dir("/http");

  dc_init(1,Args);
  dc_run();

  return 0;
}
예제 #13
0
파일: RSort.cpp 프로젝트: dgu123/dc-lib
int main( int argc, char **argv )
{
	int i, j;
	
    dc_init ();
	
	//allocates vector...
	// max N is 1024...
    v=(int *)dc_malloc (4096);
	
	//allocates MyQGraphicsRectItem vector...
	vr=(MyQGraphicsRectItem **)malloc (N*sizeof (MyQGraphicsRectItem **));
	
	/*generates random seed...*/
	srand((unsigned)time (NULL));
	
	//fills vector with values...
	printf ("Generated vector: \n");
	for (i=0; i<N; i++)
	{
		/*generates random number in (0,1)...*/
		j = rand() % (N*N);
		//without this printf it won't work with -O2...
		//printf ("%d ", j); 
		v[i] = j;
	}
	printf ("\n");
	
	QApplication a( argc, argv );

	w=new MyWidget ();

	w->show();
	
	int ret_value=a.exec();
		
	//frees main page...
    dc_free (v);
	//frees MyQGraphicsRectItem vector...
	free (vr);
	
	//deallocates constraint parameter data structs...
	for (i=0; i<N; i++)
	{
		free (gDataArray[i]);
	}

	return ret_value;
} 
예제 #14
0
static void acpi_test(int ac, char **av)
{
    unsigned int i;
    unsigned int k;

    unsigned int sleep_gpio_save[13];
    ls1a_save_gpio_val(sleep_gpio_save);

    suspend_save();

    i = strtoul(av[1], 0, 0);
//	printf ("you set %d for test !\n", i);
    if (i & 1)
        *(volatile unsigned int *)0xbfe7c004 = 1 << 8;	//power button
    k = *(volatile unsigned int *)0xbfe7c024;
    k &= ~((1 << 8) | (1 << 9));
    *(volatile unsigned int *)0xbfe7c024 = (i & 0x3) << 8;	//[8:9]RI_EN、PME_EN
//	*(volatile unsigned int *)0xbfe7c008 = (1 << 13) | (5 << 10);	//sleep to ram
    flushcache();

    __asm__ volatile (
        "la	$2, 2f\n\t"
        "li	$3, 0xa01ffc00\n\t"
        "sw	$2, 0x0($3)\n\t"		//save return address
        "li	$2, 0xaffffe34\n\t"
        "lw	$3, 0x0($2)\n\t"
        "or	$3, 0x1\n\t"
        "sw	$3, 0x0($2)\n\t"	//enable ddr autorefresh
        "li	$2, 0xbfe7c008\n\t"
        "li	$3, (1<<13) | (5<<10)\n\t"
        "sw	$3, 0x0($2)\n\t"		//go to sleep
        "1:\n\t"
        "bal 1b\n\t"
        "nop\n\t"
        "2:\n\t"
        ::
        : "$2","$3","memory"
//			"move %0,$2\n\t"
//			: "=r" (p)
//			: "0" (p), "r" (len), "r" (1)
//			: "$2","$3","$4","$5"
    );

    ls1a_restore_gpio_val(sleep_gpio_save);
    dc_init();
    outstring("acpi resume back here !\n");
//	printf ("acpi resume back here !\n");

}
예제 #15
0
파일: main.c 프로젝트: Tinkerforge/dc-brick
int main() {
	const Pin pins_stack[] = {PINS_STACK};
	PIO_Configure(pins_stack, PIO_LISTSIZE(pins_stack));

	brick_hardware_version[0] = BRICK_HARDWARE_VERSION_MAJOR;
	brick_hardware_version[1] = BRICK_HARDWARE_VERSION_MINOR;
	brick_hardware_version[2] = BRICK_HARDWARE_VERSION_REVISION;

	brick_init();
	wdt_restart();

#ifdef PROFILING
    profiling_init();
#endif

    if(usb_is_connected()) {
    	logi("Configure as USB device\n\r");
    	usb_init();
    	wdt_restart();

    	xTaskCreate(usb_message_loop,
    				(signed char *)"usb_ml",
    				2000,
    				NULL,
    				1,
    				(xTaskHandle *)NULL);
    } else {
    	usb_first_connection = false;
    	logi("Configure as Stack Participant (SPI)\n\r");
        spi_stack_slave_init();
        wdt_restart();

    	xTaskCreate(spi_stack_slave_message_loop,
    			    (signed char *)"spi_ml",
    			    2500,
    			    NULL,
    			    1,
    			    (xTaskHandle *)NULL);
    }

	dc_init();
	wdt_restart();

	brick_init_start_tick_task();
	wdt_restart();

	vTaskStartScheduler();
}
예제 #16
0
파일: mpicnc.cpp 프로젝트: baskarang/icnc
// This is our CnC phase.
// We instantiate the dist_cnc_init object, put a number of tags and wait.
// The function can be called with different parameters.  We need the
// communicator in any case, but of course it can be MPI_Comm_World.
// If dist_env is true we do it the SPMD-way: every process, not only
// root, executes everything. If dist_env is false only the root
// executes things outside the dist_cnc_init constructor.
void cnc_phase( MPI_Comm mc, bool dist_env )
{
#ifdef _DIST_
    // Init distribution infrastructure (RAII), most likely behaves like a barrier
    // if dist_env==false client processes get blocked in here forever.
    CnC::dist_cnc_init< my_context > dc_init( mc, dist_env );
#endif

    // as we provided a communicator to dc_init, all processes
    // continue here (by default only rank 0 gets here)

    std::cout << "Let's go\n";
    // now let's get MPI rank etc.
    int numranks = 0;
    MPI_Comm_rank(mc,&rank);
    MPI_Comm_size(mc,&numranks);

    // The environment code should be executed on rank 0 and
    // on all client processes of a distributed environment.
    // We might have more than one rank 0
    // if different communicators are in use.
    // Multiple environments are semantically tricky, combined with
    // CnC they make sense if the MPI phase creates distributed
    // data to be used by CnC. We mimic this by distributing
    // the control-puts across all processes of a distributed env.
    if( rank == 0 || dist_env ) {
        // create the context, the runtime will distribute it under the hood
        my_context c;
        // dist_env requires a sync, e.g. a barrier
        if( dist_env ) MPI_Barrier( mc );
        // start tag, 0 if root
        int s = rank;
        // in a dist env each process puts a subset of tags
        // we do this by setting the loop-increment to the number
        // of processes in the env
        int inc = dist_env ? numranks : 1;
        // Simply put all (owned) control tags
        for (int number = s; number < N; number += inc) {
            c.m_tags.put(number);
        }
        // everyone in the env waits for quiescence
        c.wait();
        std::cout << "done\n";
    }
    // here the CnC distribution infrastructure gets shut down 
    // when the dist_cnc_init object gets destructed (RAII)
}
예제 #17
0
static int init(struct conduit *conduit)
{
    static int inited = 0;
    struct data *data;
    
    if(!inited)
    {
	dc_init();
	inited = 1;
    }
    data = smalloc(sizeof(*data));
    memset(data, 0, sizeof(*data));
    data->fd = -1;
    data->gdkread = data->gdkwrite = -1;
    conduit->cdata = data;
    return(0);
}
예제 #18
0
int CALLBACK WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShowCmd)
{
	ReserveBottomMemory();

	tick_thd.Start();

	int argc=0;
	wchar* cmd_line=GetCommandLineA();
	wchar** argv=CommandLineToArgvA(cmd_line,&argc);
	if(strstr(cmd_line,"NoConsole")==0)
	{
		if (AllocConsole())
		{
			freopen("CON","w",stdout);
			freopen("CON","w",stderr);
			freopen("CON","r",stdin);
		}
		SetConsoleCtrlHandler( (PHANDLER_ROUTINE) CtrlHandler, TRUE );
	}

	SetupPath();

	//SetUnhandledExceptionFilter(&ExeptionHandler);
	__try
	{
		int dc_init(int argc,wchar* argv[]);
		void dc_run();
		void dc_term();
		dc_init(argc,argv);

		#ifdef _WIN64
				setup_seh();
		#endif

		dc_run();
		dc_term();
	}
	__except( ExeptionHandler(GetExceptionInformation()) )
	{
		printf("Unhandled exception - Emulation thread halted...\n");
	}
	SetUnhandledExceptionFilter(0);

	return 0;
}
예제 #19
0
void digital_cam_uart_init(void)
{
  // Call common DC init
  dc_init();
  digital_cam_uart_thumbnails = 0;
  for (int t = 0; t < THUMB_COUNT; t++) {
    for (int i = 0; i < THUMB_MSG_SIZE; i++) {
      thumbs[t][i] = 0;
    }
  }
#if PERIODIC_TELEMETRY
  register_periodic_telemetry(&telemetry_Ap, "PAYLOAD", send_thumbnails);
#endif

#ifdef SITL
  serial_init("/dev/ttyUSB0");
#endif
}
예제 #20
0
int main(int argc, wchar* argv[])
{
	//if (argc==2) 
		//ndcid=atoi(argv[1]);

#if defined(USES_HOMEDIR)
	string home = (string)getenv("HOME");
	if(home.c_str())
	{
		home += "/.reicast";
		mkdir(home.c_str(), 0755); // create the directory if missing
		SetHomeDir(home);
	}
	else
		SetHomeDir(".");
#else
	SetHomeDir(".");
#endif

	printf("Home dir is: %s\n",GetPath("/").c_str());

	common_linux_setup();

	printf("common linux setup done\n");
	
	settings.profile.run_counts=0;
		
	dc_init(argc,argv);

	if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK|SDL_INIT_NOPARACHUTE)==-1)
	die("error initializing SDL");
	
	SetupInput();
	
	#ifdef USE_OSS	
		init_sound();
	#endif
	
	dc_run();
	
	clean_exit(0);

	return 0;
}
예제 #21
0
파일: ROthello2.cpp 프로젝트: dgu123/dc-lib
int main( int argc, char **argv )
{
	int i=0;
	int h, k;
	
	/*double avgAct=0.0;
	int maxAct=0;
	double avgFinalAct=0.0;
	int maxFinalAct=0;
	double avgTime=0.0;
	double maxTime=0.0;*/
	
	//initializes ww[][] (pointers to ellipses)...
	for (h=0; h<N; h++)
		for (k=0; k<N; k++)
			ww[h][k]=NULL;
	
    dc_init ();
	
	//allocates vector...
	// max N is 16...
	//v=(int *)LWP_AllocPages (1);
    //v=(int *)dc_malloc (4096);
    v=(int *)dc_malloc (N*N*sizeof (int));
	
	//installs constraints...
	for (h=0; h<N; h++)
		for (k=0; k<N; k++)
		{
			//we are assuming lots of things here...
			int theData=(h<<16)+k;
			
			//LCP_NewCons (GeneralConstraint, NULL, (void *)theData); 
            dc_new_cons (GeneralConstraint, (void *)theData, NULL);
		}
	
	//QApplication a( argc, argv );
    MyApplication a( argc, argv );

    w=new MyWidget ();

	//a.setMainWidget( w );
	w->show();
    
	//sets up board...
	_whiteMove (N/2-1, N/2-1);
	_whiteMove (N/2, N/2);
	_blackMove (N/2-1, N/2);
	_blackMove (N/2, N/2-1);
	gSetup=0;
	
	//just testing...
/*	printf ("\nInitial board:\n");
	_printBoard ();
	while (i<1)
	{
	int a, b;
	printf ("Black move:\ni: ");
	scanf ("%d", &a);
	printf ("j: ");
	scanf ("%d", &b);
	_blackMove (a, b);
	_printBoard ();
		
	printf ("White move:\ni: ");
	scanf ("%d", &a);
	printf ("j: ");
	scanf ("%d", &b);
	_whiteMove (a, b);
	_printBoard ();
	
	i++;
	}*/

    replayThread = new MyThread ();
	
	int ret_value=a.exec();
    
    delete replayThread;
	
	//LCP_CleanUp ();
	
	//frees main page...
	//LWP_FreePages ((void *)v, 1);
    dc_free (v);

	/*debugging...*/
	//printf ("\n[DEBUG] LMemory_GetBlocksCount() says: %u\n", (unsigned int)LMemory_GetBlocksCount ());

    // dump DC profiling info
    if (dc_profile_on()) 
        dc_dump_profile_diff(stdout, 
                             &log_array_prof[0], 
                             &log_array_prof[iter-1]);
    else {

        //computes avg and max resize evt processing time...
        elapsed_time_t avg;
        avg.real=0;
        avg.user=0;
        avg.system=0;
        avg.child_user=0;
        avg.child_system=0;
        
        double max=log_array[0].real;
        for (i=0; i<iter; i++)
        {
            avg.real=avg.real+log_array[i].real;
            avg.user=avg.user+log_array[i].user;
            avg.system=avg.system+log_array[i].system;
            avg.child_user=avg.child_user+log_array[i].child_user;
            avg.child_system=avg.child_system+log_array[i].child_system;
            
            if (log_array[i].real>max)
                max=log_array[i].real;
        }

        divide_elapsed_time_by(&avg, iter);
        printf ("\nTotal times per move:\n");
        printf ("Avg real = %f\n", avg.real);
        printf ("Avg user = %f\n", avg.user);
        printf ("Avg system = %f\n", avg.system);
        printf ("Avg child_user = %f\n", avg.child_user);
        printf ("Avg child_system = %f\n", avg.child_system);
        printf ("Max real = %f\n", max);
        
        avg.real=0;
        avg.user=0;
        avg.system=0;
        avg.child_user=0;
        avg.child_system=0;
        max=inter_array[1].real;
        for (i=0; i<iter; i++)
        {
            avg.real=avg.real+inter_array[i].real;
            avg.user=avg.user+inter_array[i].user;
            avg.system=avg.system+inter_array[i].system;
            avg.child_user=avg.child_user+inter_array[i].child_user;
            avg.child_system=avg.child_system+inter_array[i].child_system;
            
            if (inter_array[i].real>max)
                max=inter_array[i].real;
        }
        
        divide_elapsed_time_by(&avg, iter);
        printf ("\nPropagation times only:\n");
        printf ("Avg real = %f\n", avg.real);
        printf ("Avg user = %f\n", avg.user);
        printf ("Avg system = %f\n", avg.system);
        printf ("Avg child_user = %f\n", avg.child_user);
        printf ("Avg child_system = %f\n", avg.child_system);
        printf ("Max real = %f\n", max);
    }

	return ret_value;
} 
예제 #22
0
void atmega_i2c_cam_ctrl_init(void)
{
  dc_init();
}
예제 #23
0
int main ( int argc, char *argv[] )
/************************************************************************
 * DCTAF 								*
 *									*
 * This program decodes TAF reports and writes the output to a GEMPAK	*
 * surface forecast file.						*
 *									*
 *  Command line:							*
 *  dctaf [options] filename						*
 *	filename	output file name/template			*
 **									*
 * Log:									*
 * D. Kidwell/NCEP 	 9/02	Based on DCMETR                         *
 * A. Hardy/NCEP        12/02   Changed stn tbl sfstns.tbl->tafstn.tbl  *
 * m.gamazaychikov/SAIC 07/05   Added parameters to CS of dc_gopt       *
 * H. Zeng/SAIC		08/05	Added parameters to CS of dc_gopt	*
 * L. Lin/NCEP 		04/08	Modified fcst times from 24 to 30	*
 * L. Hinson/AWC        06/08   Added circflg to dc_gopt and call to    *
 *                              tf_dcod                                 *
 * S. Jacobs/NCEP	 3/14	Added black list station table		*
 ***********************************************************************/
{

/*
**	Change the values of these default variables for the
**	specific decoder.
**
**	These variables are the number of expected command line
**	parameters; the program name; the packing and station tables;
**	values for the the number of additional stations and the
**	number of times; and the number of hours, prior to the
**	"current" time, to decode.
*/
#define NUMEXP 1
	int	nexp    = NUMEXP;
	char	*prgnam = "DCTAF";

	char	*defprm = "taf.pack";
	char	*defstn = "tafstn.tbl";
	char	*dfstn2 = "tafblacklist.tbl";
	int	idfadd  = 25;
/*      idfmax was set to 24 - default number of forecast time
**      now it has been changed to 30
*/
	int	idfmax  = 30;
	int	ndfhr1  =  5;
	int	ndfhr2  = 24;
        int     idfwdh  =  0;

/*
**	Do not change these variables. These variables are used by all
**	decoders for getting the command line parameters.
*/
	char	parms[NUMEXP][DCMXLN], curtim[DCMXLN];
	int	num, iret;

	char	gemfil[DCMXLN], stntbl[DCMXLN], stntb2[DCMXLN], 
		prmfil[DCMXLN];
	int	iadstn, maxtim, nhours, txtflg, circflg, iwndht;

/*---------------------------------------------------------------------*/

/*
**	Initialize the output logs, set the time out and 
**	parse the command line parameters.
*/
	dc_init ( prgnam, argc, argv, nexp, parms, &num, &iret );

/*
**	Check for an initialization error.
**	On an error, exit gracefully.
*/
	if  ( iret < 0 )  {
	    dc_exit ( &iret );
	}

/*
**	Set the decoder parameters to the command line entries or
**	default values.
*/
	dc_gopt ( defprm, defstn, dfstn2, idfadd, idfmax, ndfhr1, ndfhr2,
                  idfwdh, prmfil, stntbl, stntb2, &iadstn, &maxtim, curtim,
                  &nhours, &txtflg, &circflg, &iwndht, &iret );

/*
**	The output file name must be present.
**
**	Change this section for the specific decoder.
*/
	strcpy ( gemfil, parms[0] );

/*
**	Call the decoding routine.
**
**	Change this function call, and the define command,
**	for the specific decoder.
*/

	tf_dcod ( curtim, gemfil, stntbl, stntb2, prmfil, 
		  &iadstn, &maxtim, &nhours, &circflg, &iret, 
                  strlen(curtim), strlen(gemfil), strlen(stntbl), 
                  strlen(stntb2), strlen(prmfil) );
/*
**	Send a shut down message to the logs and close the log files.
*/
	dc_exit ( &iret );
}
예제 #24
0
int main ( int argc, char *argv[] )
/************************************************************************
 * DCREDBOOK								*
 *									*
 * This program decodes REDBOOK graphics files and outputs them as 	*
 * standard graphics format files from GEMPAK device drivers.		*
 *									*
 *  Command line:							*
 *  dcgrib [options] device						*
 *      device		output file device                       	*
 **									*
 * Log:									*
 * Chiz/Unidata		 8/00						*
 ***********************************************************************/
{
/*
**      Change the values of these default variables for the
**      specific decoder.
**
**      These variables are the number of expected command line
**      parameters; the program name; the packing and station tables;
**      values for the the number of additional stations and the
**      number of times; and the number of hours, prior to the
**      "current" time, to decode.
*/
#define NUMEXP	1
	int	nexp    = NUMEXP;
	char	*prgnam = "DCREDBOOK";

	char	*defprm = " ";
	char	*defstn = " ";
	char	*dfstn2 = " ";
	int	idfadd  = 0;
	int	idfmax  = 1;
	int	ndfhr1  = 0;
	int	ndfhr2  = 0;
	int     idfwdh  = 0;

/*
**	Do not change these variables. These variables are used by all
**	decoders for getting the command line parameters.
*/
	char	parms[NUMEXP][DCMXLN], curtim[DCMXLN];
	int	num, iret, ier;

	char	gemdev[DCMXLN], stntbl[DCMXLN], stntb2[DCMXLN],
		prmfil[DCMXLN];
	int	iadstn, maxtim, nhours, txtflg, crcflg, iwndht;

	char    errstr[DCMXLN];

/*---------------------------------------------------------------------*/

/*
**	Initialize the output logs, set the time out and 
**	parse the command line parameters. dc_init calls in_bdta in 5.4.3+. 
*/
	dc_init ( prgnam, argc, argv, nexp, parms, &num, &iret );

/*
**	Check for an initialization error.
**	On an error, exit gracefully.
*/
	if  (( iret < 0 )&&(iret != -11))  {
	    sprintf ( errstr, "Error initializing\0" );
	    dc_wclg ( 0, "DC", iret, errstr, &ier );
	    dc_exit ( &iret );
	}

/*
**	Set the decoder parameters to the command line entries or
**	default values.
*/
	dc_gopt ( defprm, defstn, dfstn2, idfadd, idfmax, ndfhr1, ndfhr2,
		  idfwdh, prmfil, stntbl, stntb2, &iadstn, &maxtim, curtim, &nhours,
		  &txtflg, &crcflg, &iwndht, &iret );

/*
**	The if the output file name is not present, use gribkey table
**
**	Change this section for the specific decoder.
*/
	strcpy ( gemdev, parms[0] );

/*
**	Call the decoding routine.
**
**	Change this function call, and the define command,
**	for the specific decoder.
*/
	decode_redbook (gemdev, stntbl, &iret);

/*
**	Send shut down message and close the log files.
*/
	dc_exit ( &iret );

}
예제 #25
0
void debug_console(void (*_func)(void))
{
	int done = 0;

	while( key_inkey() ) {
		os_poll();
	}

	if ( !debug_inited ) {
		dc_init();
	}

	dc_draw(TRUE);

	while (!done) {
		// poll the os
		os_poll();

		int k = key_inkey();
		switch( k ) {

		case KEY_SHIFTED+KEY_ENTER:
		case KEY_ESC:
			done = TRUE;
			break;

		case KEY_BACKSP:
			if (!dc_command_buf.empty()) {
				dc_command_buf.erase(dc_command_buf.size() - 1);
			}
			break;

		case KEY_F3:
		case KEY_UP:
			if (last_oldcommand < (dc_history.end() - 1)) {
				++last_oldcommand;
			}

			dc_command_buf = *last_oldcommand;
			break;

		case KEY_DOWN:
			if (last_oldcommand > dc_history.begin()) {
				--last_oldcommand;
			}

			dc_command_buf = *last_oldcommand;
			break;

		case KEY_PAGEUP:
			if (dc_scroll_y > 1) {
				dc_scroll_y--;
			}
			break;

		case KEY_PAGEDOWN:
			if (dc_scroll_y < (DBROWS - DROWS)) {
				dc_scroll_y++;
			} else {
				dc_scroll_y = (DBROWS - DROWS);
			}
			break;

		case KEY_ENTER:
			dc_scroll_y = (DBROWS - DROWS);			// Set the scroll to look at the bottom
			last_oldcommand = dc_history.begin();	// Reset the last oldcommand
			lastline = 0;	// Reset the line counter

			// Clear the command line on the window, but don't print the prompt until the command has processed
			// Stuff a copy of the command line onto the history
			// Search for the command
				// If not found:
				//   abort,
				//   dc_printf("Error: Invalid or Missing command %s", cmd.c_str()), and
				//   dc_printf(dc_prompt) when ready for input
			// Call the function for that command, and strip the cmd token from the command line string
			if (dc_command_buf.empty()) {
				dc_printf("No command given.\n");
				break;
			} // Else, continue to process the cmd_line

			// z64: Thread Note: Maybe lock a mutex here to allow a previous DCF to finish/abort before starting a new one
			// z64: We'll just assume we won't be here unless a command has finished...
			dc_history.push_front(dc_command_buf);	// Push the command onto the history queue
			last_oldcommand = dc_history.begin();	// Reset oldcommand

			while (dc_history.size() > DCMDS) {
				dc_history.pop_back();			// Keep the commands less than or equal to DCMDS
			}

			dc_command_str = dc_command_buf;	// Xfer to the command string for processing
			dc_command_buf.resize(0);			// Nullify the buffer
			dc_printf("%s%s\n", dc_prompt, dc_command_str.c_str());	// Print the command w/ prompt.
			dc_draw(FALSE);					// Redraw the console without the command line.
			dc_do_command(&dc_command_str);	// Try to do the command
			break;

		default:
			// Not any of the control key codes, so it's probably a letter or number.
			ubyte c = (ubyte)key_to_ascii(k);
			if ((c != 255) && (dc_command_buf.size() < MAX_CLI_LEN)) {
				dc_command_buf.push_back(c);
			}
		}

		// Do the passed function
		if ( _func ) {
			_func();
		}

		// All done, and ready for new entry
		dc_draw(TRUE);
	}

	while( key_inkey() ) {
		os_poll();
	}
}
예제 #26
0
int main ( int argc, char *argv[] )
/************************************************************************
 * DCMSFC								*
 *									*
 * This program decodes ship, buoy, C-MAN, and Coast Guard reports and	*
 * writes the output to a GEMPAK surface file.				*
 *									*
 *  Command line:							*
 *  dcmsfc [options] filename						*
 *	filename	output file name/template			*
 **									*
 * Log:									*
 * K. Tyle/GSC		 4/97	Based on DCMETR				*
 * D. Kidwell/NCEP	10/97	Eliminated bufr references 		*
 * I. Durham/GSC	 5/98	Changed underscore decl. to an include	*
 * A. Hardy/GSC		 1/01   Added full prototype			*
 * S. Jacobs/NCEP	 2/01	Removed all references to ulog		*
 * F. J. Yen/NCEP	 4/01	Added Coast Guard reports to prolog	*
 * D. Kidwell/NCEP	 1/03	Increased idfmax to MMHDRS - 1          *
 * m.gamazaychikov/SAIC 07/05   Added parameters to CS of dc_gopt       *
 * H. Zeng/SAIC		08/05	Added parameters to CS of dc_gopt	*
 * L. Hinson/AWC        06/08   Added circflg parameter to dc_gopt      *
 ***********************************************************************/
{

/*
**	Change the values of these default variables for the
**	specific decoder.
**
**	These variables are the number of expected command line
**	parameters; the program name; the packing and station tables;
**	values for the the number of additional stations and the
**	number of times; and the number of hours, prior to the
**	"current" time, to decode.
*/
#define NUMEXP 1
	int	nexp    = NUMEXP;
	char	*prgnam = "DCMSFC";

	char	*defprm = "msfc.pack";
	char	*defstn = "msfstns.tbl";
	char	*dfstn2 = " ";
	int	idfadd  = 25;
	int	idfmax  =  MMHDRS - 1;
	int	ndfhr1  =  5;
	int	ndfhr2  = 24;
        int     idfwdh  =  0;

/*
**	Do not change these variables. These variables are used by all
**	decoders for getting the command line parameters.
*/
	char	parms[NUMEXP][DCMXLN], curtim[DCMXLN];
	int	num, iret;

	char	gemfil[DCMXLN], stntbl[DCMXLN], stntb2[DCMXLN], 
		prmfil[DCMXLN];
	int	iadstn, maxtim, nhours, txtflg, circflg, iwndht;

/*---------------------------------------------------------------------*/

/*
**	Initialize the output logs, set the time out and 
**	parse the command line parameters.
*/
	dc_init ( prgnam, argc, argv, nexp, parms, &num, &iret );

/*
**	Check for an initialization error.
**	On an error, exit gracefully.
*/
	if  ( iret < 0 )  {
	    dc_exit ( &iret );
	}

/*
**	Set the decoder parameters to the command line entries or
**	default values.
*/
	dc_gopt ( defprm, defstn, dfstn2, idfadd, idfmax, ndfhr1, ndfhr2,
                  idfwdh, prmfil, stntbl, stntb2, &iadstn, &maxtim, curtim,
                  &nhours, &txtflg, &circflg, &iwndht, &iret );

/*
**	The output file name must be present.
**
**	Change this section for the specific decoder.
*/
	strcpy ( gemfil, parms[0] );

/*
**	Call the decoding routine.
**
**	Change this function call, and the define command,
**	for the specific decoder.
*/

	ma_dcod ( curtim, gemfil, stntbl, prmfil, 
		  &iadstn, &maxtim, &nhours, &iret, strlen(curtim), 
		  strlen(gemfil), strlen(stntbl), strlen(prmfil) );
/*
**	Send a shut down message to the logs and close the log files.
*/
	dc_exit ( &iret );
	return(0);
}
예제 #27
0
/*
 * The main loop of the player thread, during playback.  This is
 * basically a state machine, which multiplexes data between the
 * decoder thread and the output threads.
 */
static void do_play(struct decoder_control *dc)
{
	struct player player = {
		.dc = dc,
		.buffering = true,
		.decoder_starting = false,
		.paused = false,
		.queued = true,
		.output_open = false,
		.song = NULL,
		.xfade = XFADE_UNKNOWN,
		.cross_fading = false,
		.cross_fade_chunks = 0,
		.cross_fade_tag = NULL,
		.elapsed_time = 0.0,
	};

	player_unlock();

	player.pipe = music_pipe_new();

	player_dc_start(&player, player.pipe);
	if (!player_wait_for_decoder(&player)) {
		player_dc_stop(&player);
		player_command_finished();
		music_pipe_free(player.pipe);
		event_pipe_emit(PIPE_EVENT_PLAYLIST);
		player_lock();
		return;
	}

	player_lock();

	if (pc.command == PLAYER_COMMAND_SEEK)
		player.elapsed_time = pc.seek_where;

	pc.state = PLAYER_STATE_PLAY;
	player_command_finished_locked();

	while (true) {
		player_process_command(&player);
		if (pc.command == PLAYER_COMMAND_STOP ||
		    pc.command == PLAYER_COMMAND_EXIT ||
		    pc.command == PLAYER_COMMAND_CLOSE_AUDIO) {
			player_unlock();
			audio_output_all_cancel();
			break;
		}

		player_unlock();

		if (player.buffering) {
			/* buffering at the start of the song - wait
			   until the buffer is large enough, to
			   prevent stuttering on slow machines */

			if (music_pipe_size(player.pipe) < pc.buffered_before_play &&
			    !decoder_lock_is_idle(dc)) {
				/* not enough decoded buffer space yet */

				if (!player.paused &&
				    player.output_open &&
				    audio_output_all_check() < 4 &&
				    !player_send_silence(&player))
					break;

				decoder_lock(dc);
				/* XXX race condition: check decoder again */
				player_wait_decoder(dc);
				decoder_unlock(dc);
				player_lock();
				continue;
			} else {
				/* buffering is complete */
				player.buffering = false;
			}
		}

		if (player.decoder_starting) {
			/* wait until the decoder is initialized completely */

			if (!player_check_decoder_startup(&player))
				break;

			player_lock();
			continue;
		}

#ifndef NDEBUG
		/*
		music_pipe_check_format(&play_audio_format,
					player.next_song_chunk,
					&dc->out_audio_format);
		*/
#endif

		if (decoder_lock_is_idle(dc) && player.queued &&
		    dc->pipe == player.pipe) {
			/* the decoder has finished the current song;
			   make it decode the next song */

			assert(dc->pipe == NULL || dc->pipe == player.pipe);

			player_dc_start(&player, music_pipe_new());
		}

		if (player_dc_at_next_song(&player) &&
		    player.xfade == XFADE_UNKNOWN &&
		    !decoder_lock_is_starting(dc)) {
			/* enable cross fading in this song?  if yes,
			   calculate how many chunks will be required
			   for it */
			player.cross_fade_chunks =
				cross_fade_calc(pc.cross_fade_seconds, dc->total_time,
						pc.mixramp_db,
						pc.mixramp_delay_seconds,
						dc->replay_gain_db,
						dc->replay_gain_prev_db,
						dc->mixramp_start,
						dc->mixramp_prev_end,
						&dc->out_audio_format,
						&player.play_audio_format,
						music_buffer_size(player_buffer) -
						pc.buffered_before_play);
			if (player.cross_fade_chunks > 0) {
				player.xfade = XFADE_ENABLED;
				player.cross_fading = false;
			} else
				/* cross fading is disabled or the
				   next song is too short */
				player.xfade = XFADE_DISABLED;
		}

		if (player.paused) {
			player_lock();

			if (pc.command == PLAYER_COMMAND_NONE)
				player_wait();
			continue;
		} else if (!music_pipe_empty(player.pipe)) {
			/* at least one music chunk is ready - send it
			   to the audio output */

			play_next_chunk(&player);
		} else if (audio_output_all_check() > 0) {
			/* not enough data from decoder, but the
			   output thread is still busy, so it's
			   okay */

			/* XXX synchronize in a better way */
			g_usleep(10000);
		} else if (player_dc_at_next_song(&player)) {
			/* at the beginning of a new song */

			if (!player_song_border(&player))
				break;
		} else if (decoder_lock_is_idle(dc)) {
			/* check the size of the pipe again, because
			   the decoder thread may have added something
			   since we last checked */
			if (music_pipe_empty(player.pipe)) {
				/* wait for the hardware to finish
				   playback */
				audio_output_all_drain();
				break;
			}
		} else if (player.output_open) {
			/* the decoder is too busy and hasn't provided
			   new PCM data in time: send silence (if the
			   output pipe is empty) */
			if (!player_send_silence(&player))
				break;
		}

		player_lock();
	}

	player_dc_stop(&player);

	music_pipe_clear(player.pipe, player_buffer);
	music_pipe_free(player.pipe);

	if (player.cross_fade_tag != NULL)
		tag_free(player.cross_fade_tag);

	player_lock();

	if (player.queued) {
		assert(pc.next_song != NULL);
		pc.next_song = NULL;
	}

	pc.state = PLAYER_STATE_STOP;

	player_unlock();

	event_pipe_emit(PIPE_EVENT_PLAYLIST);

	player_lock();
}

static gpointer player_task(G_GNUC_UNUSED gpointer arg)
{
	struct decoder_control dc;

	dc_init(&dc);
	decoder_thread_start(&dc);

	player_buffer = music_buffer_new(pc.buffer_chunks);

	player_lock();

	while (1) {
		switch (pc.command) {
		case PLAYER_COMMAND_SEEK:
		case PLAYER_COMMAND_QUEUE:
			assert(pc.next_song != NULL);

			do_play(&dc);
			break;

		case PLAYER_COMMAND_STOP:
			player_unlock();
			audio_output_all_cancel();
			player_lock();

			/* fall through */

		case PLAYER_COMMAND_PAUSE:
			pc.next_song = NULL;
			player_command_finished_locked();
			break;

		case PLAYER_COMMAND_CLOSE_AUDIO:
			player_unlock();

			audio_output_all_release();

			player_lock();
			player_command_finished_locked();

#ifndef NDEBUG
			/* in the DEBUG build, check for leaked
			   music_chunk objects by freeing the
			   music_buffer */
			music_buffer_free(player_buffer);
			player_buffer = music_buffer_new(pc.buffer_chunks);
#endif

			break;

		case PLAYER_COMMAND_UPDATE_AUDIO:
			player_unlock();
			audio_output_all_enable_disable();
			player_lock();
			player_command_finished_locked();
			break;

		case PLAYER_COMMAND_EXIT:
			player_unlock();

			dc_quit(&dc);
			dc_deinit(&dc);
			audio_output_all_close();
			music_buffer_free(player_buffer);

			player_command_finished();
			return NULL;

		case PLAYER_COMMAND_CANCEL:
			pc.next_song = NULL;
			player_command_finished_locked();
			break;

		case PLAYER_COMMAND_REFRESH:
			/* no-op when not playing */
			player_command_finished_locked();
			break;

		case PLAYER_COMMAND_NONE:
			player_wait();
			break;
		}
	}
}

void player_create(void)
{
	assert(pc.thread == NULL);

	GError *e = NULL;
	pc.thread = g_thread_create(player_task, NULL, true, &e);
	if (pc.thread == NULL)
		MPD_ERROR("Failed to spawn player task: %s", e->message);
}
예제 #28
0
void atmega_i2c_cam_ctrl_init(void)
{
  atmega_i2c_cam_ctrl_trans.status = I2CTransDone;
  dc_init();
}
예제 #29
0
int main(int args,char *argv[]){
    const int smallOutputNumber=-1;
    int i,j;
    cJSON *root;
    int num_chromosome;
    int req_type=1;
    char buffer[30];
    char req_gene[20]={0};
    cJSON *msg;
    char req_kind[50]="E.coli K12-DH10B";

    pi=0;
    ini=0;
    req_restrict.rfc10=0;
    req_restrict.rfc12=0;
    req_restrict.rfc12a=0;
    req_restrict.rfc21=0;
    req_restrict.rfc23=0;
    req_restrict.rfc25=0;

    char *req_str=argv_default;
    if(args==2) req_str=argv[1];

    cJSON *request=cJSON_Parse(req_str);
    if(check_req(request)){
        onError("illegal args");
        return 0;
    }

    i=1;
    j=1;

    cJSON *cJSON_temp;
    cJSON_temp=cJSON_GetObjectItem(request,"type");
    if(cJSON_temp) req_type=cJSON_temp->valueint;
    char req_pam[PAM_LEN+1];
    int req_pam_len;
    strcpy(req_pam,cJSON_GetObjectItem(request,"pam")->valuestring);
    req_pam_len=(int)strlen(req_pam);
    char req_specie[30];
    struct return_struct rs;
    int ptts_num;
    int len[NUM_CHROMOSOME];
    strcpy(req_specie,cJSON_GetObjectItem(request,"specie")->valuestring);
    if(strcmp(req_specie,"SARS")==0){
        rs=info_readin(PTT_SARS,ptts,str,wai,NULL);
    }else if(strcmp(req_specie,"E.coli")==0){
        cJSON_temp=cJSON_GetObjectItem(request,"kind");
        if(cJSON_temp) strcpy(req_kind,cJSON_temp->valuestring);
        rs=info_readin(PTT_ECOLI,ptts,str,wai,req_kind);
    }else if(strcmp(req_specie,"Saccharomycetes")==0){
        rs=info_readin(PTT_SACCHAROMYCETES,ptts,str,wai,NULL);
    }else{
        onError("no specie");
        return 0;
    }
    ptts_num=rs.ptts_num;
    num_chromosome=rs.num_chromosome;
    for(i=1;i<=num_chromosome;i++) len[i]=rs.len[i];

    double req_r1=0.65;
    cJSON_temp=cJSON_GetObjectItem(request,"gene");
    if(cJSON_temp){
        req_r1=cJSON_GetObjectItem(request,"r1")->valuedouble;
    }

    cJSON_temp=cJSON_GetObjectItem(request,"gene");
    int req_id,req_gene_start,req_gene_end;
    if(cJSON_temp){
        strcpy(req_gene,cJSON_temp->valuestring);
        for(int i=0;i<ptts_num;i++){
            if(strcmp(req_gene,ptts[i].gene)==0){
                req_id=ptts[i].chromosome;
                req_gene_start=ptts[i].s;
                req_gene_end=ptts[i].t;
                break;
            }
        }
    }else{
        char req_location[20];
        strcpy(req_location,cJSON_GetObjectItem(request,"location")->valuestring);
        sscanf(req_location,"%d:%d..%d",&req_id,&req_gene_start,&req_gene_end);
    }

    char req_rfc[10];
    strcpy(req_rfc,cJSON_GetObjectItem(request,"rfc")->valuestring);
    req_restrict.rfc10=req_rfc[0]-48;
    req_restrict.rfc12=req_rfc[1]-48;
    req_restrict.rfc12a=req_rfc[2]-48;
    req_restrict.rfc21=req_rfc[3]-48;
    req_restrict.rfc23=req_rfc[4]-48;
    req_restrict.rfc25=req_rfc[5]-48;

    generate_filename(buffer,req_specie,req_kind,req_pam,req_type);
    dc_init(buffer);
    /*
    This part above is for read in JSON-style request.
    The result stored in req_specie, req_pam, req_gene_start, req_gene_end, rfc and so on.
    At the same time, it reads in ptt file for specie,
    and also open files.
    */

    for(int id=1;id<=num_chromosome;id++){
        for(i=LEN;i<len[id]-req_pam_len;i++){       // All possible gRNAs, +direction
            if(check_pam(str[id]+i,req_pam)){
                psb_site[pi].index=i;
                psb_site[pi].strand='+';
                psb_site[pi].chromosome=id;
                for(j=0;j<req_pam_len;j++) psb_site[pi].pam[j]=(str[id]+i)[j];
                psb_site[pi].pam[j]=0;
                for(j=0;j<LEN;j++) psb_site[pi].nt[j]=(str[id]+i-LEN)[j];
                psb_site[pi].nt[j]=0;
                pi++;
            }
        }
        char req_pam_rev[PAM_LEN];
        int last=-1;
        dna_rev(req_pam_rev,req_pam,req_pam_len);
        for(i=0;i<len[id]-LEN-req_pam_len;i++){     // All possible gRNAs, -direction
            if(check_pam(str[id]+i,req_pam_rev)){
                psb_site[pi].index=i+req_pam_len-1;
                psb_site[pi].strand='-';
                psb_site[pi].chromosome=id;
                if(req_pam_len!=last){
                    last=req_pam_len;
                }
                for(j=0;j<req_pam_len;j++) psb_site[pi].pam[j]=dna_rev_char((str[id]+i)[req_pam_len-1-j]);
                psb_site[pi].pam[j]=0;
                for(j=0;j<LEN;j++) psb_site[pi].nt[j]=dna_rev_char((str[id]+i+req_pam_len)[LEN-j-1]);
                psb_site[pi].nt[j]=0;
                pi++;
            }
        }
    }

    for(i=0;i<pi;i++){
        fflush(stdout);
        if(psb_site[i].chromosome!=req_id) continue;
        if(psb_site[i].strand=='+'){
            if(psb_site[i].index<req_gene_start || psb_site[i].index+req_pam_len-1>req_gene_end) continue;
            for(j=psb_site[i].index-LEN;j<psb_site[i].index+req_pam_len-1;j++){
                if(wai[req_id][j]!=1) break;
            }
            if(j<psb_site[i].index+req_pam_len-1) j=0;
            else j=1;
        }else{
            if(psb_site[i].index-req_pam_len+1<req_gene_start || psb_site[i].index>req_gene_end) continue;
            for(j=psb_site[i].index-req_pam_len+1;j<psb_site[i].index+LEN;j++){
                if(wai[req_id][j]!=1) break;
            }
            if(j<psb_site[i].index+LEN) j=0;
            else j=1;
        }
        if(j){
            score(i,&ini,req_type,req_r1);
        }
    }

    dc_save();

    sort(in_site,in_site+ini,cmp_in_site);  // Sort & Output

    root=cJSON_CreateObject();
    cJSON_AddNumberToObject(root,"status",0);

    msg=cJSON_CreateObject();
    cJSON_AddStringToObject(msg,"specie",req_specie);
    cJSON_AddStringToObject(msg,"kind",req_kind);
    cJSON_AddStringToObject(msg,"gene",req_gene);
    sprintf(buffer,"%d:%d..%d",req_id,req_gene_start,req_gene_end);
    cJSON_AddStringToObject(msg,"location",buffer);
    cJSON_AddItemToObject(root,"message",msg);

    vector<cJSON*> list;
    list.clear();
    for(i=0;i<ini && i!=smallOutputNumber;i++){
        cJSON *ans=cJSON_CreateObject();
        sprintf(buffer,"#%d",i+1);
        cJSON_AddStringToObject(ans,"key",buffer);
        sprintf(buffer,"%s%s",in_site[i].nt,in_site[i].pam);
        cJSON_AddStringToObject(ans,"grna",buffer);
        sprintf(buffer,"%d:%d",in_site[i].chromosome,in_site[i].index);
        cJSON_AddStringToObject(ans,"position",buffer);
        char xs[2];
        xs[0]=in_site[i].strand;
        xs[1]=0;
        cJSON_AddStringToObject(ans,"strand",xs);
        cJSON_AddNumberToObject(ans,"total_score",(int)in_site[i].score);
        cJSON_AddNumberToObject(ans,"Sspe",(int)(req_r1*in_site[i].Sspe_nor));
        cJSON_AddNumberToObject(ans,"Seff",(int)((1.0-req_r1)*in_site[i].Seff_nor));
        cJSON_AddNumberToObject(ans,"count",in_site[i].count);
        cJSON_AddItemToObject(ans,"offtarget",in_site[i].otj);

        list.push_back(ans);
    }

    cJSON_AddItemToObject(root,"result",Create_array_of_anything(&(list[0]),list.size()));

    printf("%s\n",NomoreSpace(argv[0]=cJSON_Print(root)));

    free(argv[0]);
    return 0;
}
예제 #30
0
int main ( int argc, char *argv[] )
/************************************************************************
 * DCHRCN								*
 *									*
 * This program decodes the WTNT23, WTNT24 and WTPZ23 tropical storm    *
 * and hurricane forecast/advisory reports and writes the output to an  *
 * ASCII file.    							*
 *									*
 *  Command line:							*
 *  dcwtch [options] filename						*
 *	filename	output file name/template			*
 **									*
 * Log:									*
 * A. Hardy/GSC		 9/99						*
 * A. Hardy/GSC		 1/01	Added full prototype			*
 * S. Jacobs/NCEP	 2/01	Removed all references to ulog		*
 * m.gamazaychikov/SAIC 07/05   Added parameters to CS of dc_gopt       *
 * H. Zeng/SAIC		08/05	Added parameters to CS of dc_gopt	*
 * L. Hinson/AWC        06/08   Added circflg parameter to dc_gopt      *
 ***********************************************************************/
{

/*
**	Change the values of these default variables for the
**	specific decoder.
**
**	These variables are the number of expected command line
**	parameters; the program name; the packing and station tables;
**	values for the the number of additional stations and the
**	number of times; and the number of hours, prior to the
**	"current" time, to decode.
*/
#define NUMEXP 1
	int	nexp    = NUMEXP;
	char	*prgnam = "DCHRCN";

  	char	*defprm = " ";
	char	*defstn = " ";
	char	*dfstn2 = " ";
	int	idfadd  = 25;
	int	idfmax  = 24;
	int	ndfhr1  =  5;
	int	ndfhr2  = 24;
        int     idfwdh  =  0;

/*
**	Do not change these variables. These variables are used by all
**	decoders for getting the command line parameters.
*/
	char	parms[NUMEXP][DCMXLN], curtim[DCMXLN];
	int	num, iret;

	char	gemfil[DCMXLN], stntbl[DCMXLN], stntb2[DCMXLN],
		prmfil[DCMXLN];
	int	iadstn, maxtim, nhours, txtflg, circflg, iwndht;

/*---------------------------------------------------------------------*/

/*
**	Initialize the output logs, set the time out and 
**	parse the command line parameters.
*/
	dc_init ( prgnam, argc, argv, nexp, parms, &num, &iret );

/*
**	Check for an initialization error.
**	On an error, exit gracefully.
*/
	if  ( iret < 0 )  {
	    dc_exit ( &iret );
	}

/*
**	Set the decoder parameters to the command line entries or
**	default values.
*/
	dc_gopt ( defprm, defstn, dfstn2, idfadd, idfmax, ndfhr1, ndfhr2,
                  idfwdh, prmfil, stntbl, stntb2, &iadstn, &maxtim, curtim,
                  &nhours, &txtflg, &circflg, &iwndht, &iret );

/*
**	The output file name must be present.
**
**	Change this section for the specific decoder.
*/
	strcpy ( gemfil, parms[0] );

/*
**	Call the decoding routine.
**
**	Change this function call, and the define command,
**	for the specific decoder.
*/

	hc_dcod ( curtim, gemfil, stntbl, prmfil, 
		  &iadstn, &maxtim, &nhours, &iret, strlen(curtim), 
		  strlen(gemfil), strlen(stntbl), strlen(prmfil) );
/*
**	Send a shut down message to the logs and close the log files.
*/
	dc_exit ( &iret );
	return 0;
}