Referência ao ficheiro src/vapiMacroXML.c

#include <stdio.h>
#include "vapiTypes.h"
#include "vapiAux.h"
#include "vapiString.h"
#include "vapiMacro.h"
#include "vapiMacroList.h"
#include "vapiOperationList.h"
#include "vapiOperationOptions.h"
#include "vapiGtkAux.h"
#include "vapiGtkAuxWindow.h"
#include "vapiOptions.h"
#include "vapiOptionsXML.h"
#include "vapiXML.h"
#include "vapiOperationXML.h"
#include <libxml/encoding.h>
#include <libxml/xmlreader.h>
#include <libxml/xmlwriter.h>
#include <string.h>

Diagrama de dependências de inclusão para vapiMacroXML.c:

Ir para o código fonte deste ficheiro.

Funções
vMacroHeader *	vapiMacroFromXML (const char *filename, vOperationList *OperationList, vMacroList *MacroList)
	Imports a Macro from XML. It imports the Macro Name, Comments, Operations and Options.
char *	vapiMacroFromXMLSetName (const char *filename)
	Get the Name of the Macro from the XML.
void	vapiMacroToXML (vMacroHeader *MacroHeader, const char *filename)
	Exports a Macro to XML It will export the Operation Definitions and the options, if different from default.
static xmlTextWriter *	vapiMacroXMLFileInit (vMacroHeader *MacroHeader, const char *filename)
vBoolean	vapiMacroXMLLoadToList (vMacroList *MacroList, vOperationList *OperationList, const char *filename)
	Loads a Macro directly from file to the MacroList.

---

Documentação das funções

vMacroHeader* vapiMacroFromXML	(	const char *	filename,
		vOperationList *	OperationList,
		vMacroList *	MacroList
	)

Imports a Macro from XML. It imports the Macro Name, Comments, Operations and Options.

Parâmetros:

filename

The xml filename.

Definido na linha 122 do ficheiro vapiMacroXML.c.

Referências _vMacroHeader::Macro, MacroList, OperationList, _vEffect::OptionsSettings, v_debug, vapiCheckOperations(), vapiMacroAddItem(), vapiMacroNew(), vapiMacroUpdateComment(), vapiOperationListSelectOperation(), vapiOperationOptionsInit(), vapiOptionsCheck(), vapiOptionsXMLSetOptions(), vapiOptionsXMLSetOptionsOperation() e vapiXMLNextElement().

Referenciado por vapiMacroXMLLoadToList().

{
        xmlTextReader *xmlInput;
        vMacroHeader *MacroHeader;
        vEffect *tempOperation;
        vOptions *tempOptions;
        int ret = 1;
        xmlInput = xmlReaderForFile (filename, "ISO-8859-1", XML_PARSE_DTDATTR |        /* default DTD attributes */
                                     XML_PARSE_NOENT |  /* substitute entities */
                                     XML_PARSE_DTDVALID);       /* validate with the DTD */

        if (xmlInput == NULL)
        {
                return NULL;
        }
        xmlTextReaderRead (xmlInput);
        if (!strcmp
            ((char *) xmlTextReaderLocalName (xmlInput), "vapiMacro "))
        {
                return MacroHeader = 0;
        }

        vapiXMLNextElement (xmlInput);
        MacroHeader =
                vapiMacroNew ((char *) xmlTextReaderGetAttribute
                              (xmlInput, BAD_CAST "name"));
        /*
         * Entramos nas Operações.
         */
        if (vapiXMLNextElement (xmlInput) > 0)
        {
                if (!strcmp
                    ((char *) xmlTextReaderLocalName (xmlInput), "Comment"))
                {
                        v_debug ("comentário lido: .%s.", xmlTextReaderReadString
                                                (xmlInput));
                        vapiMacroUpdateComment (MacroHeader,
                                                (char *)
                                                xmlTextReaderReadString
                                                (xmlInput));
                        v_debug ("comentário lido: .%s.", xmlTextReaderReadString
                                                (xmlInput));
                        vapiXMLNextElement (xmlInput);
                        
                }
                if (strcmp
                    ((char *) xmlTextReaderLocalName (xmlInput), "Operation"))
                {
                        return MacroHeader = 0;
                }

                while (ret > 0)
                {

                        tempOperation =
                                vapiOperationListSelectOperation
                                (OperationList, (char *)
                                 xmlTextReaderGetAttribute (xmlInput,
                                                            BAD_CAST "name"));
                        v_debug ("operation name: %s",
                                 xmlTextReaderGetAttribute (xmlInput,
                                                            BAD_CAST "name"));

                        tempOptions =
                                vapiOperationOptionsInit (tempOperation);

                        vapiOptionsXMLSetOptions (xmlInput, tempOptions,
                                                  &vapiOptionsXMLSetOptionsOperation);

                        vapiMacroAddItem (MacroHeader->Macro,
                                          tempOperation, tempOptions);
                        ret = vapiXMLNextElement (xmlInput);

                        vapiOptionsCheck (tempOperation->OptionsSettings,
                                          tempOptions);

                        vapiCheckOperations (tempOperation, tempOptions,
                                             MacroList);
                }

        }


        //v_info ("Carregada a Macro de xml");
        return MacroHeader;
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

char* vapiMacroFromXMLSetName

(

const char *

filename

)

Get the Name of the Macro from the XML.

Parâmetros:

filename

The xml filename.

Retorna:

the name of the macro that the xml holds, or returns NULL if it is not a valid vpiMaccroXML file.

Definido na linha 211 do ficheiro vapiMacroXML.c.

Referências vapiXMLNextElement().

Referenciado por vapiGtkMacroOpenFromXML(), vapiGtkMacroTestXMLFileOpen(), vapiGtkMacroUpdateMacroName() e vapiMacroXMLLoadToList().

{

        xmlTextReader *xmlInput;

        xmlInput = xmlReaderForFile (filename, "ISO-8859-1", XML_PARSE_DTDATTR |        /* default DTD attributes */
                                     XML_PARSE_NOENT |  /* substitute entities */
                                     XML_PARSE_DTDVALID);       /* validate with the DTD */

        if (xmlInput == NULL)
        {
                return NULL;
        }
        if (xmlTextReaderRead (xmlInput) < 0)
        {
                return NULL;
        }

        if (!strcmp
            ((char *) xmlTextReaderLocalName (xmlInput), "vapiMacro "))
        {
                return NULL;
        }

        vapiXMLNextElement (xmlInput);
        return ((char *)
                xmlTextReaderGetAttribute (xmlInput, BAD_CAST "name"));
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiMacroToXML	(	vMacroHeader *	MacroHeader,
		const char *	filename
	)

Exports a Macro to XML It will export the Operation Definitions and the options, if different from default.

Parâmetros:

filename

the name of the xml file to save to.

Definido na linha 68 do ficheiro vapiMacroXML.c.

Referências _vMacroHeader::Macro, _vEffect::name, _vMacroItem::Operation, _vMacroItem::Options, _vEffect::OptionsSettings, v_info(), vapiMacroCountElements(), vapiMacroSelectItem(), vapiMacroXMLFileInit(), vapiOptionsXMLGetOptions() e vapiOptionsXMLGetOptionsOperation().

Referenciado por vapiGtkMacroSaveToXML().

{
        xmlTextWriter *xmlOutput;
        int i, OperationNumber;
        vMacroItem *Item;

        /*
         * Criar cabeçalho do Ficheiro XML.
         */

        xmlOutput = vapiMacroXMLFileInit (MacroHeader, filename);

        /*
         * Ir a cada Operação da Macro.
         */

        OperationNumber = vapiMacroCountElements (MacroHeader->Macro);

        if (!OperationNumber)
        {
                return;
        }

        for (i = 0; i < OperationNumber; i++)
        {
                Item = vapiMacroSelectItem (MacroHeader->Macro, i);

                xmlTextWriterStartElement (xmlOutput, BAD_CAST "Operation");

                xmlTextWriterWriteAttribute (xmlOutput, BAD_CAST "name",
                                             BAD_CAST Item->Operation->name);

                /*
                 * Get Options.
                 */
                vapiOptionsXMLGetOptions (xmlOutput,
                                          Item->Operation->OptionsSettings,
                                          Item->Options,
                                          &vapiOptionsXMLGetOptionsOperation);


                xmlTextWriterEndElement (xmlOutput);

        }


        xmlTextWriterEndDocument (xmlOutput);

        xmlFreeTextWriter (xmlOutput);
        v_info ("Guardada Macro para xml");

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

static xmlTextWriter* vapiMacroXMLFileInit	(	vMacroHeader *	MacroHeader,
		const char *	filename
	)			[static]

Definido na linha 21 do ficheiro vapiMacroXML.c.

Referências _vMacroHeader::MacroComment, _vMacroHeader::MacroName e vapiOptionsXMLOptionsElement().

Referenciado por vapiMacroToXML().

{
        xmlTextWriter *xmlOutput;

        /*
         * Como colocar a string do ficheiro Automatica.
         */

        xmlOutput = xmlNewTextWriterFilename (filename, 0);

        xmlTextWriterSetIndent (xmlOutput, 1);

        xmlTextWriterStartDocument (xmlOutput, NULL, "ISO-8859-1", NULL);

        xmlTextWriterStartDTD (xmlOutput, BAD_CAST "vapiMacro", NULL, NULL);

        xmlTextWriterWriteDTDElement (xmlOutput,
                                      BAD_CAST "vapiMacro",
                                      BAD_CAST "(Operation*,Comment?)");
        xmlTextWriterWriteDTDAttlist (xmlOutput,
                                      BAD_CAST "vapiMacro",
                                      BAD_CAST "name NMTOKENS #REQUIRED");
        xmlTextWriterWriteDTDElement (xmlOutput, BAD_CAST "Comment",
                                      BAD_CAST "(#PCDATA)");
        xmlTextWriterWriteDTDElement (xmlOutput,
                                      BAD_CAST "Operation",
                                      BAD_CAST "(option)*");
        xmlTextWriterWriteDTDAttlist (xmlOutput,
                                      BAD_CAST "Operation",
                                      BAD_CAST "name NMTOKENS #REQUIRED");

        vapiOptionsXMLOptionsElement (xmlOutput, 2, "times", "original");

        xmlTextWriterEndDTD (xmlOutput);

        xmlTextWriterStartElement (xmlOutput, BAD_CAST "vapiMacro");
        xmlTextWriterWriteAttribute (xmlOutput, BAD_CAST "name",
                                     BAD_CAST MacroHeader->MacroName);
        
        xmlTextWriterStartElement (xmlOutput, BAD_CAST "Comment");
        xmlTextWriterWriteString (xmlOutput, BAD_CAST MacroHeader->MacroComment);
        xmlTextWriterEndElement (xmlOutput);

        return xmlOutput;
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

vBoolean vapiMacroXMLLoadToList	(	vMacroList *	MacroList,
		vOperationList *	OperationList,
		const char *	filename
	)

Loads a Macro directly from file to the MacroList.

Retorna:

vTRUE if it has errors.

Definido na linha 241 do ficheiro vapiMacroXML.c.

Referências MacroList, MacroName, OperationList, vapiMacroFromXML(), vapiMacroFromXMLSetName(), vapiMacroListAddItem(), vapiMacroListMacroExist(), vFALSE e vTRUE.

Referenciado por vapiGtkMacroOpenFromXML() e vapiLoadExampleMacros().

{
        char *MacroName;
        vMacroHeader *MacroHeader;

        MacroName = vapiMacroFromXMLSetName (filename);

        if (MacroName == NULL)
        {
                return vFALSE;
        }

        if (vapiMacroListMacroExist (MacroList, MacroName, 1) == -1)
        {
                return vFALSE;
        }

        MacroHeader = vapiMacroFromXML (filename, OperationList, MacroList);

        vapiMacroListAddItem (MacroList, MacroHeader);

        return vTRUE;

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

---