int st_query(int a, int b) {
	if (is_parent(a, b)) {
		return a;
	}
    if (is_parent(b, a)) {
		return b;
    }
    for (int i = len - 1; i >= 0; i--) {
		if (!is_parent(up[i][a], b)) {
			a = up[i][a];
		}
    }
    return up[0][a];
  }
Esempio n. 2
0
//XXX:carefull, the dentry type is not supported by all fs
static void dir_parse(i parent_fd)
{
  ++depth;
  u8 dirents[DIRENTS_BUF_SZ];
  while(1){
    l r=getdents64(parent_fd,dirents,DIRENTS_BUF_SZ);
    if(ISERR(r)){
      PERR("ERROR(%ld):getdents error\n",r);
      exit(-1);
    }
    if(!r) break;
    l j=0;
    while(j<r){
      struct dirent64 *d=(struct dirent64*)(dirents+j);

      dout(d);

      if(d->type==DT_DIR&&!is_current(d->name)&&!is_parent(d->name)){
        i dir_fd;
        do
          dir_fd=(i)openat(parent_fd,d->name,RDONLY|NONBLOCK);
        while(dir_fd==-EINTR);
        if(ISERR(dir_fd))
          PERR("ERROR(%d):unable to open subdir:%s\n",dir_fd,d->name);
        else{
          dir_parse(dir_fd);
          l r1;
          do r1=close(dir_fd); while(r1==-EINTR);
        }
      }
      j+=d->rec_len;
    }
  }
  depth--;
}
Esempio n. 3
0
    Note::Note(std::string n, std::string dir) : Node(p), _name(n);
    Org_Bot::Org_Bot(): Node

    Note::Note(std::string n, Note* p) : Node(p), _name(n)
    {
	if (p != NULL)
	{
	    p->make_parent(); //may already be parent, then line will do nada
	    dir = p->path();
	}
	else
	    ERROR("Creating note with NULL parent. (Must give parent or directory)");
    }

    Note::make_parent()
    {//Ignores request if already parent
	if (! is_parent())
	{
	    system(("rm "+path()).c_str());
	    system(("mkdir "+path()).c_str());
//	    Note* nt = new Note("note.a", this);
//	    nt->msg = msg;
// I'd like to do this without creating a new Note
	}
    }
}
Esempio n. 4
0
void Fl_Type::write_properties() 
{
	int level = 0;
	for (Fl_Type* p = parent; p; p = p->parent) level++;
	// repeat this for each attribute:
	if (!label().empty()) {
		write_indent(level+1);
		write_word("label");
		write_word(label());
	}
	if (!user_data().empty()) {
		write_indent(level+1);
		write_word("user_data");
		write_word(user_data());
		if (!user_data_type().empty()) {
			write_word("user_data_type");
			write_word(user_data_type());
		}
	}
	if (!callback().empty()) {
		write_indent(level+1);
		write_word("callback");
		write_word(callback());
	}
	if (is_parent() && open_) write_word("open");
	if (selected) write_word("selected");
	if (!tooltip().empty()) {
		write_indent(level+1);
		write_word("tooltip");
		write_word(tooltip());
	}
}
Esempio n. 5
0
int main(void) {

  int p,c,x,y;
  int result;

  while (1) {
    if (scanf("%s %s", buf1, buf2) != 2) {
      printf("unexpected\n");
      exit(0);
    }
    if (strcmp(buf1,"no.child")==0) break;
    
    c = lookup(buf1);
    p = lookup(buf2);

    parent[c] = p;
    children[p][num_children[p]] = c;
    num_children[p]++;
  }

  while (1) {
    if (scanf("%s %s", buf1, buf2) != 2) {
      exit(0);
    }
    
    x = lookup(buf1);
    y = lookup(buf2);

    result = is_parent(x, y);
    if (result) {
      print_grand(result, "child");
      continue;
    }
    result = is_parent(y, x);
    if (result) {
      print_grand(result, "parent");
      continue;
    }
    if (parent[x] && (parent[x] == parent[y])) {
      printf("sibling\n");
      continue;
    }
    if (check_cousins(x, y)) continue;
    printf("no relation\n");
  }

}
Esempio n. 6
0
   void init(bool exit_parent, boost::function0<bool> child_init_func)
   {
      daemon_impl_.fork_(child_init_func);

      if(exit_parent && is_parent())
      {
         exit(EXIT_SUCCESS);
      }
   }
Esempio n. 7
0
void handle_signal(int sigtype) {
	if (SIGINT == sigtype) {
		dump("Received SIGINT signal");
		running = false;
		
		if (is_parent()) {
			send_signal(SIGTERM, false);
		}
	} else if (SIGTERM == sigtype) {
		dump("Received SIGTERM signal");
		running = false;

		if (is_parent()) {
			send_signal(SIGTERM, false);
		}
	} else {
		dump("Received unknown signal. Ignoring it");
	}
}
Esempio n. 8
0
/*
 * is_parent: returns True iff parent is a parent class of child, or if 
 *    parent and child are the same class.
 *    Class id #s are compared to see if two classes are equal.
 */
int is_parent(class_type parent, class_type child)
{
   if (child->class_id->idnum == parent->class_id->idnum)
      return True;

   if (child->superclass == NULL)
      return False;

   return is_parent(parent, child->superclass);
}
Esempio n. 9
0
string
materialize (url u, string filter) {
  // Combines resolve and concretize
  url r= resolve (u, filter);
  if (!(is_rooted (r) || is_here (r) || is_parent (r))) {
    failed_error << "u= " << u << LF;
    FAILED ("url could not be resolved");
  }
  return concretize (r);
}
Esempio n. 10
0
url
operator * (url u1, url u2) {
  //cout << "concat " << u1->t << " * " << u2->t << "\n";
  if (is_root (u2) || (is_concat (u2) && is_root (u2[1]))) {
    if (is_concat (u1) && is_root_web (u1[1])) {
      if (is_root (u2, "default") ||
          (is_concat (u2) && is_root (u2[1], "default")))
        {
          url v= u1[2];
          while (is_concat (v)) v= v[1];
          if (is_root (u2)) return u1[1] * v;
          return u1[1] * v * u2[2];
        }
      if (is_root (u2, "blank") ||
          (is_concat (u2) && is_root (u2[1], "blank")))
        return reroot (u2, u1[1][1]->t->label);
    }
    return u2;
  }
  if (is_here (u1) || (u1->t == "")) return u2;
  if (is_here (u2)) return u1;
  if (is_none (u1)) return url_none ();
  if (is_none (u2)) return url_none ();
  if (u2 == url_parent ()) {
    if (is_root (u1)) return u1;
    if (is_pseudo_atomic (u1) && (!is_parent (u1))) return url_here ();
    if (is_semi_root (u1)) return u1;
  }
  if (is_concat (u2) && (u2[1] == url_parent ())) {
    if (is_root (u1)) return u1 * u2[2];
    if (is_pseudo_atomic (u1) && (!is_parent (u1))) return u2[2];
    if (is_semi_root (u1)) return u1 * u2[2];
  }
  if (is_concat (u1)) return u1[1] * (u1[2] * u2);
  return as_url (tuple ("concat", u1->t, u2->t));
}
Esempio n. 11
0
// write a widget and all it's children:
void Fl_Type::write() {
  int level = 0;
  for (Fl_Type* p = parent; p; p = p->parent) level++;
  write_indent(level);
  write_word(type_name());
  write_word(name());
  write_open(level);
  write_properties();
  write_close(level);
  if (!is_parent()) return;
  // now do children:
  write_open(level);
  Fl_Type *child;
  for (child = first_child; child; child = child->next_brother) child->write();
  write_close(level);
}
Esempio n. 12
0
string
concretize (url u) {
  // This routine transforms a resolved url into a system file name.
  // In the case of distant files from the web, a local copy is created.
  if (is_rooted (u, "default") ||
      is_rooted (u, "file") ||
      is_rooted (u, "blank"))
        return as_string (reroot (u, "default"));
  if (is_rooted_web (u)) return concretize (get_from_web (u));
  if (is_rooted_tmfs (u)) return concretize (get_from_server (u));
  if (is_ramdisc (u)) return concretize (get_from_ramdisc (u));
  if (is_here (u)) return as_string (url_pwd ());
  if (is_parent (u)) return as_string (url_pwd () * url_parent ());
  if (is_wildcard (u, 1)) return u->t[1]->label;
  std_warning << "Couldn't concretize " << u->t << LF;
  // failed_error << "u= " << u << LF;
  // FAILED ("url has no root");
  return "xxx";
}
Esempio n. 13
0
File: recvcmd.c Progetto: 0xAX/muttx
static struct header *find_parent (ATTACHPTR **idx, short idxlen, struct body *cur, short nattach)
{
	short i;
	struct header *parent = NULL;

	if (cur)
	{
		for (i = 0; i < idxlen; i++)
		{
			if (mutt_is_message_type (idx[i]->content->type, idx[i]->content->subtype)
			    && is_parent (i, idx, idxlen, cur))
				parent = idx[i]->content->hdr;
			if (idx[i]->content == cur)
				break;
		}
	}
	else if (nattach)
		parent = find_common_parent (idx, idxlen, nattach);

	return parent;
}
Esempio n. 14
0
class_type make_class_signature(id_type class_id, id_type superclass_id)
{
   list_type l;
   id_type old_id;
   class_type c = (class_type) SafeMalloc(sizeof(class_struct));
   c->superclass = NULL;  /* Will be set for real below */

   c->class_id = class_id;

   /* Class name must not have appeared before */
   old_id = lookup_id(class_id);

   switch(class_id->type)
   {
   case I_MISSING:
      /* The class has been referenced in a function call, but not declared anywhere 
       * We should use the existent class # and remove the id from the missing list 
       */
      if (class_id->source != I_CLASS)
      {
	 action_error("Class %s was referenced elsewhere with different type", class_id->name);
	 break;
      }

      /* Insert directly into global table to preserve id # */
      class_id->type = I_CLASS;
      class_id->source = COMPILE;
      table_insert(st.globalvars, (void *) class_id, id_hash, id_compare);

      /* Remove from missing list */
      table_delete_item(st.missingvars, class_id, id_hash, id_compare);

      break;
      
   case I_UNDEFINED:
      /* New class name--continue normally */
      add_identifier(class_id, I_CLASS);
      break;

   case I_CLASS:
      /* We are recompiling a previously existing class.  This is rather ugly, since
       * we want to replace all the old class's data with our new data.  However, to give
       * previously compiled subclasses a chance of working with the new version, we
       * should try to match class numbers, message #s, etc. with the old class.
       *   At this point, all the old class's data have been inserted into our hash
       * tables.  The new class will be inserted into st.globalvars.  We must remove the old class 
       * from the class list.
       */

      /* If class is given twice in source files, that's an error */
      if (class_id->source == COMPILE)
	 action_error("Class %s is given twice", class_id->name);
      else 
	 /* Change the existent class id to reflect the fact that the class has now
	  * been recompiled. */
	 old_id->source = COMPILE;

      class_id->source = COMPILE;

      /* Delete self from list of existent classes.  Give warnings for subclasses. */
	 
      for (l = st.classes; l != NULL; l = l->next)
	 if (is_parent(c, (class_type) l->data))
	 {
	    if (((class_type) l->data)->class_id->idnum == c->class_id->idnum)
	       st.classes = list_delete_item(st.classes, l->data, class_compare);
	    else
	       /* Don't give warning if deleted self from list */
	    {
	       recompile_type recompile_info = 
		  (recompile_type) SafeMalloc(sizeof(recompile_struct));
	       recompile_info->class_id = ((class_type) (l->data))->class_id;
	       recompile_info->superclass = c->class_id;
	       
	       /* Only add to list if it isn't already there */
	       if (list_find_item(st.recompile_list, recompile_info->class_id, 
				  recompile_compare) == NULL)
		  st.recompile_list = list_add_item(st.recompile_list, (void *) recompile_info);
	    }
	    
	 }
      break;
      
   default:
      action_error("Duplicate identifier %s", class_id->name);
   }

   /* Delete this class from list of those that need to be recompiled */
   st.recompile_list = 
      list_delete_item(st.recompile_list, (void *) c->class_id, recompile_compare);

   c->resources  = NULL;
   c->properties = NULL;
   c->messages   = NULL;
   c->is_new = True; /* We should generate code for this class */

   /* Superclass must be defined, if one is given */
   if (superclass_id != NULL)
   {
      lookup_id(superclass_id);
      if (superclass_id->type != I_CLASS)
	 action_error("Can't find superclass %s", superclass_id->name);
      else if (class_id->idnum == superclass_id->idnum)
	 action_error("Can't subclass from self", superclass_id->name);	 
      else 
      {
	 /* Find superclass's data and store a pointer to it. */
	 for (l = st.classes; l != NULL; l = l->next)
	    if (superclass_id->idnum == ((class_type) (l->data))->class_id->idnum)
	    {
	       c->superclass = (class_type) l->data;
	       break;
	    }

	 if (c->superclass == NULL)
	    action_error("Unable to find superclass %s", superclass_id->name);
      }
      
   }
   else c->superclass = NULL;

   st.curclass = class_id->idnum;

   /* Now add superclasses' properties to our own property table, but delete
    * them from our property list.  This way the table will hold all properties 
    * that can be referenced in the class, but the property list will only 
    * hold those that were declared in this class (need to know this for code gen) */
   add_parent_properties(c, c->superclass);

   /* Similarly, add superclasses' classvars.  This must be done AFTER adding the properties,
    * since some properties in a superclass could be overriding classvars in a superclass */
   add_parent_classvars(NULL, c, c->superclass);

   /* Add to list of classes */
   st.classes = list_add_item(st.classes, (void *) c);

   return c;   
}