Exemplo n.º 1
0
/*
 * find the element in the tree
 */
BStree *find_tree(BStree *tree, item_type element)
{
	if(tree == NULL)
		return NULL;
	else if(element == tree->element)
		return tree;
	else if(element < tree->element)
		return find_tree(tree->left, element);
	else
		return find_tree(tree->right, element);
}
Exemplo n.º 2
0
Arquivo: tree.c Projeto: nabeken/bird
/**
 * find_tree
 * @t: tree to search in
 * @val: value to find
 *
 * Search for given value in the tree. I relies on fact that sorted tree is populated
 * by &f_val structures (that can be compared by val_compare()). In each node of tree,
 * either single value (then t->from==t->to) or range is present.
 *
 * Both set matching and |switch() { }| construction is implemented using this function,
 * thus both are as fast as they can be.
 */
struct f_tree *
find_tree(struct f_tree *t, struct f_val val)
{
    if (!t)
        return NULL;
    if ((val_compare(t->from, val) != 1) &&
            (val_compare(t->to, val) != -1))
        return t;
    if (val_compare(t->from, val) == -1)
        return find_tree(t->right, val);
    else
        return find_tree(t->left, val);
}
int main (int argc, char *argv[])
{
    FILE *fpi;
    long pos;
    char *keyp;
    int  keylen;
    int  version, features;

    static unsigned char buffer[1024];

    if (argc < 2) {
        fprintf (stderr, "missing argument\n");
        exit (1);
    }

    fpi = fopen (argv[1], "r");
    if (fpi == NULL) {
        fprintf (stderr, "Unable to open file \"%s\"\n", argv[1]);
        return 1;
    }

    {
        char *buf = malloc (4096);
        setbuffer (fpi, buf, 4096);
    }

    pos = trie_hdr_read (fpi, &version, &features);

    keyp = (argc >= 3 ? argv[2] : "");
    keylen = strlen (keyp);

    find_tree (fpi, features, pos, buffer, buffer, keyp, keylen);

    return 0;
}
void find_tree (FILE *fpi, int features, uint64_t pos, unsigned char *buffer, unsigned char *bp, char *keyp, int keylen)
{
    uint64_t son, refpos, cnt;
    int      len, end, tlen, cmp;

    if (!pos) return;

    refpos = pos;

    for (;;) {
        trie_node_read (fpi, features, &refpos, &pos, &cnt, &len, &end, &son, bp);
        if (!len) break;
/*
        pos  = ftell (fpi);
*/

        tlen = (keylen < len ? keylen : len);
        cmp  = memcmp (bp, keyp, tlen);
        if (cmp > 0) break;
        if (cmp == 0) {
            if (end) {
                fwrite (buffer, bp - buffer + len, 1, stdout);
                fputc ('\n', stdout);
            }
            find_tree (fpi, features, son, buffer, bp + len, keyp + tlen, keylen - tlen);
        }
    }
}
Exemplo n.º 5
0
static cb_ret_t
tree_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
{
    WDialog *h = DIALOG (w);

    switch (msg)
    {
    case MSG_RESIZE:
        {
            Widget *bar;

            /* simply call dlg_set_size() with new size */
            dlg_set_size (h, LINES - 9, COLS - 20);
            bar = WIDGET (find_buttonbar (h));
            bar->x = 0;
            bar->y = LINES - 1;
            return MSG_HANDLED;
        }

    case MSG_ACTION:
        return send_message (find_tree (h), NULL, MSG_ACTION, parm, NULL);

    default:
        return dlg_default_callback (w, sender, msg, parm, data);
    }
}
Exemplo n.º 6
0
/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  main
 *  Description:  
 * =====================================================================================
 */
	int
main ( int argc, char *argv[] )
{
	BStree *root = NULL;
	printf("insert the data 1 7 4 8 3 6 5\n");
	root = insert_tree(root, NULL, 2);
	delete_tree(root, 2);
	root = NULL;
	root = insert_tree(root,NULL, 2);
	insert_tree(root, NULL, 1);
	insert_tree(root, NULL, 7);
	insert_tree(root, NULL, 4);
	insert_tree(root, NULL, 8);
	insert_tree(root, NULL, 3);
	insert_tree(root, NULL, 6);
	insert_tree(root, NULL, 5);

	print_tree(root);

	printf("delete 7\n");
	delete_tree(root, 7);
	print_tree(root);
	printf("delete 2\n");
	delete_tree(root, 2);
	print_tree(root);

	printf("find 8\n");
	printf("%d\n", find_tree(root, 8)->element);
	clear(root);
	return EXIT_SUCCESS;
}				/* ----------  end of function main  ---------- */
Exemplo n.º 7
0
/**
 * Get the carrier id from multiparam_t structure.
 *
 * @param mp carrier id as integer, pseudo-variable or AVP name of carrier
 * @param _msg SIP message
 * @return carrier id on success, -1 otherwise
 *
 */
int mp2carrier_id(struct sip_msg * _msg, struct multiparam_t *mp) {
	int carrier_id;
	struct usr_avp *avp;
	int_str avp_val;
	str tmp;

	/* TODO combine the redundant parts of the logic */
	switch (mp->type) {
	case MP_INT:
		return mp->u.n;
		break;
	case MP_AVP:
		avp = search_first_avp(mp->u.a.flags, mp->u.a.name, &avp_val, 0);
		if (!avp) {
			LM_ERR("cannot find AVP '%d'\n", mp->u.a.name);
			return -1;
		}
		if ((avp->flags&AVP_VAL_STR)==0) {
			return avp_val.n;
		}
		else {
			carrier_id = find_tree(avp_val.s);
			if (carrier_id < 0) {
				LM_WARN("could not find carrier tree '%.*s'\n", avp_val.s.len, avp_val.s.s);
				/* might be using fallback later... */
			}
			return carrier_id;
		}
		break;
	case MP_PVE:
		/* retrieve carrier name from parameter */
		if (pv_printf_s(_msg, mp->u.p, &tmp)<0) {
			LM_ERR("cannot print the carrier\n");
			return -1;
		}
		carrier_id = find_tree(tmp);
		if (carrier_id < 0) {
			LM_WARN("could not find carrier tree '%.*s'\n", tmp.len, tmp.s);
			/* might be using fallback later... */
		}
		return carrier_id;
	default:
		LM_ERR("invalid carrier type\n");
		return -1;
	}
}
Exemplo n.º 8
0
/**
 * fixes the module functions' parameters if it is a carrier.
 * supports name string, pseudo-variables and AVPs.
 *
 * @param param the parameter
 *
 * @return 0 on success, -1 on failure
 */
static int carrier_fixup(void ** param) {
	pv_spec_t avp_spec;
	struct multiparam_t *mp;
	str s;

	mp = (struct multiparam_t *)pkg_malloc(sizeof(struct multiparam_t));
	if (mp == NULL) {
		LM_ERR("no more memory\n");
		return -1;
	}
	memset(mp, 0, sizeof(struct multiparam_t));

	s.s = (char *)(*param);
	s.len = strlen(s.s);

	if (s.s[0]!='$') {
		/* This is a name string */
		mp->type=MP_INT;

		/* get carrier id */
		if ((mp->u.n = find_tree(s)) < 0) {
			LM_ERR("could not find carrier tree '%s'\n", (char *)(*param));
			pkg_free(mp);
			return -1;
		}
		LM_INFO("carrier tree %s has id %i\n", (char *)*param, mp->u.n);

		pkg_free(*param);
		*param = (void *)mp;
	}
	else {
		/* This is a pseudo-variable */
		if (pv_parse_spec(&s, &avp_spec)==0) {
			LM_ERR("pv_parse_spec failed for '%s'\n", (char *)(*param));
			pkg_free(mp);
			return -1;
		}
			if (avp_spec.type==PVT_AVP) {
			/* This is an AVP - could be an id or name */
			mp->type=MP_AVP;
			if(pv_get_avp_name(0, &(avp_spec.pvp), &(mp->u.a.name), &(mp->u.a.flags))!=0) {
				LM_ERR("Invalid AVP definition <%s>\n", (char *)(*param));
				pkg_free(mp);
				return -1;
			}
		} else {
			mp->type=MP_PVE;
			if(pv_parse_format(&s, &(mp->u.p))<0) {
				LM_ERR("pv_parse_format failed for '%s'\n", (char *)(*param));
				pkg_free(mp);
				return -1;
			}
		}
	}
	*param = (void*)mp;

	return 0;
}
Exemplo n.º 9
0
void add_tree(deque<string> tag, const stu & u, const vector<int> & no, Tree & t){
	for (int i = 0; i != no.size(); ++i)
		if (!count(t.pid[no[i]].begin(), t.pid[no[i]].end(), u.ID))
			t.pid[no[i]].push_back(u.ID);
	if (!tag.empty()){
		string v = tag.front(); tag.pop_front();
		add_tree(tag, u, no, t.next[find_tree(v, t)]);
	}
}
Exemplo n.º 10
0
/**
 * rewrites the request URI of msg by calculating a rule, using
 * crc32 for hashing. The request URI is used to determine tree node
 * the given _tree is the used routing tree
 *
 * @param msg the current SIP message
 * @param _tree the routing tree to be used (string or pseudo-variable
 * @param _domain the requested routing domain
 *
 * @return 1 on success, -1 on failure
 */
int tree_route_uri(struct sip_msg * msg, char * _tree, char * _domain) {
	struct rewrite_data * rd = NULL;
	pv_elem_t *model;
	str carrier_name;
	int index;
	str ruser;
	str ruri;

	if (!_tree) {
		LM_ERR("bad parameters\n");
		return -1;
	}

	if (parse_sip_msg_uri(msg) < 0) {
		return -1;
	}

	/* Retrieve carrier name from parameter */
	model = (pv_elem_t*)_tree;
	if (pv_printf_s(msg, model, &carrier_name)<0)	{
		LM_ERR("cannot print the format\n");
		return -1;
	}
	if ((index = find_tree(carrier_name)) < 0)
		LM_WARN("could not find carrier %.*s\n",
				carrier_name.len, carrier_name.s);
	else
		LM_DBG("tree %.*s has id %i\n", carrier_name.len, carrier_name.s, index);
	
	ruser.s = msg->parsed_uri.user.s;
	ruser.len = msg->parsed_uri.user.len;
	ruri.s = msg->parsed_uri.user.s;
	ruri.len = msg->parsed_uri.user.len;
	do {
		rd = get_data();
	} while (rd == NULL);
	if (index < 0) {
		if (fallback_default) {
			LM_NOTICE("invalid tree id %i specified, use default tree\n", index);
			index = rd->default_carrier_index;
		} else {
			LM_ERR("invalid tree id %i specified and fallback deactivated\n", index);
			release_data(rd);
			return -1;
		}
	}
	release_data(rd);
	return carrier_rewrite_msg(index, (int)(long)_domain, &ruri, msg, &ruser,
			shs_call_id, alg_crc32);
}
Exemplo n.º 11
0
int
as_path_match_set(struct adata *path, struct f_tree *set)
{
  u8 *p = path->data;
  u8 *q = p+path->length;
  int i, n;

  while (p<q)
    {
      n = p[1];
      p += 2;
      for (i=0; i<n; i++)
	{
	  struct f_val v = {T_INT, .val.i = get_as(p)};
	  if (find_tree(set, v))
	    return 1;
	  p += BS;
	}
    }
Exemplo n.º 12
0
void Analysis::link_tree()
{
  pAssemblerTree nowtree = root;
  while (nowtree)
  {
    ud_t ud = nowtree->asmpiece.back();
    if (ud.operand[0].type == UD_OP_JIMM && ud.mnemonic != UD_Icall)
    {
      long addr = ud.operand[0].size == 8 ? ((signed char)ud.operand[0].lval.sbyte + ud.pc) : (ud.operand[0].lval.sdword + ud.pc);
      pAssemblerTree tree_R= find_tree(addr);
      if (tree_R)
      {
         nowtree->RightChild = tree_R;
         nowtree->jcc_addr = addr;
      }
    }  
    nowtree = nowtree->LeftChild;
  }
}
Exemplo n.º 13
0
static cb_ret_t
tree_callback (Dlg_head * h, Widget * sender, dlg_msg_t msg, int parm, void *data)
{
    switch (msg)
    {
    case DLG_POST_KEY:
        /* The enter key will be processed by the tree widget */
        if (parm == '\n')
        {
            h->ret_value = B_ENTER;
            dlg_stop (h);
        }
        return MSG_HANDLED;

    case DLG_ACTION:
        /* command from buttonbar */
        return send_message ((Widget *) find_tree (h), WIDGET_COMMAND, parm);

    default:
        return default_dlg_callback (h, sender, msg, parm, data);
    }
}
Exemplo n.º 14
0
void find_tree
(const Filename& fn_where, const std::string& what, DoStr dostr, void* from)
{
    std::string where = fn_where.get_rootful();
    // Nach Verzeichnissen suchen
    al_ffblk info;
    if (where[where.size()-1] != '/') where += '/';
    std::string search_for = where + '*';
    if (al_findfirst(search_for.c_str(), &info,
     FA_RDONLY | FA_HIDDEN | FA_LABEL | FA_DIREC | FA_ARCH) == 0) {
        do {
            // Dies nur f�r jedes Verzeichnis au�er . und .. ausf�hren:
            // Neue Suche mit gleichem Vektor im gefundenen Verzeichnis
            if ((info.attrib & FA_DIREC) == FA_DIREC && info.name[0] != '.') {
                Filename fn_recurs(where + info.name + '/');
                find_tree(fn_recurs, what, dostr, from);
            }
        } while (al_findnext(&info) == 0);
        al_findclose(&info);
    }
    // Nach Dateien suchen, die dem Suchkriterium entsprechen
    Filename fn_where_with_slash(where);
    find_files(fn_where_with_slash, what, dostr, from);
}
Exemplo n.º 15
0
			redo_trees();
			return (dobj);
		}
	}
}

VOID open_tree(WORD obj)
{
	WORD	kind, new, where; 
	GRECT	o;
	LONG	tree;
	WORD	themenu, menu;
 
	tree = ad_view;
	select_tree(tree, trunpan_f(obj));
	where = find_tree(obj - 1);
	kind = get_kind(where);

	switch (kind)
	{
		case UNKN:
			type_tree(obj);
			dselct_tree(tree, trunpan_f(obj));
			return;
		case PANL:
			new = PANL_STATE;
			break;
		case DIAL:
			new = DIAL_STATE;
			break;
		case ALRT:
int main()
{
    Tree *tree = createTree();
    Hashtable *table5, *table50, *table500;
    FILE *fp50, *fp500, *fp5mil;
    clock_t tstart, tend;
    time_t t;
    srand((unsigned) time(&t));
    double favg;
    int data = 0, i = 0, search, value, found;
    int array50k[50000], *array500k, *array5mil;
    array500k = malloc(500001 * sizeof(int));
    array5mil = malloc(5000001 * sizeof(int));
    if(tree == NULL)
        printf("Memory allocation failed...");
    fp50 = fopen("50tus.txt", "r");
    fp500 = fopen("500tus.txt", "r");
    fp5mil = fopen("5mil.txt", "r");
    if(fp50 == NULL || fp500 == NULL|| fp5mil == NULL)
    {
        fprintf(stderr, "error\n");
        return 1;
    }
    system("color 3");
    table5 = create_table(50000000);
    table50 = create_table(500000);
    table500 = create_table(5000000);

    /*50k*/
    printf("\n50k insert, balance and search!\n");
    printf("Insert: 50k ");
    tstart = clock(); // start
    for(i = 0; i < 50000; ++i)
    {
        fscanf(fp50,"%d\n", &data);
        insert(tree, data);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    tree_to_arr(tree);
    printf("Searching 100x in 50k ");
    tstart = clock(); // start
    find_tree(tree);
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    clear_tree(tree);

    /*500k*/
    printf("\n500k insert, balance and search!\n");
    printf("Insert: 500k ");
    tstart = clock(); // start
    for(i = 0; i < 500000; ++i)
    {
        fscanf(fp500,"%d\n", &data);
        insert(tree, data);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    tree_to_arr(tree);
    printf("Searching 100x in 500k ");
    tstart = clock(); // start
    find_tree(tree);
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    clear_tree(tree);

    /*5mille*/
    printf("\n5 million insert, balance and search!\n");
    printf("Insert: 5 million ");
    tstart = clock(); // start
    for(i = 0; i < 5000000; ++i)
    {
        fscanf(fp5mil,"%d\n", &data);
        insert(tree, data);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    tree_to_arr(tree);
    printf("Searching 100x in 5 million ");
    tstart = clock(); // start
    find_tree(tree);
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    clear_tree(tree);

    /*50k sekvens*/
    printf("\nSekvential insert 50k!\n");
    tstart = clock(); // start
    for(i = 0; i<50000; i++)
    {
        fscanf(fp50, "%d\n", &array50k[i]);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    printf("Sekvential search 50k, 100x!\n");
    tstart = clock(); // start
    for(i = 0; i<100; i++)
    {
        search = randomGen();
        sekvential_search(array50k, search, 50000);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    printf("Sekvential search 50k, 100x(o)!\n");
    tstart = clock(); // start
    for(i = 0; i<100; i++)
    {
        search = randomGen();
        sekvent_search(array50k, search, 50000);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);

    /*500k sekvens*/
    printf("\nSekvential insert 500k!\n");
    tstart = clock(); // start
    for(i = 0; i<500000; i++)
    {
        fscanf(fp500, "%d\n", &array500k[i]);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    printf("Sekvential search 500k, 100x!\n");
    tstart = clock(); // start
    for(i = 0; i<100; i++)
    {
        search = randomGen();
        sekvential_search(array500k, search, 500000);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    printf("Sekvential search 500k, 100x(o)!\n");
    tstart = clock(); // start
    for(i = 0; i<100; i++)
    {
        search = randomGen();
        sekvent_search(array500k, search, 500000);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);

    /*5mille seq*/
    printf("\nSekvential insert 5 million!\n");
    tstart = clock(); // start
    for(i = 0; i<5000000; i++)
    {
        fscanf(fp5mil, "%d\n", &array5mil[i]);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    printf("Sekvential search 5 million, 100x!\n");
    tstart = clock(); // start
    for(i = 0; i<100; i++)
    {
        search = randomGen();
        sekvential_search(array5mil, search, 5000000);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);
    printf("Sekvential search 5 million, 100x(o)!\n");
    tstart = clock(); // start
    for(i = 0; i<100; i++)
    {
        search = randomGen();
        sekvent_search(array5mil, search, 5000000);
    }
    tend = clock(); // end
    favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
    printf("Avg. execution time: %g sec\n",favg);

    /*Hash 500k*/
    printf("\nHash insert 50k!\n");
    tstart = clock(); // start
    for(i = 0; i<50000; i++){
        fscanf(fp500, "%d\n", &value);
        insert_hash(table50, value);
    }
        tend = clock(); // end
        favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
        printf("Avg. execution time: %g sec\n",favg);

    /*Hash 500k*/
    printf("\nHash insert 500k!\n");
    tstart = clock(); // start
    for(i = 0; i<500000; i++){
        fscanf(fp500, "%d\n", &value);
        insert_hash(table500, value);
    }
        tend = clock(); // end
        favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
        printf("Avg. execution time: %g sec\n",favg);

    /*Hash 5 mille*/
    printf("\nHash insert 5 million!\n");
    tstart = clock(); // start
    for(i = 0; i<5000000; i++){
        fscanf(fp5mil, "%d\n", &value);
        insert_hash(table5, value);
    }
        tend = clock(); // end
        favg = ((double)(tend - tstart))/CLOCKS_PER_SEC;
        printf("Avg. execution time: %g sec\n",favg);

    destroy_table(table5);
    destroy_table(table50);
    destroy_table(table500);
    destroyTree(tree);
    return 0;
}
int main(int argc, char *argv[]){

  element_type test_array[20];
  int i;
  BTREE T = init_tree();
  TREE_NODE p;
  int height;
 
  
  for(i=0; i<20; i++){
    test_array[i]= random(200);
    printf("%d, ", test_array[i]);
  }
  printf("\n");
  T =  creat_tree(test_array, sizeof(test_array)/sizeof(test_array[0]), T);
  height = height_recursive(T);
  printf("height is %d\n", height);

  printf("preorder:\n");
  preorder_recursive(T); 
  printf("\n");

  printf("inoder:\n");
  inorder_recursive(T);
  printf("\n");

  printf("postorder:\n");
  postorder_recursive(T);
  printf("\n");

  printf("preorder nonrec:\n");
  preorder_norecursive(T);
  printf("\n");

  printf("inorder nonrec:\n");
  inorder_norecursive(T);
  printf("\n");

  printf("postorder nonrec:\n");
  postorder_norcursive(T);
  printf("\n");
 
  printf("levelorder:\n");
  levelorder(T);
  printf("\n");

  printf("print leaf recursive:\n");
  output_leaf_recursive(T);
  printf("\n"); 

  printf("print leaf norecursive\n");
  output_leaf_norecursive(T);
  printf("\n");

  printf("find an element\n");
  if(find_tree(177, T) == NULL)
    printf("no such element\n");
  else
    preorder_recursive(find_tree(177, T));
  printf("\n");

  printf("min node\n");
  visit(find_min(T)->element);
  printf("\n");
  
  printf("max node\n");
  visit(find_max(T)->element);
  printf("\n");

  printf("delet:\n");
  tree_delete(115, T);
  preorder_recursive(T);
  printf("\n");
  
  printf("exchange tree:\n");
  exchange_recursive(T);
  preorder_recursive(T);
  printf("\n");

  printf("exchange tree norecursive:\n");
  exchange_norecursive(T);
  preorder_recursive(T);
  printf("\n");


  free_tree(T);
 
  return 0;
}
Exemplo n.º 18
0
VOID view_trees(VOID)
{
	WORD	nobj, iobj;
	WORD	kind, where, nh; 
	LONG	tree, iconad;

	tree = ad_pbx;
	rcs_work[0].ob_next = NIL;	/* construct tree root */
	rcs_work[0].ob_type = G_BOX;
	rcs_work[0].ob_flags = NONE;
	rcs_work[0].ob_state = NORMAL;
#if TURBO_C
	rcs_work[0].ob_spec.index = 0x00000007L;
#else
	rcs_work[0].ob_spec = 0x00000007L;
#endif
	rcs_work[0].ob_x = view.g_x;
	rcs_work[0].ob_y = view.g_y;
	rcs_work[0].ob_width = view.g_w;
	rcs_work[0].ob_height = view.g_h;

	if (!LWGET(RSH_NTREE(head)))
	{
		rcs_work[0].ob_head = NIL;
		rcs_work[0].ob_tail = NIL;
	}
	else
	{
		nobj = min(VIEWSIZE, LWGET(RSH_NTREE(head)) - rcs_trpan); 
		nobj = min(nobj, fit_vtrees() * (nh = fit_htrees()));

		rcs_work[0].ob_head = 1;	/* root pointers */
		rcs_work[0].ob_tail = nobj;

		for (iobj = 0; iobj++ < nobj; )
		{
			if (iobj < nobj)
				rcs_work[iobj].ob_next = iobj + 1;
			else
				rcs_work[iobj].ob_next = ROOT;
			rcs_work[iobj].ob_head = NIL;
			rcs_work[iobj].ob_tail = NIL;
			rcs_work[iobj].ob_flags = NONE;
			rcs_work[iobj].ob_state = NORMAL;
			rcs_work[iobj].ob_type = G_ICON;
#if TURBO_C
			rcs_work[iobj].ob_spec.iconblk =
				(ICONBLK *)ADDR(&rcs_icons[iobj]);
#else
			rcs_work[iobj].ob_spec = ADDR(&rcs_icons[iobj]);
#endif
			rcs_work[iobj].ob_width = ICON_W;
			rcs_work[iobj].ob_height = ICON_H + gl_hschar;
			rcs_work[iobj].ob_x = ((iobj - 1) % nh) * (ICON_W + MIN_WINT);
			rcs_work[iobj].ob_y = ((iobj - 1) / nh) * (ICON_H + MIN_HINT);

			where = find_tree(iobj + rcs_trpan - 1);
			kind = get_kind(where);
			iconad = GET_SPEC(tree, rcs_typ2icn[kind]);
			LBCOPY(ADDR(&rcs_icons[iobj]), iconad, sizeof(ICONBLK));	
			rcs_icons[iobj].ib_ptext = 		/* address of tree */
				(char *)ADDR( get_name(where) );
			rcs_icons[iobj].ib_wtext =
				ch_width(IBM) * (WORD)LSTRLEN(rcs_icons[iobj].ib_ptext);
			rcs_icons[iobj].ib_ytext = ICON_H;
			rcs_icons[iobj].ib_xtext =
				(rcs_icons[iobj].ib_wicon - rcs_icons[iobj].ib_wtext) / 2;
		}
	}
}