예제 #1
0
파일: raw_char.c 프로젝트: Nrvax/43sh
void		get_raw_input(t_raw *raw, t_hist *hist, int *enter, int *move)
{
  int		err;

  while (!*enter)
    {
      *move = 0;
      raw->rd = raw_alloc(sizeof(char) * 10);
      raw->line->oldcursor = raw->line->cursor;
      if (read(0, raw->rd, 10) < 0)
	continue ;
      if (raw->rd[0] > 31 && raw->rd[0] < 127)
	{
	  err = insert_char(raw, raw->rd[0]);
	  raw->complete = 0;
	  raw->beg = NULL;
	}
      else
	err = get_std_escape(raw, raw->rd, enter, move);
      (err != SUCCESS) ? (input_error(err)) : (0);
      if (err == ERROR && raw->line->input->buffer[0] == 0)
	return ;
      redraw(raw, *move, *enter);
      free(raw->rd);
    }
  free_hist(raw->history);
}
예제 #2
0
oop string_join(oop strlist, oop sepstr) {
  size_t total_length = 0;
  size_t sep_length;
  int needsep = 0;
  oop pos;
  binary *result;
  char *c;

  if (!isbinary(sepstr)) die("string_join: sepstr is not a binary");
  sep_length = oop_len(sepstr);
  for (pos = strlist; ispair(pos); pos = ((pair *) pos)->cdr) {
    oop s = ((pair *) pos)->car;
    if (!isbinary(s)) die("string_join: element of strlist is not a binary");
    if (needsep) total_length += sep_length;
    total_length += oop_len(s);
    needsep = 1;
  }
  if (!isnil(pos)) die("string_join: strlist is not a list");
  result = raw_alloc(sizeof(binary) + total_length);
  init_binary_header(result->header, TYPE_BINARY, total_length);
  c = result->data;
  needsep = 0;
  for (pos = strlist; ispair(pos); pos = ((pair *) pos)->cdr) {
    oop s = ((pair *) pos)->car;
    if (needsep) {
      memcpy(c, ((binary *) sepstr)->data, sep_length);
      c += sep_length;
    }
    memcpy(c, ((binary *) s)->data, oop_len(s));
    c += oop_len(s);
    needsep = 1;
  }
  return result;
}
예제 #3
0
파일: raw_memfunc.c 프로젝트: Nrvax/43sh
void		raw_memmove(void *dest, void *src, size_t size)
{
  void		*tmp;

  tmp = raw_alloc(size);
  memcpy(tmp, src, size);
  memcpy(dest, tmp, size);
  free(tmp);
}
예제 #4
0
oop string_split_by_chars(oop s, oop charstr) {
  oop result = mknull();
  size_t limit;
  pair *prev = NULL;
  char *separators;
  size_t separators_len;
  size_t tokstart;
  size_t pos;
  char *sdata;

  if (!isbinary(s)) die("string_split_by_chars: string is not a binary");
  if (!isbinary(charstr)) die("string_split_by_chars: separators is not a binary");

  separators = ((binary *) charstr)->data;
  separators_len = oop_len(charstr);

  sdata = ((binary *) s)->data;
  tokstart = pos = 0;
  limit = oop_len(s);

  while (pos < limit) {
    /* Find the first separator */
    while (pos < limit && memchr(separators, sdata[pos], separators_len) == NULL) pos++;
    if (tokstart != pos) {
      binary *tok = raw_alloc(sizeof(binary) + (pos - tokstart));
      pair *p = raw_cons(tok, mknull());
      init_binary_header(tok->header, TYPE_BINARY, (pos - tokstart));
      memcpy(tok->data, &sdata[tokstart], pos - tokstart);
      if (prev == NULL) {
	result = p;
      } else {
	prev->cdr = p;
      }
      prev = p;
    }
    /* Find the first nonseparator */
    while (pos < limit && memchr(separators, sdata[pos], separators_len) != NULL) pos++;
    tokstart = pos;
  }

  return result;
}
예제 #5
0
		// called by the next generation down to promote an
		// already allocated object to the generation in question.
		inline void *promote(void *obj, size_t size, ValueType type, bool pinned)
		{
			void *n = raw_alloc(size, type, pinned);
			memcpy(n, obj, size);
			return n;
		}
예제 #6
0
파일: heap.c 프로젝트: skarpenko/phlox
void *kmalloc(size_t size)
{
    void *address = NULL;
    int bin_index;
    struct heap_page *page;
    unsigned long irq_state = 0;
    uint32 i;

#if MAKE_NOIZE
    kprint("kmalloc: asked to allocate size %d\n", size);
#endif

    /* lock */
    HEAP_LOCK(irq_state);

    /* find a bin of suitable size */
    for (bin_index = 0; bin_index < bin_count; bin_index++)
        if (size <= bins[bin_index].element_size)
            break;

    /* if requested memory block is too big,
     * no bin of suitable size discovered
     */
    if (bin_index == bin_count) {
        /* XXX fix the raw alloc later. */
        panic("kmalloc: asked to allocate too much for now!\n");
        goto out;
    } else {
        /* allocate space */
        if (bins[bin_index].free_list != NULL) {
            address = bins[bin_index].free_list;
            bins[bin_index].free_list = (void *)(*(addr_t *)bins[bin_index].free_list);
            bins[bin_index].free_count--;
        } else {
            if (bins[bin_index].raw_count == 0) {
                bins[bin_index].raw_list = raw_alloc(bins[bin_index].grow_size, bin_index);
                bins[bin_index].raw_count = bins[bin_index].grow_size / bins[bin_index].element_size;
            }

            bins[bin_index].raw_count--;
            address = bins[bin_index].raw_list;
            bins[bin_index].raw_list += bins[bin_index].element_size;
        }

        bins[bin_index].alloc_count++;
        page = &heap_alloc_table[((addr_t)address - heap_base) / PAGE_SIZE];
        page[0].free_count--;
#if MAKE_NOIZE
        kprint("kmalloc0: page 0x%x: bin_index %d, free_count %d\n", page, page->bin_index, page->free_count);
#endif
        for(i = 1; i < bins[bin_index].element_size / PAGE_SIZE; i++) {
            page[i].free_count--;
#if MAKE_NOIZE
            kprint("kmalloc1: page 0x%x: bin_index %d, free_count %d\n", page[i], page[i].bin_index, page[i].free_count);
#endif
        }
    }

out:
    /* unlock */
    HEAP_UNLOCK(irq_state);

#if MAKE_NOIZE
    kprint("kmalloc: asked to allocate size %d, returning ptr = %p\n", size, address);
#endif
    return address;
}