void
_mp_app_inotify_add_recursive_watch(const char *path, void *ad)
{

	DIR *dp = NULL;
	struct dirent *entry = NULL;
	char *sub_path = NULL;
	sub_path = strdup(path);
	if (mp_app_inotify_add_watch(sub_path, _mp_app_inotify_cb, ad) < 0)
	{
		IF_FREE(sub_path);
		return;
	}

	dp = opendir(sub_path);
	if (dp == NULL)
		return;

	while ((entry = (struct dirent *)readdir(dp)) != NULL)
	{
		if (entry->d_name[0] == '.')
			continue;

		IF_FREE(sub_path);
		sub_path = g_strdup_printf("%s/%s", path, entry->d_name);
		if (entry->d_type == DT_DIR)
			_mp_app_inotify_add_recursive_watch(sub_path, ad);
	}
	IF_FREE(sub_path);

	closedir(dp);

}

EAPI void
ecore_exe_event_data_free(Ecore_Exe_Event_Data *e)
{
   if (!e) return;
   IF_FREE(e->lines);
   IF_FREE(e->data);
   free(e);
}

/**
 * engrave_data_free - free the given data block
 * @param ed: The Engrave_Data to free
 *
 * @return Returns no value.
 */
EAPI void
engrave_data_free(Engrave_Data *ed)
{
  if (!ed) return;

  IF_FREE(ed->key);
  IF_FREE(ed->value);
  FREE(ed);
}

/**
 * close the current project
 */
static void
project_close( Ewler_Project *p )
{
	IF_FREE(p->name);
	IF_FREE(p->path);
	IF_FREE(p->filename);

	ecore_hash_destroy(p->files);
	FREE(p);
}

static void _exml_node_destroy( void *data )
{
	EXML_Node *node = data;

	if (node) {
		ecore_hash_destroy(node->attributes);
		IF_FREE(node->tag);
		IF_FREE(node->value);
		ecore_list_destroy(node->children);

		FREE(node);
	}
}

void CViewSourceHTML::WriteTextInElement(const nsAString& tagName, 
                                         eHTMLTags tagType, const nsAString& text,
                                         nsTokenAllocator* allocator,
                                         const nsAString& attrName, 
                                         const nsAString& attrValue) {
  // Open the element, supplying the attribute, if any.
  nsTokenAllocator* theAllocator = mTokenizer->GetTokenAllocator();
  if (!theAllocator) {
    return;
  }

  CStartToken* startToken =
    static_cast<CStartToken*>
      (theAllocator->CreateTokenOfType(eToken_start, tagType, tagName));
  if (!startToken) {
    return;
  }

  nsCParserStartNode startNode(startToken, theAllocator);
  if (!attrName.IsEmpty()) {
    AddAttrToNode(startNode, allocator, attrName, attrValue);
  }
  mSink->OpenContainer(startNode);
  IF_FREE(startToken, theAllocator);

  // Add the text node.
  CTextToken textToken(text);
  nsCParserNode textNode(&textToken, 0/*stack token*/);
  mSink->AddLeaf(textNode);

  // Close the element.
  mSink->CloseContainer(tagType);
}

/**
 * engrave_data_value_set - set the value of the data object
 * @param ed: The Engrave_Data to set the value into
 * @param value: The value to set.
 * 
 * @return Returns no value.
 */
EAPI void
engrave_data_value_set(Engrave_Data *ed, const char *value)
{
    if (!ed) return;
    IF_FREE(ed->value);
    ed->value = (value ? strdup(value) : NULL);
}

/**
 * Call this to start a new PRE block.  See bug 86355 for why this
 * makes some pages much faster.
 */
void CViewSourceHTML::StartNewPreBlock(void){
  CEndToken endToken(eHTMLTag_pre);
  nsCParserNode endNode(&endToken, 0/*stack token*/);
  mSink->CloseContainer(eHTMLTag_pre);

  nsTokenAllocator* theAllocator = mTokenizer->GetTokenAllocator();
  if (!theAllocator) {
    return;
  }

  CStartToken* theToken =
    static_cast<CStartToken*>
               (theAllocator->CreateTokenOfType(eToken_start,
                                                   eHTMLTag_pre,
                                                   NS_LITERAL_STRING("PRE")));
  if (!theToken) {
    return;
  }

  nsCParserStartNode startNode(theToken, theAllocator);
  AddAttrToNode(startNode, theAllocator,
                NS_LITERAL_STRING("id"),
                NS_ConvertASCIItoUTF16(nsPrintfCString("line%d", mLineNumber)));
  mSink->OpenContainer(startNode);
  IF_FREE(theToken, theAllocator);

#ifdef DUMP_TO_FILE
  if (gDumpFile) {
    fprintf(gDumpFile, "</pre>\n");
    fprintf(gDumpFile, "<pre id=\"line%d\">\n", mLineNumber);
  }
#endif // DUMP_TO_FILE

  mTokenCount = 0;
}

/**
 * This method is called just after a known text char has
 * been consumed and we should read a text run. Note: we actually ignore the
 * first character of the text run so that we can consume invalid markup 
 * as text.
 *  
 * @param aToken The OUT parameter that holds our resulting token.
 * @param aScanner Our source of data
 * @return Error result.
 */ 
nsresult
nsHTMLTokenizer::ConsumeText(CToken*& aToken, nsScanner& aScanner)
{
  nsresult result = NS_OK;
  nsTokenAllocator* theAllocator = this->GetTokenAllocator();
  CTextToken* theToken =
    (CTextToken*)theAllocator->CreateTokenOfType(eToken_text, eHTMLTag_text);
  if (theToken) {
    PRUnichar ch = '\0';
    result = theToken->Consume(ch, aScanner, mFlags);
    if (NS_FAILED(result)) {
      if (0 == theToken->GetTextLength()) {
        IF_FREE(aToken, mTokenAllocator);
        aToken = nullptr;
      } else {
        result = NS_OK;
      }
    }

    aToken = theToken;
    AddToken(aToken, result, &mTokenDeque, theAllocator);
  }

  return result;
}

void
sp_view_mgr_pop_view_content(Sp_View_Manager *view_mgr, bool pop_to_first)
{
	startfunc;
	MP_CHECK(view_mgr);
	MP_CHECK(view_mgr->navi);

	GList *last = g_list_last(view_mgr->view_history);
	MP_CHECK(last);
	Sp_View_Data *view_data = last->data;
	MP_CHECK(view_data);

	if (pop_to_first) {
		Elm_Object_Item *bottom_item = elm_naviframe_bottom_item_get(view_mgr->navi);
		if (bottom_item)
			elm_naviframe_item_pop_to(bottom_item);

		while(view_data && view_data->index > 0) {
			SAFE_FREE(view_data);
			view_mgr->view_history = g_list_delete_link(view_mgr->view_history, last);
			last = g_list_last(view_mgr->view_history);
			if (last)
				view_data = last->data;
		}
	} else {
		elm_naviframe_item_pop(view_mgr->navi);
		IF_FREE(view_data);
		view_mgr->view_history = g_list_delete_link(view_mgr->view_history, last);
	}

	if (g_list_length(view_mgr->view_history) == 0) {
		g_list_free(view_mgr->view_history);
		view_mgr->view_history = NULL;
	}
}

/** Release all the objects you're holding to.
 * @update	harishd 08/02/00
 * @return  void
 */
nsresult 
nsCParserNode::ReleaseAll() 
{
  if(mTokenAllocator) {
    IF_FREE(mToken,mTokenAllocator);
  }
  return NS_OK;
}

void
fg_part_up( void *data, Evas_Object *o,
						const char *emission, const char *source )
{
	Ewler_Widget *w = data;

	IF_FREE(w->source);
}

nsresult nsCParserStartNode::ReleaseAll() 
{
  NS_ASSERTION(0!=mTokenAllocator, "Error: no token allocator");
  CToken* theAttrToken;
  while ((theAttrToken = static_cast<CToken*>(mAttributes.Pop()))) {
    IF_FREE(theAttrToken, mTokenAllocator);
  }
  nsCParserNode::ReleaseAll();
  return NS_OK; 
}

/**
 * @param dvi: the dvi widget to change the displayed dvi
 * @param filename: the path to the new dvi to be displayed by @a dvi
 * @return Returns no value.
 * @brief Change the dvi file displayed by an dvi widget
 *
 * Set the dvi displayed by @a dvi to the one found at the path @a filename. If an
 * edje is used, a minimum size should be specified in the edje or the code.
 */
int
ewl_dvi_file_set(Ewl_Dvi *dvi, const char *filename)
{
        Ewl_Widget *w;
        Ewl_Embed *emb;

        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR_RET(dvi, FALSE);
        DCHECK_TYPE(dvi, EWL_DVI_TYPE);

        w = EWL_WIDGET(dvi);
        emb = ewl_embed_widget_find(w);

        if (!filename || (filename[0] == '\0'))
                DRETURN_INT(FALSE, DLEVEL_STABLE);

        if (dvi->filename != filename) {
                IF_FREE(dvi->filename);
        }

        if (dvi->dvi_page) {
                edvi_page_delete(dvi->dvi_page);
                dvi->dvi_page = NULL;
        }

        if (dvi->dvi_document) {
                edvi_document_delete(dvi->dvi_document);
                dvi->dvi_document = NULL;
        }

        dvi->filename = strdup(filename);

        /*
         * Load the new dvi if widget has been realized
         */

        dvi->dvi_document = edvi_document_new(dvi->filename, dvi->dvi_device, dvi->dvi_property);
        if (!dvi->dvi_document)
                DRETURN_INT(FALSE, DLEVEL_STABLE);

        dvi->dvi_page = edvi_page_new(dvi->dvi_document);
        if (!dvi->dvi_page) {
                edvi_document_delete(dvi->dvi_document);
                dvi->dvi_document = NULL;
                DRETURN_INT(FALSE, DLEVEL_STABLE);
        }

        if (REALIZED(w)) {
                ewl_widget_obscure(w);
                ewl_widget_reveal(w);
        }

        DRETURN_INT(TRUE, DLEVEL_STABLE);
}

void
sp_view_mgr_destroy(Sp_View_Manager* view_mgr)
{
	startfunc;
	MP_CHECK(view_mgr);

	if (view_mgr->view_history) {
		GList *current = view_mgr->view_history;
		while(current) {
			IF_FREE(current->data);
			current = current->next;
		}

		g_list_free(view_mgr->view_history);
		view_mgr->view_history = NULL;
	}


	IF_FREE(view_mgr);
}

/**
 * This method consumes an end tag and any "attributes" that may come after it.
 *
 * @param aChar The last character read from the scanner.
 * @param aToken The OUT parameter that holds our resulting token.
 * @param aScanner Our source of data
 * @return Error result
 */
nsresult
nsHTMLTokenizer::ConsumeEndTag(PRUnichar aChar,
                               CToken*& aToken,
                               nsScanner& aScanner)
{
  // Get the "/" (we've already seen it with a Peek)
  aScanner.GetChar(aChar);

  nsTokenAllocator* theAllocator = this->GetTokenAllocator();
  aToken = theAllocator->CreateTokenOfType(eToken_end, eHTMLTag_unknown);
  NS_ENSURE_TRUE(aToken, NS_ERROR_OUT_OF_MEMORY);

  // Remember this for later in case you have to unwind...
  int32_t theDequeSize = mTokenDeque.GetSize();
  nsresult result = NS_OK;

  // Tell the new token to finish consuming text...
  result = aToken->Consume(aChar, aScanner, mFlags);
  AddToken(aToken, result, &mTokenDeque, theAllocator);
  if (NS_FAILED(result)) {
    // Note that this early-return here is safe because we have not yet
    // added any of our tokens to the queue (AddToken only adds the token if
    // result is a success), so we don't need to fall through.
    return result;
  }

  result = aScanner.Peek(aChar);
  if (NS_FAILED(result)) {
    aToken->SetInError(true);

    // Note: We know here that the scanner is not incremental since if
    // this peek fails, then we've already masked over a kEOF coming from
    // the Consume() call above.
    return NS_OK;
  }

  if (kGreaterThan != aChar) {
    result = ConsumeAttributes(aChar, aToken, aScanner);
  } else {
    aScanner.GetChar(aChar);
  }

  // Do the same thing as we do in ConsumeStartTag. Basically, if we've run
  // out of room in this *section* of the document, pop all of the tokens
  // we've consumed this round and wait for more data.
  if (NS_FAILED(result)) {
    while (mTokenDeque.GetSize() > theDequeSize) {
      CToken* theToken = (CToken*)mTokenDeque.Pop();
      IF_FREE(theToken, mTokenAllocator);
    }
  }

  return result;
}

static void
ewl_icon_theme_cb_free(void *data)
{
        DENTER_FUNCTION(DLEVEL_STABLE);

        if (data == EWL_THEME_KEY_NOMATCH)
                DRETURN(DLEVEL_STABLE);

        IF_FREE(data);

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

void
elicit_free(Elicit *el)
{
  elicit_magnify_stop(el);

  if (el->color)
    color_unref(el->color);

  if (el->obj.main)
    evas_object_del(el->obj.main);

  if (el->obj.shot)
    evas_object_del(el->obj.shot);

  if (el->obj.swatch)
    evas_object_del(el->obj.swatch);

  if (el->ee)
    ecore_evas_free(el->ee);

  if (el->band)
    elicit_band_free(el->band);

  if (el->palette)
    palette_free(el->palette);

  IF_FREE(el->conf.theme);
  IF_FREE(el->path.theme);
  IF_FREE(el->path.datadir);
  IF_FREE(el->path.confdir);
  IF_FREE(el->path.palette);
  IF_FREE(el->path.conffile);

  free(el);
}

void egxp_opcode_free (Egxp_Opcode * op) {
#ifdef EGXP_DEBUG
  printf("TRACE: egxp_opcode_free\n");
#endif
  assert (op);
  
  /* free only the initial pointer */
  IF_FREE (op->id_string);

  // static string, so it's forbidden to destroy if (op->id_string) free (op->id_string);
  ecore_hash_destroy (op->string_id);
  FREE (op);
}

/**
 * Set the current tag name
 * @param   xml The xml document to modify
 * @param   tag The new tag name
 * @return  @c TRUE if successful, @c FALSE if an error occurs.
 * @ingroup EXML_Modfiy_Element_Group
 */
int exml_tag_set(EXML *xml, char *tag)
{
	CHECK_PARAM_POINTER_RETURN("xml", xml, FALSE);
	CHECK_PARAM_POINTER_RETURN("tag", tag, FALSE);

	IF_FREE(xml->current->tag);

	xml->current->tag = strdup( tag );
	if (!xml->current->tag)
		return FALSE;

	return TRUE;
}