Esempio n. 1
0
int main()
{	
	unsigned int adc;
	float vol;
	int n;
	
	copy_vec();
	irq_init();
	button_init();
	uart0_init();
	timer_init();
//	timer4_init();

	lcd_init();
	lcd_clean(0xffff);
	adc_ts_init();
	ts_init();
	while(1);

	while(1)
	{
		adc = read_adc(0);
		vol = adc * 3.3 / 0x3ff;
		n = (vol - (int)vol) * 1000;
		
		printf("AIN0: adc = %u	voltage:%d.%03d\r\n", adc, (int)vol, n);
		delayms(1000);
	}
	
	return 0;
}
Esempio n. 2
0
int main(int argc, char** argv){
    int retval = 0;
    int i, Navg;
    param_obj param;
    kw_obj kw;
    ts_obj ts;
    vsip_mview_f *dtaIn, *gramOut;
    if(retval += param_read(argv[1],&param)){
        printf("Failed to read parameter file\n");
        exit(-1);
    }
    param_log(&param);
    kw_init(&kw, &param);
    ts_init(&ts, &param);
    /* simulate time series and beamform */
    Navg = (int) param.Navg;
    dtaIn = ts_instance(&ts);
    gramOut = kw_instance(&kw);
    kw_zero(&kw);
    for(i=0; i<Navg; i++){
        ts_zero(&ts);
        ts_sim_noise(&ts);
        ts_sim_nb(&ts);
        komega(&kw,dtaIn);
    }
    /* beamform done. Gram should be in gramOut */
    /*************/    
    /* Massage gram data and save to file for plotting */
      for(i=0; i<vsip_mgetrowlength_f(gramOut); i++)
      {/* move zero to middle */
         vsip_vview_f *v = vsip_mcolview_f(gramOut, i);
         vsip_vfreqswap_f(v);
         vsip_vdestroy_f(v);
      }
      {/* massage the data for plot*/
         vsip_scalar_f max = vsip_mmaxval_f(gramOut, NULL),min;
         vsip_scalar_f avg = vsip_mmeanval_f(gramOut);
         vsip_mclip_f(gramOut,0.0, max, avg/100000.0, max, gramOut);
         vsip_mlog10_f(gramOut,gramOut);
         min = -vsip_mminval_f(gramOut, NULL);
         vsip_smadd_f(min, gramOut, gramOut);
         max = vsip_mmaxval_f(gramOut, NULL);
         vsip_smmul_f(1.0/max, gramOut, gramOut);
      }
      { /* output data and plot with octave */
         FILE *fptr = fopen("gramOut","w");
         size_t size = vsip_mgetrowlength_f(gramOut) * vsip_mgetcollength_f(gramOut);
         vsip_scalar_f *out = (vsip_scalar_f*)malloc(size * sizeof(vsip_scalar_f));
         vsip_mcopyto_user_f(gramOut, VSIP_COL, out);
         fwrite(out,size,sizeof(vsip_scalar_f),fptr);
         fclose(fptr);
         free(out);
      }
    /* cleanup */
    kw_fin(&kw);
    ts_fin(&ts);
    param_free(&param);
    return retval;
}
Esempio n. 3
0
static void init(void) {
    options_init();
    comm_init();
    tl_init();
    ts_init();
    ti_init();
    sb_init();

    tl_show();
    // others...
}
Esempio n. 4
0
int main(int argc, char *argv[])
{
	int rc = ts_init();
	if (rc == -1)
		return 1;

	/* parse arguments */
	switch (ts_options_process(&tss.opts, argc, argv)) {
	case TS_MODE_USAGE:
		ts_options_free(&tss.opts);
		return ts_options_usage();
	case TS_MODE_VERSION:
		ts_options_free(&tss.opts);
		return 0;
	case TS_MODE_CREATE:
		break;
	}

	/* load configuration file */
	rc = ts_config_load(&tss.opts);
	if (rc == -1)
		goto done;

	/* create spaces */
	rc = ts_space_init(&tss.s);
	if (rc == -1)
		goto done;
	rc = ts_space_fill(&tss.s, &tss.opts);
	if (rc == -1)
		goto done;

	printf("work_dir: %s\n", tss.opts.cfg.work_dir);
	printf("snap_dir: %s\n", tss.opts.cfg.snap_dir);
	printf("wal_dir:  %s\n", tss.opts.cfg.wal_dir);
	printf("spaces:   %d\n", mh_size(tss.s.t));

	/* indexate snapshot and xlog data */
	rc = ts_indexate();
	if (rc == -1)
		goto done;
	/* write snapshot */
	rc = ts_snapshot_create();
	if (rc == -1)
		goto done;
	printf("complete.\n");

done:
	ts_free();
	return (rc == -1 ? 1 : 0);
}
Esempio n. 5
0
int tsload_init(struct subsystem* xsubsys, unsigned xs_count) {
	struct subsystem** subsys_list = NULL;
	unsigned s_count = sizeof(subsys) / sizeof(struct subsystem);
	int si, xsi;

	/* Mempool is not yet initialized, so use libc; freed by ts_finish */
	subsys_list = malloc((s_count + xs_count) * sizeof(struct subsystem*));

	/* Initialize [0:s_count] subsystems with tsload's subsystems
	 * and [s_count:s_count+xs_count] with extended subsystems */
	for(si = 0; si < s_count; ++si)
		subsys_list[si] = &subsys[si];
	for(xsi = 0; xsi < xs_count; ++si, ++xsi)
		subsys_list[si] = &xsubsys[xsi];

	return ts_init(subsys_list, s_count + xs_count);
}
Esempio n. 6
0
File: init.c Progetto: brkt/fuse-xfs
void
xfs_init(libxfs_init_t *args)
{
	memset(args, 0, sizeof(libxfs_init_t));

	if (isa_file)  {
		args->disfile = 1;
		args->dname = fs_name;
		args->volname = NULL;
	} else  {
		args->disfile = 0;
		args->volname = fs_name;
		args->dname = NULL;
	}

	if (log_spec)  {	/* External log specified */
		args->logname = log_name;
		args->lisfile = (isa_file?1:0);
		/* XXX assume data file also means log file */
		/* REVISIT: Need to do fs sanity / log validity checking */
	}

	if (rt_spec)  {	/* RT device specified */
		args->rtname = rt_name;
		args->risfile = (isa_file?1:0);
		/* XXX assume data file also means rt file */
	}

	args->usebuflock = do_prefetch;
	args->setblksize = 0;
	args->isdirect = LIBXFS_DIRECT;
	if (no_modify)
		args->isreadonly = (LIBXFS_ISREADONLY | LIBXFS_ISINACTIVE);
	else if (dangerously)
		args->isreadonly = (LIBXFS_ISINACTIVE | LIBXFS_DANGEROUSLY);
	else
		args->isreadonly = LIBXFS_EXCLUSIVELY;

	if (!libxfs_init(args))
		do_error(_("couldn't initialize XFS library\n"));

	ts_create();
	ts_init();
	increase_rlimit();
	pftrace_init();
}
Esempio n. 7
0
int main()
{	
	copy_vec();
	irq_init();
	button_init();
	uart0_init();
	timer_init();
//	timer4_init();

	lcd_init();
	lcd_clean(0xffff);
	adc_ts_init();
	ts_init();

//	tslib_calibrate();
//	lcd_clean(0xffff);

	nand_init();
#if 1	
	nand_read_id();
	
	while(1);
#endif

	printf("\r\n\n");
	printf("===============================================\r\n");
	printf("              NAND FLASH PROGRAMMING            \r\n");
	
	unsigned int size = 512 * 1024; // 512KB
	nand_read_id();

	printf("erase entire flash, waiting ... \r\n");

	int i;
	for(i = 0; i < 2048; i++)
		nand_erase_block(i);
	
	printf("start program ... \r\n");
	nand_write_bytes(0x0, (unsigned char *)0x31000000, size);
	printf("program end ... \r\n");
	printf("===============================================\r\n");
	while(1);
	
	return 0;
}
Esempio n. 8
0
void flang_init() {
  memset(fl_on_error_jmp, 0, sizeof(jmp_buf));

  // reset error state
  ast_last_error_message = 0;
  ast_last_error_node = 0;

  pool_init(2048);

  st_replace_allocators(pool_new, pool_realloc_fix_string, pool_free);
  hash_replace_allocators(pool_new, pool_realloc, pool_free);
  array_replace_allocators(pool_new, pool_realloc, pool_free);

  identifiers = malloc(sizeof(array));
  array_new(identifiers);

  ast_dump_file = stdout;

  ts_init();
}
Esempio n. 9
0
void brd_driver_init(){
#ifdef CFG_DRV_CON_UART
	con_uart_init();
#endif
#ifdef CFG_DRV_CON_TELNET
	con_telnet_init();
#endif
#ifdef CFG_DRV_SDI
        sd_init();
#endif

#ifdef CFG_DRV_LCD
	lcd_init();
#endif

#ifdef CFG_DRV_TS
	ts_init();
#endif

#ifdef CFG_DRV_NET_DM9000
	dm9000_init();
#endif
}
Esempio n. 10
0
void bcr_initBarcodeReader(void) {
	EncoderInit();
	MotorDir(FWD,FWD);
	FrontLED(ON);
	
	lineCounter = 0;
	rawCounter = 0;
	latestLineData = 0;
	
	unsigned int tmp[2];
	util_getStableLineData(tmp);
	tolFactor = getToleranceValue(tmp[LEFT] + tmp[RIGHT]);
	
	int i;
	util_pauseInterrupts();
	for(i = 0; i < (M_RAW_DATAPOINTS * M_WINDOW_SIZE); i++) {
		measureDataPoint();
		Msleep(5);
	}
	
	ts_init();
	ts_addFunction(&measureDataPoint, M_SAMPLING_FREQ);
	sei();
}
Esempio n. 11
0
File: oo_ui.c Progetto: EX311/moira
int main(int argc, char *argv[])
{
	int ret;
	struct tsdev *ts;
	lua_State *L;

	myfb = myfb_open();
	set_vfb_buf(1);
	ts = ts_init();

	L = luaL_newstate();
	luaL_openlibs(L);

	lua_register(L, "SET_COUNT", lua_set_icon_count);
	lua_register(L, "SET_ICON", lua_set_icon_info);
	lua_register(L, "SET_CMD", lua_set_cmd_list);
	lua_register(L, "SET_BGCOLOR", lua_set_bgcolor);
	lua_register(L, "SET_BGIMAGE", lua_set_bgimage);

	luaL_dofile(L, file_ui);
	lua_close(L);

	while (1) {
		int c, da_count, old_da_count, pid, state = 0;
		struct ts_sample samp;
		struct icon *i;
		struct cmd_list *j;

		da_count = get_DeviceAttached();
		if (!da_count)
			da_count = 0;

		if (!old_da_count)
			old_da_count = da_count;
		else {
			if (old_da_count != da_count) {
				clear_screen();
				put_string_center(myfb->fbvar.xres/2, myfb->fbvar.yres/2 - 10, "Attached Info is changed!", white);
				put_string_center(myfb->fbvar.xres/2, myfb->fbvar.yres/2 + 10, "Touch the screen!", white);
				old_da_count = da_count;
				ret = ts_read(ts, &samp, 1);
				continue;
			}
		}

		set_bgimage();
		set_bgcolor();
		for (c=0; c<=da_count; c++)
			draw_block(myfb->fbvar.xres-12*c-12, 3);
		
		if (head == NULL) {
			put_string_center(myfb->fbvar.xres/2, myfb->fbvar.yres/2, "Sorry, No Apps. registered!", white);
#ifdef DEBUG
			fprintf(stderr, "No Apps!\n");
#endif
			break;
		}

		for (i=head; i != NULL; i=i->next)
			draw_icon(i);

		ret = ts_read(ts, &samp, 1);
		if (ret < 0) {
			perror("ts_read");
			continue;
		}
		if (ret != 1)
			continue;

		if (samp.x > 310 && samp.y >230)
			break;

		for (i=head, j=cmdlist; i != NULL; i=i->next, j=j->next) {
			if (icon_handle(i, &samp) > 0) {
				if (chat_count < 20)
					continue;
				chat_count = 0;

				pid = fork();
				if (pid == 0) {
#ifdef DEBUG
					fprintf(stderr, " *** This is CHILD! ***\n");
#endif
					if (j)
						ret = execl(j->path, j->args, 0);
					if (ret < 0) {
						perror("execl");
						exit(1);
					}
				} else {
					sleep(1);
					wait(&state);
					no_count = 0;
					put_string_center(myfb->fbvar.xres/2, myfb->fbvar.yres/2, "End of Program!", white);
#ifdef DEBUG
					fprintf(stderr, " *** End of CHILD! ***\n");
#endif
				}
			}
		}
	}

	clear_screen();
	put_string_center(myfb->fbvar.xres/2, myfb->fbvar.yres/2, "Thanks for Use!", white);

	free_icon();
	free_cmd();
	ts_close(ts);
	free_vfb_buf(1);
	myfb_close();
	return 0;
}
Esempio n. 12
0
int My_boot_main()
{

	//unsigned char buff[2048];

	int num;
#ifdef MMU_ON
    mmu_init();
#endif
    led_init();
    button_init();
    init_irq();
    
    uart_init();
    
    ts_init();
    
    //lcd_init(); 
    
    //lcd_test();
    
    dm9000_init();
    
	while(1)
	{
		printf("\n**********************************************\n\r");
		printf("\n*******************My-boot********************\n\r");
		printf("[1], Download Linux Kernel from TFTP Server!\n\r");
		printf("[2], Boot Linux from RAM!\n\r");
		printf("[3], Boot Linux from Nand Flash\n\r");
		printf("\n Please Select:");

		int num;
		scanf("%d", &num);

		switch (num)
        {
            case 1:
            //tftp_load();
            tftp_send_request("start.o");
            break;
            
            case 2:
            //boot_linux_ram();
            //arp_request();
            boot_linux();
            break;
            
            case 3:
            //boot_linux_nand();
            arp_request();
            break;
            
            default:
                printf("Error: wrong selection!\n\r");
            break;	
        }

	return 0;
    }
}
Esempio n. 13
0
int main(int argc,char **argv)
{
	int ret;
	pthread_t view_id;
	pid_t view_pid=0,audio_pid=0;

       // LCD 初始化
	fb_init();
      // 触摸屏初始化
	ts_init();
       // 显示一张启动logo
	show_jpglogo("./image/welcome.jpg");
	sleep(3);
	// 显示控制主界面菜单
	show_menu();


	ret =  pthread_create(&view_id, NULL,picview_thread, NULL);
	if(ret == -1)
		goto pthread_create_err;



	while(1)
	{
		
		// 等待获取坐标
		pthread_mutex_lock(&mutex);
		printf(" main get lock!\n");
	
		m = get_motion();
		
		printf(" main put lock!\n");
		pthread_mutex_unlock(&mutex);
		usleep(1000);


		switch(m)
		{

			case button1:
				printf("button1 Prev\n");
				if(audio_pid != 0)
					kill(audio_pid,SIGKILL);
				audio_pid = start_audio(BACKWARD);
				//kill(view_pid,SIGUSR1);
				break;
				
			case button2:
				printf("button2 Next\n");
				if(audio_pid != 0)
					kill(audio_pid,SIGKILL);
				audio_pid = start_audio(FORWARD);
				//kill(view_pid,SIGUSR2);				
				break;
				
			case button3:
				printf("button3 Stop\n");
				kill(audio_pid,SIGSTOP);
				//kill(view_pid,SIGSTOP);				
				break;
				
			case button4:
				printf("button4 Continue\n");
				kill(audio_pid,SIGCONT);
				//kill(view_pid,SIGCONT);					
				break;

			case button5:
				printf("button5 Load\n");
				traverse_file_dir("/photo/dir");
				//view_pid = start_picview();
				signal(SIGCHLD,waitp);
				break;
				
		}


	}

	fb_uninit();
	ts_uninit();
	
	return 0;
	
pthread_create_err:
	printf("  pthread_create  err!\n");
	return -1;

}
Esempio n. 14
0
DH_FILE * dh_open(char path[])
{
 DH_FILE * dh_file = NULL;
 FILE_ENTRY * fptr;
 char filename[MAX_PATHNAME_LEN+1];
 char pathname[MAX_PATHNAME_LEN+1];
 short int i;
 char * p;
 struct DH_HEADER header;
 struct DH_AK_HEADER ak_header;
 char * ibuff = NULL;
 short int file_id = -1;
 OSFILE fu = INVALID_FILE_HANDLE;      /* Primary subfile */
 OSFILE ofu = INVALID_FILE_HANDLE;     /* Overflow subfile */
 int bytes;
 unsigned long int ak_map;
 short int no_of_subfiles;
 short int no_of_aks;
 bool read_only = FALSE;
 DESCRIPTOR * descr;
 int n;
 int subfile;
 long int ak_node_num;
 OBJECT_HEADER * obj;
 struct stat statbuf;
 unsigned long int device = 0;
 unsigned long int inode = 0;

 dh_err = 0;
 process.os_error = 0;

 /* Validate file name */

 p = strrchr(path, DS);          /* Find final directory separator */
 if (p == NULL) p = path;
 if ((*p == '\0')                  /* Null name in last component */
    || !fullpath(filename, path))  /* Unable to map to absolute pathname */
  {
   dh_err = DHE_FILE_NOT_FOUND;
   goto exit_dh_open;
  }

 /* Check if this file is already open to this process */

 if (stat(filename, &statbuf) != 0)
  {
   dh_err = DHE_FILE_NOT_FOUND;
   goto exit_dh_open;
  }
 device = statbuf.st_dev;
 inode = statbuf.st_ino;

 for (dh_file = dh_file_head; dh_file != NULL; dh_file = dh_file->next_file)
  {
   fptr = FPtr(dh_file->file_id);
   if ((device == 0) && (inode == 0))  /* Compare by name */
    {
     if (strcmp((char *)(fptr->pathname), filename) != 0) continue;
    }
   else
    {
     if ((fptr->device != device) || (fptr->inode != inode)) continue;
    }

   /* Found a match */

   if (fptr->ref_ct < 0)   /* Already open for exclusive access */
    {
     dh_err = DHE_EXCLUSIVE;
     goto exit_dh_open;
    }

   dh_file->open_count++;
   goto exit_dh_open;
  }

 /* Open primary subfile */

 sprintf(pathname, "%s%c~0", filename, DS);
 if (access(pathname, 2)) read_only = TRUE;

 fu = dio_open(pathname, (read_only)?DIO_READ:DIO_UPDATE);
 if (!ValidFileHandle(fu))
  {
   dh_err = DHE_FILE_NOT_FOUND;
   goto exit_dh_open;
  }

 /* Validate primary subfile header */

 if (Read(fu, (char *)(&header), DH_HEADER_SIZE) < 0)
  {
   dh_err = DHE_READ_ERROR;
   process.os_error = OSError;
   goto exit_dh_open;
  }

 switch(header.magic)
  {
   case DH_PRIMARY:
      if (header.hash)
       {
        dh_err = DHE_HASH_TYPE;
        goto exit_dh_open;
       }
      break;
   default:
      dh_err = DHE_PSFH_FAULT;
      goto exit_dh_open;
  }

 if ((header.flags & DHF_TRUSTED)    /* Access requires trusted status */
    && (!(process.program.flags & HDR_IS_TRUSTED)))
  {
   dh_err = DHE_TRUSTED;
   goto exit_dh_open;
  }

 /* !!FILE_VERSION!! */
 if (header.file_version > DH_VERSION)
  {
   dh_err = DHE_VERSION;
   goto exit_dh_open;
  }

 /* Check if this file may contain a record id longer than the maximum
    we can support.  The longest_id element of the DH_PARAMS structure
    is set to the length of the longest id written to the file.  This
    record may not be there anymore.  QMFix will sort this out.         */

 if ((header.file_version > 0)
    && (header.params.longest_id > sysseg->maxidlen))
  {
   dh_err = DHE_ID_LEN;
   goto exit_dh_open;
  }

 /* Open overflow subfile */

 sprintf(pathname, "%s%c~1", filename, DS);
 if (access(pathname, 2)) read_only = TRUE;

 ofu = dio_open(pathname, (read_only)?DIO_READ:DIO_UPDATE);
 if (!ValidFileHandle(ofu))
  {
   dh_err = DHE_FILE_NOT_FOUND;
   goto exit_dh_open;
  }

 /* Allocate new DH_FILE structure
    AKs use subfile numbers from AK_BASE_SUBFILE upwards, based on position
    in the AK map. Because AKs can be deleted, there may be gaps in the
    numbering. At this stage, simply find the highest used AK number so that
    we know how big the data structures need to be. We will go through the
    map again once we have created the AK data array.                                          */

 no_of_aks = 0;
 for(i = 0, ak_map = header.ak_map; i < MAX_INDICES; i++, ak_map = ak_map >> 1)
  {
   if (ak_map & 1) no_of_aks = i + 1;  /* Not really  -  There may be gaps */
  }
 no_of_subfiles = AK_BASE_SUBFILE + no_of_aks;

 bytes = sizeof(struct DH_FILE)
         + (sizeof(struct SUBFILE_INFO) * (no_of_subfiles - 1));
 dh_file = (DH_FILE *)k_alloc(9,bytes);
 if (dh_file == NULL)
  {
   dh_err = DHE_OPEN_NO_MEMORY;
   goto exit_dh_open;
  }

 for (i = 0; i < no_of_subfiles; i++) dh_file->sf[i].fu = INVALID_FILE_HANDLE;

 dh_file->file_version = header.file_version;
 dh_file->header_bytes = DHHeaderSize(header.file_version, header.group_size);
 dh_file->ak_header_bytes = AKHeaderSize(header.file_version);
 dh_file->group_size = header.group_size;

 dh_file->no_of_subfiles = no_of_subfiles;
 dh_file->open_count = 1;
 dh_file->flags = 0;
 dh_file->ak_map = header.ak_map;
 dh_file->trigger_name = NULL;
 dh_file->trigger = NULL;
 dh_file->trigger_modes = 0;

 if (read_only) dh_file->flags |= DHF_RDONLY;        /* Read only */



 if (header.akpath[0] == '\0') dh_file->akpath = NULL;
 else
  {
   dh_file->akpath = (char *)k_alloc(106, strlen(header.akpath) + 1);
   strcpy(dh_file->akpath, header.akpath);
  }

 /* Transfer file units into DH_FILE structure so that we do not have
    to open them again on the first access.                           */

 dh_set_subfile(dh_file, PRIMARY_SUBFILE, fu);
 fu = INVALID_FILE_HANDLE;

 dh_set_subfile(dh_file, OVERFLOW_SUBFILE, ofu);
 ofu = INVALID_FILE_HANDLE;

 /* Load trigger function, if any */

 if (header.trigger_name[0] != '\0')
  {
   dh_file->trigger_name = (char *)k_alloc(69,strlen(header.trigger_name) + 1); /* 0259 */
   strcpy(dh_file->trigger_name, header.trigger_name);

   /* Attempt to snap link to trigger function */

   obj = (OBJECT_HEADER *)load_object(header.trigger_name, FALSE);
   if (obj != NULL) obj->ext_hdr.prog.refs += 1;
   dh_file->trigger = (u_char *)obj;
   dh_file->flags |= DHF_TRIGGER;
 
   /* Copy the trigger mode flags. If this file pre-dates the introduction
      of these flags, the byte will be zero. Set the defaults to be as they
      were for old versions of the system.                                 */

   if (header.trigger_modes) dh_file->trigger_modes = header.trigger_modes;
   else dh_file->trigger_modes = TRG_PRE_WRITE | TRG_PRE_DELETE;
  }

 /* Now process any AK indices */

 if (no_of_aks)      /* Has AK indices */
  {
   dh_file->flags |= DHF_AK;

   /* Set up AK data matrix */

   dh_file->ak_data = a_alloc(no_of_aks, AKD_COLS, TRUE);

   for(i = 0, ak_map = header.ak_map; i < no_of_aks; i++, ak_map = ak_map >> 1)
    {
     /* AK field name - Set as null string for now, filled in for used
        entries after we have validated the subfile.                    */

     descr = Element(dh_file->ak_data, (i * AKD_COLS) + AKD_NAME);
     InitDescr(descr, STRING);
     descr->data.str.saddr = NULL;
   
     if (ak_map & 1)
      {
       /* Open AK subfile and validate header */

       subfile = i + AK_BASE_SUBFILE;
       if (!dh_open_subfile(dh_file, filename, subfile, FALSE))
        {
         dh_err = DHE_AK_NOT_FOUND;
         goto exit_dh_open;
        }

       if (!dh_read_group(dh_file, subfile, 0, (char *)(&ak_header),
            DH_AK_HEADER_SIZE))
        {
         dh_err = DHE_AK_HDR_READ_ERROR;
         process.os_error = OSError;
         goto exit_dh_open;
        }

       if (ak_header.magic != DH_INDEX)
        {
         dh_err = DHE_AK_HDR_FAULT;
         goto exit_dh_open;
        }

       /* Cross-check the index subfile with the primary data subfile */

       if (header.creation_timestamp != ak_header.data_creation_timestamp)
        {
         dh_err = DHE_AK_CROSS_CHECK;
         goto exit_dh_open;
        }

       /* Fill in AK name */

       ts_init(&(descr->data.str.saddr), strlen(ak_header.ak_name));
       ts_copy_c_string(ak_header.ak_name);
       (void)ts_terminate();

       /* Field number */

       descr = Element(dh_file->ak_data, (i * AKD_COLS) + AKD_FNO);
       InitDescr(descr, INTEGER);
       descr->data.value = ak_header.fno;

       /* Flags */

       descr = Element(dh_file->ak_data, (i * AKD_COLS) + AKD_FLGS);
       InitDescr(descr, INTEGER);
       descr->data.value = ak_header.flags;

       /* I-type code */

       descr = Element(dh_file->ak_data, (i * AKD_COLS) + AKD_OBJ);
       InitDescr(descr, STRING);
       descr->data.str.saddr = NULL;
       ts_init(&(descr->data.str.saddr), ak_header.itype_len);

       ak_node_num = GetAKFwdLink(dh_file, ak_header.itype_ptr);
       if (ak_node_num != 0)   /* Long expression */
        {
         /* Fetch I-type from separate node */

         ibuff = (char *)k_alloc(53, DH_AK_NODE_SIZE);
         do {
             if (!dh_read_group(dh_file, subfile, ak_node_num, ibuff,
                  DH_AK_NODE_SIZE))
              {
               goto exit_dh_open;
              }

             n = ((DH_ITYPE_NODE *)ibuff)->used_bytes - offsetof(DH_ITYPE_NODE, data);
             ts_copy((char *)(((DH_ITYPE_NODE *)ibuff)->data), n);
             ak_node_num = GetAKFwdLink(dh_file, ((DH_ITYPE_NODE *)ibuff)->next);
            } while(ak_node_num);
        }
       else
        {
         ts_copy((char *)ak_header.itype, ak_header.itype_len);
        }
       (void)ts_terminate();

       descr->data.str.saddr = s_make_contiguous(descr->data.str.saddr, NULL);

       /* Collation map name */

       descr = Element(dh_file->ak_data, (i * AKD_COLS) + AKD_MAPNAME);
       InitDescr(descr, STRING);
       k_put_c_string(ak_header.collation_map_name, descr);

       /* Collation map (contiguous string) */

       descr = Element(dh_file->ak_data, (i * AKD_COLS) + AKD_MAP);
       if (ak_header.collation_map_name[0] == '\0')
        {
         InitDescr(descr, STRING);
         descr->data.str.saddr = NULL;
        }
       else
        {
         k_put_string(ak_header.collation_map, 256, descr);
        }
      }
    }
  }
 else
  {
Esempio n. 15
0
void op_ospath()
{
 /* Stack:

     |================================|=============================|
     |            BEFORE              |           AFTER             |
     |================================|=============================|
 top |  Key                           | Information                 |
     |--------------------------------|-----------------------------| 
     |  Pathname string               |                             |
     |================================|=============================|

 Key values:           Action                             Returns
     0  OS_PATHNAME    Test if valid pathname             True/False
     1  OS_FILENAME    Test if valid filename             True/False
                       or directory file record name
     2  OS_EXISTS      Test if file exists                True/False
     3  OS_UNIQUE      Make a unique file name            Name
     4  OS_FULLPATH    Return full pathname               Name
     5  OS_DELETE      Delete file                        Success/Failure
     6  OS_CWD         Get current working directory      Pathname
     7  OS_DTM         Return date/time modified          DTM value
     8  OS_FLUSH_CACHE Flush DH file cache                -
     9  OS_CD          Change working directory           Success/Failure
    10  OS_MAPPED_NAME Map a directory file name          Mapped name
    11  OS_OPEN        Check if path is an open file      True/False
    12  OS_DIR         Return content of directory        Filenames
    13  OS_MKDIR       Make a directory                   True/False
    14  OS_MKPATH      Make a directory path              True/False

 Pathnames with lengths outside the range 1 to MAX_PATHNAME_LEN return
 0 regardless of the action key.

 */

 long int status = 0;
 short int key;
 DESCRIPTOR * descr;
 char path[MAX_PATHNAME_LEN+1];
 short int path_len;
 char name[MAX_PATHNAME_LEN+1];
 char * p;
 char * q;
 STRING_CHUNK * head;
 int file_id;
 FILE_ENTRY * fptr;
 struct stat stat_buff;
 DIR * dfu;
 struct dirent * dp;
 long int n;

 /* Get action key */

 descr = e_stack - 1;
 GetInt(descr);
 key = (short int)(descr->data.value);
 k_pop(1);

 /* Get pathname */

 descr = e_stack - 1;
 path_len = k_get_c_string(descr, path, MAX_PATHNAME_LEN);
 k_dismiss();
 if (path_len < 0) goto set_status;
#ifdef CASE_INSENSITIVE_FILE_SYSTEM
 UpperCaseString(path);
#endif

 switch(key)
  {
   case OS_PATHNAME:     /* Test if valid pathname */
      p = path;
      if (*p == '/') p++;

      do {
          q = strchr(p, '/');
          if (q != NULL) *q = '\0';
          if (!valid_name(p)) goto set_status;
          p = q + 1;
         } while(q != NULL);
      status = 1;


      break;

   case OS_FILENAME:     /* Test if valid pathname */
      status = (long int)valid_name(path);
      break;

   case OS_EXISTS:     /* Test if file exists */
      status = !access(path, 0);
      break;

   case OS_UNIQUE:  /* Make unique file name. Path variable holds directory name */
      n = (time(NULL) * 10) & 0xFFFFFFFL;
      do {
          sprintf(name, "%s\\D%07lX", path, n);
          n--;
         } while(!access(name, 0));
      sprintf(name, "D%07lX", n);
      k_put_c_string(name, e_stack);
      e_stack++;
      goto exit_op_pathinfo;

   case OS_FULLPATH:     /* Expand path to full OS pathname */
      fullpath(name, path);
      k_put_c_string(name, e_stack);
      e_stack++;
      goto exit_op_pathinfo;

   case OS_DELETE:
      flush_dh_cache();
      status = (long int)delete_path(path);
      break;

   case OS_CWD:
      (void)getcwd(name, MAX_PATHNAME_LEN);
#ifdef CASE_INSENSITIVE_FILE_SYSTEM
      UpperCaseString(name);
#endif
      k_put_c_string(name, e_stack);
      e_stack++;
      goto exit_op_pathinfo;

   case OS_DTM:
      if (stat(path, &stat_buff) == 0) status = stat_buff.st_mtime;
      break;

   case OS_FLUSH_CACHE:
      flush_dh_cache();
      break;

   case OS_CD:
      status = attach(path);
      break;

   case OS_MAPPED_NAME:    /* Map a directory file record name */
      (void)map_t1_id(path, strlen(path), name);
      k_put_c_string(name, e_stack);
      e_stack++;
      goto exit_op_pathinfo;

   case OS_OPEN:
      fullpath(name, path);
      for(file_id = 1; file_id <= sysseg->used_files; file_id++)
       {
        fptr = FPtr(file_id);
        if ((fptr->ref_ct != 0)
          && (strcmp((char *)(fptr->pathname), name) == 0))
         {
          status = TRUE;
          break;
         }
       }
      break;

   case OS_DIR:
      head = NULL;
      ts_init(&head, 1024);
      if ((dfu = opendir(path)) != NULL)
       {
        if (path[path_len-1] == DS) path[path_len-1] = '\0';

        while((dp = readdir(dfu)) != NULL)
         {
          if (strcmp(dp->d_name, ".") == 0) continue;
          if (strcmp(dp->d_name, "..") == 0) continue;

          sprintf(name, "%s%c%s", path, DS, dp->d_name);
          if (stat(name, &stat_buff)) continue;

          strcpy(name+1, dp->d_name);
#ifdef CASE_INSENSITIVE_FILE_SYSTEM
          UpperCaseString(name+1);
#endif
          if (stat_buff.st_mode & S_IFDIR)
           {
            name[0] = 'D';
            if (head != NULL) ts_copy_byte(FIELD_MARK);
            ts_copy_c_string(name);
           }
          else if (stat_buff.st_mode & S_IFREG)
           {
            name[0] = 'F';
            if (head != NULL) ts_copy_byte(FIELD_MARK);
            ts_copy_c_string(name);
           }
         }

        closedir(dfu);
       }
      ts_terminate();
      InitDescr(e_stack, STRING);
      (e_stack++)->data.str.saddr = head;
      goto exit_op_pathinfo;      

   case OS_MKDIR:
      status = !MakeDirectory(path);
      break;

   case OS_MKPATH:
      status = make_path(path);
      break;
       
   default:
      k_error(sysmsg(1010));
  }

set_status:

 /* Set status value on stack */

 InitDescr(e_stack, INTEGER);
 (e_stack++)->data.value = status;

exit_op_pathinfo:
 return;
}
Esempio n. 16
0
Private STRING_CHUNK * get_file_status(FILE_VAR * fvar)
{
 STRING_CHUNK * str = NULL;
 u_char ftype;
 DH_FILE * dh_file;
 SQ_FILE * sq_file;
 int64 file_size = 0;
 int file_type_num = 0;
 bool is_seq = FALSE;
 char * path;
 int64 n64;
 struct stat statbuf;

 memset(&statbuf, 0, sizeof(statbuf));

 ftype = fvar->type;
 path = (char *)(FPtr(fvar->file_id)->pathname);

 /* !!FVAR_TYPES!! */
 switch(ftype)
  {
   case DYNAMIC_FILE:
      file_type_num = FL_TYPE_DH;
      dh_file = fvar->access.dh.dh_file;
      FDS_open(dh_file, PRIMARY_SUBFILE);
      fstat(dh_file->sf[PRIMARY_SUBFILE].fu, &statbuf);
      file_size = dh_filesize(dh_file, PRIMARY_SUBFILE) + dh_filesize(dh_file, OVERFLOW_SUBFILE);
      break;

   case DIRECTORY_FILE:
      file_type_num = FL_TYPE_DIR;
      stat((char *)(FPtr(fvar->file_id)->pathname), &statbuf);
      file_size = dir_filesize(fvar);
      break;

   case SEQ_FILE:
      file_type_num = FL_TYPE_SEQ;
      is_seq = TRUE;
      sq_file = fvar->access.seq.sq_file;
      if (!(sq_file->flags & SQ_NOTFL)) fstat(sq_file->fu, &statbuf);
      file_size = statbuf.st_size;
      path = sq_file->pathname;
      break;

  }

 ts_init(&str, 128);

 /* 1  File position */
 n64 = (is_seq)?sq_file->posn:0;
 ts_printf("%lld\xfe", n64);

 /* 2  At EOF? */
 ts_printf("%d\xfe", (is_seq)?sq_file->posn == file_size:0);

 /* 3  Not used */
 ts_printf("\xfe");

 /* 4  Bytes available to read */
 n64 = (is_seq)?(file_size - sq_file->posn):0;
 ts_printf("%lld\xfe", n64);

 /* 5  File mode */
 ts_printf("%u\xfe", statbuf.st_mode & 0777);

 /* 6  File size */
 ts_printf("%lld\xfe", file_size);

 /*  7  Hard links */
 ts_printf("%d\xfe", statbuf.st_nlink);

 /*  8  UID of owner */
 ts_printf("%d\xfe", statbuf.st_uid);

 /*  9  GID of owner */
 ts_printf("%d\xfe", statbuf.st_gid);

 /* 10  Inode number */
 ts_printf("%d\xfe", statbuf.st_ino);

 /* 11  Device number */
 ts_printf("%d\xfe", statbuf.st_dev);

 /* 12  Not used */
 ts_printf("\xfe");

 /* 13  Time of last access */
 ts_printf("%d\xfe", statbuf.st_atime % 86400);

 /* 14  Date of last access */
 ts_printf("%d\xfe", (statbuf.st_atime / 86400) + 732);

 /* 15  Time of last modification */
 ts_printf("%d\xfe", statbuf.st_mtime % 86400);

 /* 16  Date of last modification */
 ts_printf("%d\xfe", (statbuf.st_mtime / 86400) + 732);

 /* 17 - 19 unused */
 ts_printf("\xfe\xfe\xfe");

 /* 20  Operating system file name */
 ts_printf("%s\xfe", path);

 /* 21  File type */
 ts_printf("%d", file_type_num);

 (void)ts_terminate();

 return str;
}
Esempio n. 17
0
void op_field()
{
 /* Stack:

     |=============================|=============================|
     |            BEFORE           |           AFTER             |
     |=============================|=============================|
 top |  Number of fields           | Substring                   |
     |-----------------------------|-----------------------------| 
     |  Occurrence number          |                             |
     |-----------------------------|-----------------------------| 
     |  Delimiter                  |                             |
     |-----------------------------|-----------------------------| 
     |  Source string              |                             |
     |=============================|=============================|
 */

 DESCRIPTOR * descr;            /* Various descriptors */
 long int num_fields;
 long int occurrence;
 char delimiter;
 STRING_CHUNK * delim_str;
 DESCRIPTOR result_descr;       /* Result string */
 STRING_CHUNK * src_str;
 short int src_bytes_remaining;
 char * src;
 char * p;
 short int len;
 bool nocase;

 nocase = (process.program.flags & HDR_NOCASE) != 0;

 process.program.col1 = 0;
 process.program.col2 = 0;

 /* Get number of fields to return */

 descr = e_stack - 1;
 GetInt(descr);
 num_fields = descr->data.value;
 if (num_fields < 1) num_fields = 1;

 /* Get start field position */

 descr = e_stack - 2;
 GetInt(descr);
 occurrence = descr->data.value;
 if (occurrence < 1) occurrence = 1;
 k_pop(2);

 /* Get delimiter character */

 descr = e_stack - 1;
 k_get_string(descr);
 if ((delim_str = descr->data.str.saddr) != NULL)
  {
   delimiter = delim_str->data[0];
   if (nocase) delimiter = UpperCase(delimiter);
  }
 k_dismiss();

 /* Get source string */

 descr = e_stack - 1;
 k_get_string(descr);
 src_str = descr->data.str.saddr;
 if (src_str == NULL) goto exit_op_field;     /* Return source string */

 if (delim_str == NULL)      /* Delimiter is null string */
  {
   process.program.col2 = src_str->string_len + 1;
   goto exit_op_field;     /* Return source string */
  }

 /* Set up a string descriptor to receive the result */

 InitDescr(&result_descr, STRING);
 result_descr.data.str.saddr = NULL;
 ts_init(&(result_descr.data.str.saddr), 32);


 /* Walk the string looking for the start of this item */

 src = src_str->data;
 src_bytes_remaining = src_str->bytes;

 if (occurrence-- == 1) goto found_start;

 do {
     process.program.col1 += src_str->bytes;
     while(src_bytes_remaining)
      {
       if (nocase)
        {
         p = (char *)memichr(src, delimiter, src_bytes_remaining);
        }
       else
        {
         p = (char *)memchr(src, delimiter, src_bytes_remaining);
        }
       if (p == NULL) break;     /* No delimiter in this chunk */

       src_bytes_remaining -= (p - src) + 1;
       src = p + 1;

       if (--occurrence == 0)
        {
         process.program.col1 -= src_bytes_remaining;
         goto found_start;
        }
      }

     if ((src_str = src_str->next) == NULL)
      {
       process.program.col1 = 0;
       goto return_null_string; /* We did not find the desired field */
      }

     src = src_str->data;
     src_bytes_remaining = src_str->bytes;
    } while(TRUE);

found_start:
  /* We have found the start of the field and its offset is in col1. Now
     copy the specified number of fields to the result string.            */

 do {
     /* Look for delimiter in the current chunk */

     while(src_bytes_remaining)
      {
       if (nocase)
        {
         p = (char *)memichr(src, delimiter, src_bytes_remaining);
        }
       else
        {
         p = (char *)memchr(src, delimiter, src_bytes_remaining);
        }
       if (p != NULL)      /* Found delimiter */
        {
         len = p - src;
         if (len) ts_copy(src, len);     /* Copy up to delimiter */

         src_bytes_remaining -= len + 1;
         src = p + 1;
         if (--num_fields == 0) goto found_end;

         ts_copy_byte(*p);        /* Copy delimiter */
        }
       else /* No delimiter - copy all to target */
        {
         ts_copy(src, src_bytes_remaining);
         break;
        }
      }

     if ((src_str = src_str->next) == NULL) break;

     src = src_str->data;
     src_bytes_remaining = src_str->bytes;
    } while(1);

found_end:
 process.program.col2 = process.program.col1 + ts_terminate() + 1;

return_null_string:
 k_dismiss();          /* Dismiss source string */

 *(e_stack++) = result_descr;

exit_op_field:
 return;
}
Esempio n. 18
0
void op_extract()
{
 /* Stack:

     |=============================|=============================|
     |            BEFORE           |           AFTER             |
     |=============================|=============================|
 top |  Subvalue number            | Substring                   |
     |-----------------------------|-----------------------------| 
     |  Value number               |                             |
     |-----------------------------|-----------------------------| 
     |  Field number               |                             |
     |-----------------------------|-----------------------------| 
     |  Source string              |                             |
     |=============================|=============================|
 */

 DESCRIPTOR * field_descr;      /* Position descriptor */
 DESCRIPTOR * value_descr;      /* Position descriptor */
 DESCRIPTOR * subvalue_descr;   /* Position descriptor */
 DESCRIPTOR * src_descr;        /* Source string */
 DESCRIPTOR result_descr;       /* Result string */
 long int field;
 long int value;
 long int subvalue;
 short int offset;
 STRING_CHUNK * str_hdr;
 short int bytes_remaining;
 short int len;
 char * p;
 char * q;
 bool end_on_value_mark;
 bool end_on_subvalue_mark;
 register char c;


 subvalue_descr = e_stack - 1;
 value_descr = e_stack - 2;
 field_descr = e_stack - 3;

 GetInt(subvalue_descr);
 subvalue = subvalue_descr->data.value;

 GetInt(value_descr);
 value = value_descr->data.value;

 GetInt(field_descr);
 field = field_descr->data.value;

 k_pop(3);

 /* Set up a string descriptor on our C stack to receive the result */

 InitDescr(&result_descr, STRING);
 result_descr.data.str.saddr = NULL;
 ts_init(&result_descr.data.str.saddr, 32);

 if (field <= 0)      /* Field zero or negative  -  Return null string */
  {
   goto done;
  }
 else if (value == 0) /* Extracting field */
  {
   end_on_value_mark = FALSE;
   end_on_subvalue_mark = FALSE;
   value = 1;
   subvalue = 1;
  }
 else if (subvalue == 0) /* Extracting value */
  {
   end_on_value_mark = TRUE;
   end_on_subvalue_mark = FALSE;
   subvalue = 1;
  }
 else /* Extracting subvalue */
  {
   end_on_value_mark = TRUE;
   end_on_subvalue_mark = TRUE;
  }

 src_descr = e_stack - 1;
 k_get_string(src_descr);
 str_hdr = src_descr->data.str.saddr;

 if (find_item(str_hdr, field, value, subvalue, &str_hdr, &offset))
  {
   if (str_hdr == NULL) goto done;

   p = str_hdr->data + offset;
   bytes_remaining = str_hdr->bytes - offset;

   while(1)
    {
     /* Is there any data left in this chunk? */

     if (bytes_remaining)
      {
       /* Look for delimiter in the current chunk */

       for (q = p; bytes_remaining-- > 0; q++)
        {
         c = *q;
         if ((IsDelim(c))
          && ((c == FIELD_MARK)
             || ((c == VALUE_MARK) && end_on_value_mark)
             || ((c == SUBVALUE_MARK) && end_on_subvalue_mark)))
          {
           /* Copy up to mark */

           len = q - p;
           if (len > 0) ts_copy(p, len);

           goto done;
          }
        }

       /* Copy remainder of this chunk (must be at least one byte) */

       ts_copy(p, q - p);
      }

     if ((str_hdr = str_hdr->next) == NULL) break;

     p = str_hdr->data;
     bytes_remaining = str_hdr->bytes;
    }
  }

done:
 ts_terminate();

 k_dismiss();   /* Dismiss source string ADDR */

 *(e_stack++) = result_descr;
}
Esempio n. 19
0
Private void rdi(
   DESCRIPTOR * src_descr,        /* Source string */
   long int field,
   long int value,
   long int subvalue,
   short int mode,
   DESCRIPTOR * new_descr,        /* Replacement / insertion string */
   DESCRIPTOR * result_descr,     /* Resultant string */
   bool compatible)               /* Append style ($MODE COMPATIBLE.APPEND) */
{
 long int f, v, sv;
 STRING_CHUNK * str_hdr;
 short int bytes_remaining;
 STRING_CHUNK * new_str;
 short int len;
 char * p;
 bool done;
 char c;
 char mark;
 bool mark_skipped = FALSE;
 bool end_on_value_mark;
 bool end_on_subvalue_mark;
 bool item_found;
 char last_char = '\0';


 str_hdr = src_descr->data.str.saddr;

 /* Set up a string descriptor to receive the result */

 InitDescr(result_descr, STRING);
 result_descr->data.str.saddr = NULL;
 ts_init(&(result_descr->data.str.saddr), (str_hdr == NULL)?64:str_hdr->string_len);


 if (field == 0) field = 1;

 if (value == 0) /* <n, 0, 0> */
  {
   end_on_value_mark = FALSE;
   end_on_subvalue_mark = FALSE;
   value = 1;
   subvalue = 1;
   mark = FIELD_MARK;
  }
 else if (subvalue == 0) /* <n, n, 0> */
  {
   end_on_value_mark = TRUE;
   end_on_subvalue_mark = FALSE;
   subvalue = 1;
   mark = VALUE_MARK;
  }
 else /* <n, n, n> */
  {
   end_on_value_mark = TRUE;
   end_on_subvalue_mark = TRUE;
   mark = SUBVALUE_MARK;
  }

 f = 1; v = 1; sv = 1;   /* Current position */
 bytes_remaining = 0;    /* For null string path */

 /* Copy to start of selected item */

 if ((field == 1) && (value == 1) && (subvalue == 1))
  {  /* <1,0,0> or <1,1,0> or <1,1,1> */
   if (str_hdr != NULL)
    {
     p = str_hdr->data;
     bytes_remaining = str_hdr->bytes;
    }
   item_found = TRUE;
   goto found; 
  }

 /* Walk the string to the desired item */

 if (str_hdr != NULL)
  {
   do {
       p = str_hdr->data;
       bytes_remaining = str_hdr->bytes;

       do {
           c = *p;
           if (IsDelim(c))
            {
             switch(c)
              {
               case FIELD_MARK:
                  if (f == field) goto not_found; /* No such value or subvalue */
                  f++;
                  v = 1;
                  sv = 1;
                  break;

               case VALUE_MARK:
                  if ((f == field) && (v == value))
                   {
                    goto not_found; /* No such subvalue */
                   }
                  v++;
                  sv = 1;
                  break;  
  
               case SUBVALUE_MARK:
                  sv++;
                  break;
              }

             if ((f == field) && (v == value) && (sv == subvalue))
              {
               p++;
               bytes_remaining--;
               item_found = TRUE;
               goto found; /* At start position */
              }
            }
           last_char = c;
           p++;
          } while(--bytes_remaining);

       /* Copy all of source chunk just searched */
  
       ts_copy(str_hdr->data, str_hdr->bytes);
      } while((str_hdr = str_hdr->next) != NULL);
  }
      
 /* We have reached the end of the string without finding the field we
    were looking for.                                                  */


not_found:
          
found:

 if (str_hdr != NULL) /* Not run off end of string */
  {
   /* Copy up to current position in source chunk */

   len = p - str_hdr->data;

   if ((mode == DYN_DELETE) && (len > 0) && (c == mark)) /* Don't copy this mark */
    {
     mark_skipped = TRUE;
     len--;
    }

   if (len > 0) ts_copy(str_hdr->data, len);
  
  /* Skip old data if we are doing REPLACE or DELETE */
  
   if (item_found)
    {
     switch(mode)
      {
       case DYN_REPLACE:
       case DYN_DELETE:
          done = FALSE;

          /* Skip old item */
    
          do {
              /* Is there any data left in this chunk? */
    
              if (bytes_remaining > 0)
               {
                /* Look for delimiter in the current chunk */
    
                do {
                    c = *p;
                    if ((IsDelim(c))
                     && ((c == FIELD_MARK)
                        || ((c == VALUE_MARK) && end_on_value_mark)
                        || ((c == SUBVALUE_MARK) && end_on_subvalue_mark)))
                     {
                      done = TRUE;
                      break;
                     }
                    p++;
                   } while(--bytes_remaining);
               }

              if (!done) /* Find next chunk */
               {
                if (str_hdr->next == NULL) done = TRUE;
                else
                 {
                  str_hdr = str_hdr->next;
                  p = str_hdr->data;
                  bytes_remaining = str_hdr->bytes;
                 }
               }
             } while(!done);
  
          if ((mode == DYN_DELETE) && !mark_skipped && (c == mark))
           {
            /* Skip the mark too */
            p++;
            bytes_remaining--;
           }
          break;
      }
    }
  }

 /* Insert new data for REPLACE or INSERT */
 
 switch(mode)
  {
   case DYN_REPLACE:
   case DYN_INSERT:
      /* We may not be at the desired position. For example, if we try to
         insert <3,2,2> we might not have the necessary number of fields,
         values or subvalues to get to this position. We must insert marks
         to get us to the right position.                                  */

      if (result_descr->data.str.saddr != NULL) /* Not at start of string */
       {
        if (field < 0)
         {
          if (compatible && last_char == FIELD_MARK)
           {
            f = 1;       /* Kill mark insertion */
            field = 1;
           }
          else
           {
            field = f + 1; /* Insert a single field mark */
           }
          v = 1;
          sv = 1;
         }
        else if (value < 0)
         {
          if ((field != f)                /* No mark if adding new field... */
           || (last_char == FIELD_MARK)   /* ... or at start of a field */
           || (compatible && last_char == VALUE_MARK))
           {
            v = 1;        /* 0222 Set both to one to kill mark insertion */
            value = 1;
           }
          else value = v + 1;
          sv = 1;
         }
        else if (subvalue < 0)
         {
          if ((field != f)                /* No mark if adding new field... */
           || (value != v)                /* ...or adding new value... */
           || (last_char == FIELD_MARK)   /* ...or at start of a field... */
           || (last_char == VALUE_MARK)   /* ...or at start of a value */
           || (compatible && last_char == SUBVALUE_MARK))
           {
            sv = 1;       /* 0222 Set both to one to kill mark insertion */
            subvalue = 1;
           }
          else subvalue = sv + 1;
         }
       }

      while(f < field)
       {
        ts_copy_byte(FIELD_MARK);
        f++;
        v = 1;
        sv = 1;
       }

      while(v < value)
       {
        ts_copy_byte(VALUE_MARK);
        v++;
        sv = 1;
       }

      while(sv < subvalue)
       {
        ts_copy_byte(SUBVALUE_MARK);
        sv++;
       }

      /* Insert replacement item */
      
      for (new_str = new_descr->data.str.saddr;
           new_str != NULL;
           new_str = new_str->next)
       {
        ts_copy(new_str->data, new_str->bytes);
       }

      /* For insert mode, if we are not at the end of the source string and
         the next character of the source string is not a mark we must
         insert a mark to delimit the new data from the following item.     */

      if ((mode == DYN_INSERT) && (str_hdr != NULL))
       {
        if (bytes_remaining == 0) /* Mark was at end of chunk */
         {
          if ((str_hdr = str_hdr->next) == NULL) goto no_mark_required;
          p = str_hdr->data;
          bytes_remaining = str_hdr->bytes;
         }


        if ((!IsDelim(*p)) || (*p <= mark)) ts_copy_byte(mark);
       }
no_mark_required:     
      break;
  }

 /* Copy remainder of source string */

 if (str_hdr != NULL)
  { 
   /* Is there any data left in this chunk? */

   if (bytes_remaining > 0) ts_copy(p, bytes_remaining);

   /* Copy any remaining chunks */

   while((str_hdr = str_hdr->next) != NULL)
    {
     ts_copy(str_hdr->data, str_hdr->bytes);
    }
  }

 ts_terminate();
}
Esempio n. 20
0
void op_fileinfo()
{
 /* Stack:

     |================================|=============================|
     |            BEFORE              |           AFTER             |
     |================================|=============================|
 top |  Key                           | Information                 |
     |--------------------------------|-----------------------------| 
     |  ADDR to file variable         |                             |
     |================================|=============================|

 Key values:           Action                         Returns
     0 FL_OPEN         Test if is open file variable  True/False
     1 FL_VOCNAME      Get VOC name of file           VOC name
     2 FL_PATH         Get file pathname              Pathname
     3 FL_TYPE         Check file type                DH:         FL_TYPE_DH  (3)
                                                      Directory:  FL_TYPE_DIR (4)
                                                      Sequential: FL_TYPE_SEQ (5)
     5 FL_MODULUS      File modulus                   Modulus value
     6 FL_MINMOD       Minimum modulus                Minimum modulus value
     7 FL_GRPSIZE      Group size                     Group size
     8 FL_LARGEREC     Large record size              Large record size
     9 FL_MERGE        Merge load percentage          Merge load
    10 FL_SPLIT        Split load percentage          Split load
    11 FL_LOAD         Current load percentage        Current load
    13 FL_AK           File has AK indices?           Boolean
    14 FL_LINE         Number of next line            Line number
  1000 FL_LOADBYTES    Current load in bytes          Current load bytes
  1001 FL_READONLY     Read only file?                Boolean
  1002 FL_TRIGGER      Get trigger function name      Call name
  1003 FL_PHYSBYTES    Physical file size             Size in bytes, excl indices
  1004 FL_VERSION      File version
  1005 FL_STATS_QUERY  Query file stats status        Boolean
  1006 FL_SEQPOS       File position                  File offset
  1007 FL_TRG_MODES    Get trigger modes              Mode mask
  1008 FL_NOCASE       File uses case insensitive ids?  Boolean
  1009 FL_FILENO       Return internal file number    File number
  1010 FL_JNL_FNO      Return journalling file no     File no, zero if not journalling
  1011 FL_AKPATH       Returns AK subfile location    Pathname of directory
  1012 FL_ID           Id of last record read         Id
  1013 FL_STATUS       As STATUS statement            Dynamic array
  1014 FL_MARK_MAPPING Is mark mapping enabled?       Boolean
  1015 FL_RECORD_COUNT Approximate record count
  1016 FL_PRI_BYTES    Primary subfile size in bytes
  1017 FL_OVF_BYTES    Overflow subfile size in bytes
  1018 FL_NO_RESIZE    Resizing inhibited?
  1019 FL_UPDATE       Update counter
  1020 FL_ENCRYPTED    File uses encryption?          Boolean
 10000 FL_EXCLUSIVE    Set exclusive access           Successful?
 10001 FL_FLAGS        Fetch file flags               File flags
 10002 FL_STATS_ON     Turn on file statistics
 10003 FL_STATS_OFF    Turn off file statistics
 10004 FL_STATS        Return file statistics
 10005 FL_SETRDONLY    Set file as read only
 */

 short int key;
 DESCRIPTOR * descr;
 FILE_VAR * fvar;
 DH_FILE * dh_file;
 char * p = NULL;
 long int n = 0;
 FILE_ENTRY * fptr;
 OSFILE fu;
 bool dynamic;
 bool internal;
 long int * q;
 STRING_CHUNK * str;
 short int i;
 double floatnum;
 u_char ftype;
 int64 n64;


 /* Get action key */

 descr = e_stack - 1;
 GetInt(descr);
 key = (short int)(descr->data.value);
 k_pop(1);

 /* Get file variable */

 descr = e_stack - 1;
 while(descr->type == ADDR) {descr = descr->data.d_addr;}


 if (key == FL_OPEN)    /* Test if file is open */
  {
   n = (descr->type == FILE_REF);
  }
 else
  {
   if (descr->type != FILE_REF) k_error(sysmsg(1200));

   fvar = descr->data.fvar;
   ftype = fvar->type;
   if (ftype == NET_FILE)  /* Network file */
    {
     str = net_fileinfo(fvar, key);
     k_dismiss();
     InitDescr(e_stack, STRING);
     (e_stack++)->data.str.saddr = str;
     return;
    }


   fptr = FPtr(fvar->file_id);

   dynamic = (ftype == DYNAMIC_FILE);
   if (dynamic) dh_file = fvar->access.dh.dh_file;

   internal = ((process.program.flags & HDR_INTERNAL) != 0);
   switch(key)
    {
     case FL_VOCNAME:     /* 1  VOC name of file */
        if (fvar->voc_name != NULL) p = fvar->voc_name;
        else p = "";
        goto set_string;

     case FL_PATH:        /* 2  File pathname */
        p = (char *)(fptr->pathname);
        goto set_string;

     case FL_TYPE:        /* 3  File type */
        /* !!FVAR_TYPES!! */
        switch(ftype)
         {
          case DYNAMIC_FILE:
             n = FL_TYPE_DH;
             break;
          case DIRECTORY_FILE:
             n = FL_TYPE_DIR;
             break;
          case SEQ_FILE:
             n = FL_TYPE_SEQ;
             break;
         }
        break;

     case FL_MODULUS:     /* 5  Modulus of file */
        if (dynamic) n = fptr->params.modulus;
        break;

     case FL_MINMOD:      /* 6  Minimum modulus of file */
        if (dynamic) n = fptr->params.min_modulus;
        break;

     case FL_GRPSIZE:     /* 7  Group size of file */
        if (dynamic) n = dh_file->group_size / DH_GROUP_MULTIPLIER;
        break;

     case FL_LARGEREC:    /* 8  Large record size */
        if (dynamic) n = fptr->params.big_rec_size;
        break;

     case FL_MERGE:       /* 9  Merge load percentage */
        if (dynamic) n = fptr->params.merge_load;
        break;

     case FL_SPLIT:       /* 10  Split load percentage */
        if (dynamic) n = fptr->params.split_load;
        break;

     case FL_LOAD:        /* 11  Load percentage */
        if (dynamic)
         {
          n = DHLoad(fptr->params.load_bytes, dh_file->group_size, fptr->params.modulus);
         }
        break;

     case FL_AK:          /* 13  File has AKs? */
        if (dynamic) n = (dh_file->ak_map != 0);
        break;

     case FL_LINE:        /* 14  Sequential file line position */
        if (ftype == SEQ_FILE)
         {
          n64 = fvar->access.seq.sq_file->line;
          if (n64 > LONG_MAX)
           {
            floatnum = (double)n64;
            goto set_float;
           }
          n = (long)n64;
         }
        break;

     case FL_LOADBYTES:   /* 1000  Load bytes */
        if (dynamic)
         {
          floatnum = (double)(fptr->params.load_bytes);
          goto set_float;
         }
        break;

     case FL_READONLY:    /* 1001  Read-only? */
        n = ((fvar->flags & FV_RDONLY) != 0);
        break;

     case FL_TRIGGER:     /* 1002  Trigger function name */
        if (dynamic)
         {
          p = dh_file->trigger_name;
          goto set_string;
         }
        break;

     case FL_PHYSBYTES:   /* 1003  Physical file size */
        switch(ftype)
         {
          case DIRECTORY_FILE:
             floatnum = (double)dir_filesize(fvar);
             break;
          case DYNAMIC_FILE:
             floatnum = (double)dh_filesize(dh_file, PRIMARY_SUBFILE) + dh_filesize(dh_file, OVERFLOW_SUBFILE);
             break;
          case SEQ_FILE:
             fu = fvar->access.seq.sq_file->fu;
             floatnum = (double)(ValidFileHandle(fu)?filelength64(fu):-1);
             break;
         }
        goto set_float;

     case FL_VERSION:     /* 1004  File version */
        if (dynamic) n = dh_file->file_version;
        break;

     case FL_STATS_QUERY: /* 1005  File statistics enabled? */
        if (dynamic) n = (fptr->stats.reset != 0);
        break;

     case FL_SEQPOS:      /* 1006  Sequential file offset */
        if (ftype == SEQ_FILE)
         {
          n64 = fvar->access.seq.sq_file->posn;
          if (n64 > LONG_MAX)
           {
            floatnum = (double)n64;
            goto set_float;
           }
          n = (long)n64;
         }
        break;

     case FL_TRG_MODES:   /* 1007  Trigger modes */
        if (dynamic) n = dh_file->trigger_modes;
        break;

     case FL_NOCASE:      /* 1008  Case insensitive ids? */
        switch(ftype)
         {
          case DIRECTORY_FILE:
          case DYNAMIC_FILE:
             n = (fptr->flags & DHF_NOCASE) != 0;
             break;
         }
        break;

     case FL_FILENO:      /* 1009  Internal file number */
        n = fvar->file_id;
        break;

     case FL_JNL_FNO:     /* 1010  Journalling file number */
        break;

     case FL_AKPATH:      /* 1011  AK subfile pathname */
        if (dynamic)
         {
          p = dh_file->akpath;
          goto set_string;
         }
        break;

     case FL_ID:          /* 1012  Id of last record read */
        k_dismiss();
        k_put_string(fvar->id, fvar->id_len, e_stack);
        e_stack++;
        return;

     case FL_STATUS:      /* 1013  STATUS array */
        str = get_file_status(fvar);
        k_dismiss();
        InitDescr(e_stack, STRING);
        (e_stack++)->data.str.saddr = str;
        return;

     case FL_MARK_MAPPING: /* 1014  Mark mapping enabled? */
        if (ftype == DIRECTORY_FILE) n = fvar->access.dir.mark_mapping;
        break;

     case FL_RECORD_COUNT: /* 1015  Approximate record count */
        if (dynamic)
         {
          floatnum = (double)(fptr->record_count);
          goto set_float;
         }
        else n = -1;

     case FL_PRI_BYTES:   /* 1016  Physical size of primary subfile */
        if (dynamic)
         {
          floatnum = (double)dh_filesize(dh_file, PRIMARY_SUBFILE);
          goto set_float;
         }
        break;

     case FL_OVF_BYTES:   /* 1017  Physical size of overflow subfile */
        if (dynamic)
         {
          floatnum = (double)dh_filesize(dh_file, OVERFLOW_SUBFILE);
          goto set_float;
         }
        break;

     case FL_NO_RESIZE:   /* 1018  Resizing inhibited? */
        if (dynamic) n = ((fptr->flags & DHF_NO_RESIZE) != 0);
        break;

     case FL_UPDATE:      /* 1019  File update counter */
        n = (long)(fptr->upd_ct);
        break;

     case FL_ENCRYPTED:   /* 1020  File uses encryption? */
        /* Recognised but returns default zero */
        break;

     case FL_EXCLUSIVE:   /* 10000  Set exclusive access mode */
        if (internal)
         {
          /* To gain exclusive access to a file it must be open only to this
             process (fptr->ref_ct = 1) and must not be open more than once
             in this process.  The latter condition only affects dynamic files
             as other types produce multiply referenced file table entries.
             We need to ensure a dynamic file is only open once so that when
             we close the file we really are going to kill off the DH_FILE
             structure. This is essential, for example, in AK creation where
             the DH_FILE structure has to change its size.                   */

          flush_dh_cache();    /* Ensure we are not stopped by a cached
                                  reference from our own process.       */
          n = FALSE;
          for (i = 0; i < 6; i++)
           {
            StartExclusive(FILE_TABLE_LOCK, 37);
            if ((fptr->ref_ct == 1)
               && ((ftype != DYNAMIC_FILE) || (dh_file->open_count == 1)))
             {
              fptr->ref_ct = -1;
              fptr->fvar_index = fvar->index;
              n = TRUE;
             }
            EndExclusive(FILE_TABLE_LOCK);

            if (n) break;

            if (i == 0)  /* First attempt */
             {
              /* Cannot gain exclusive access. Maybe some other process has
                 the file in its DH cache. Fire an EVT_FLUSH_CACHE event to
                 all processes to see if this clears the problem. We then
                 continue trying for a short time until either we get the
                 required access or we reach our retry count.              */
              raise_event(EVT_FLUSH_CACHE, -1);
             }

            Sleep(500);   /* Pause for something to happen */
           }
         }
        break;

     case FL_FLAGS:       /* 10001  File flags */
        if (dynamic && internal) n = (long int)(dh_file->flags);
        break;

     case FL_STATS_ON:    /* 10002  Enable file statistics */
        if (dynamic && internal)
         {
          memset((char *)&(fptr->stats), 0, sizeof(struct FILESTATS));
          fptr->stats.reset = qmtime();
         }
        break;

     case FL_STATS_OFF:   /* 10003  Disable file statistics */
        if (dynamic && internal) fptr->stats.reset = 0;
        break;

     case FL_STATS:       /* 10004  Return file statistics data */
        if (dynamic && internal)
         {
          str = NULL;
          ts_init(&str, 5 * FILESTATS_COUNTERS);
          for (i = 0, q = (long int *)&(fptr->stats.reset); i < FILESTATS_COUNTERS; i++, q++)
           {
            ts_printf("%ld\xfe", *q);
           }
          (void)ts_terminate();
          k_dismiss();    /* 0363 */
          InitDescr(e_stack, STRING);
          (e_stack++)->data.str.saddr = str;
          return;
         }
        break;

     case FL_SETRDONLY:   /* 10005  Set read-only */
        if (internal)
         {
          fvar->flags |= FV_RDONLY;
          if (dynamic) dh_file->flags |= DHF_RDONLY;
         }
        break;

     default:
        k_error(sysmsg(1010));
    }
  }

 /* Set integer return value on stack */

set_integer:
 k_dismiss();
 InitDescr(e_stack, INTEGER);
 (e_stack++)->data.value = n;
 return;

/* Set string return value on stack */

set_string:
 k_dismiss();
 k_put_c_string(p, e_stack);
 e_stack++;
 return;

set_float:
 if (floatnum <= (double)LONG_MAX)
  {
   n = (long)floatnum;
   goto set_integer;
  }

 k_dismiss();
 InitDescr(e_stack, FLOATNUM);
 (e_stack++)->data.float_value = floatnum;
 return;
}
Esempio n. 21
0
int main()
{
	char c;
	
	init_uart();
	lcd_init();
	lcd_enable();

	ts_init();

	ts_calibrate();
	
	printf("can update program with serial port\n\r");

	while (1)
	{
		printf("[w] write the nand flash\n\r");
		printf("[r] read the nand flash\n\r");
		printf("[e] erase the nand flash\n\r");
		printf("[g] get file, and write to nand flash 0 block\n\r");
		printf("[x] get file to ddr(0x52000000), run it\n\r");
		printf("[t] test lcd\n\r");
		printf("[s] test touch screem\n\r");

		do {
			c = getc();
			if (c == '\n' || c == '\r')
			{
				printf("\n\r");
			}
			else
			{
				putc(c);
			}
		} while (c == '\n' || c == '\r');
		
		switch (c)
		{
			case 'w':
			case 'W':
			{
				nand_write_test();
				break;
			}

			case 'r':
			case 'R':
			{
				nand_read_test();
				break;
			}

			case 'e':
			case 'E':
			{
				nand_erase_test();
				break;
			}

			case 'g':
			case 'G':
			{
				update_program();
				break;
			}

			case 'x':
			case 'X':
			{
				run_program();
				break;
			}
			
			case 't':
			case 'T':
			{
				lcd_test();
				break;
			}
			case 's':
			case 'S':
			{
				ts_test();
				break;
			}
		}
	}
	
	return 0;
}