G:/ScriptBasic/source/extensions/xml/interface.c

Go to the documentation of this file.

/*
  FILE   : interface.c
  HEADER : interface.h
  BAS    : xml.bas
  AUTHOR : *TODO*

  DATE: 

  CONTENT:
  This is the interface.c file for the ScriptBasic module xml

NTLIBS: /link /NODEFAULTLIB:"libcmt.lib" libxml2_a.lib iconv_a.lib ws2_32.lib
UXLIBS: -lxml2
*/

#include <stdio.h>
#include "../../basext.h"

#include <libxml/parser.h>

/*
*TODO*
INSERT THE BASIC CODE THAT WILL GET INTO THE FILE xml.BAS
AFTER THE LINE 'TO_BAS:' AND BEFORE THE LINE END OF THE COMMENT

NOTE THAT SUB AND COMMAND DECLARATIONS ARE CREATED AUTOMATICALLY
FROM THE FUNCTION DEFINTIONS WHEN THE MODULE IS CONFIGURED BEFORE
COMPILATION

TO_BAS:
REM """
The module xml.bas is based on the Gnome libxml2 library.
"""
*/

typedef struct _ModuleObject {
  void *HandleArray;
  }ModuleObject,*pModuleObject;


#define GET_ARGUMENT_POINTER(X,Y) \
  if( besARGNR < Y )return COMMAND_ERROR_ARGUMENT_RANGE;\
  Argument = besARGUMENT(Y);\
  besDEREFERENCE(Argument);\
  if( Argument == NULL )X=NULL; else { \
      if( Argument->vType != VTYPE_STRING ||\
          STRLEN(Argument) != sizeof(void *) ){\
    return COMMAND_ERROR_ARGUMENT_RANGE;\
    }\
  memcpy(&(X),STRINGVALUE(Argument),sizeof(void *));\
  }

#define RETURN_POINTER(X) \
   besALLOC_RETURN_STRING( sizeof( void *) );\
   memcpy(STRINGVALUE(besRETURNVALUE),&(X),sizeof(void *));

/*
*TODO*
ALTER THE VERSION NEGOTIATION CODE IF YOU NEED
*/
besVERSION_NEGOTIATE
  return (int)INTERFACE_VERSION;
besEND

/*
*TODO*
ALTER THE ERROR MESSAGE FUNCTION
*/
besSUB_ERRMSG

  switch( iError ){
    case 0x00080000: return "ERROR HAS HAPPENED";
    }
  return "Unknown xml module error.";
besEND

/*
*TODO*
ALTER THE MODULE INITIALIZATION CODE
*/
besSUB_START
  pModuleObject p;

  besMODULEPOINTER = besALLOC(sizeof(ModuleObject));
  if( besMODULEPOINTER == NULL )return 0;

  p = (pModuleObject)besMODULEPOINTER;
  return 0;
besEND

/*
*TODO*
ALTER THE MODULE FINISH CODE IF NEEDED
*/
besSUB_FINISH
  pModuleObject p;

  p = (pModuleObject)besMODULEPOINTER;
  if( p == NULL )return 0;
  return 0;
besEND

besFUNCTION(sbxmlParseFile)
  xmlDocPtr doc;
  char *pszFileName;

  besARGUMENTS("z")
    &pszFileName
  besARGEND

  doc = xmlParseFile(pszFileName);
  besFREE(pszFileName);

  besRETURN_POINTER(doc);
besEND

besFUNCTION(sbxmlNewDoc)
  xmlDocPtr doc;
  char *pszVersion;

  besARGUMENTS("z")
    &pszVersion
  besARGEND

  doc = xmlNewDoc(pszVersion);

  besFREE(pszVersion);

  besRETURN_POINTER(doc);
besEND

besFUNCTION(sbxmlFreeDoc)
  xmlDocPtr doc;

  besARGUMENTS("p")
    &doc
  besARGEND

  xmlFreeDoc(doc);
besEND

besFUNCTION(getchildren)
  xmlDocPtr doc;

  besARGUMENTS("p")
    &doc
  besARGEND

  besRETURN_POINTER(doc->children);
besEND

besFUNCTION(setchildren)
  xmlDocPtr doc;
  xmlNodePtr child;

  besARGUMENTS("pp")
    &doc , &child
  besARGEND
  doc->children = child;
besEND

besFUNCTION(getnext)
  xmlDocPtr doc;

  besARGUMENTS("p")
    &doc
  besARGEND

  besRETURN_POINTER(doc->next);
besEND

besFUNCTION(setnext)
  xmlDocPtr doc;
  xmlNodePtr nxt;

  besARGUMENTS("pp")
    &doc , &nxt
  besARGEND
  doc->next = nxt;
besEND

besFUNCTION(getprev)
  xmlDocPtr doc;

  besARGUMENTS("p")
    &doc
  besARGEND

  besRETURN_POINTER(doc->prev);
besEND

besFUNCTION(setprev)
  xmlDocPtr doc;
  xmlNodePtr prv;

  besARGUMENTS("pp")
    &doc , &prv
  besARGEND
  doc->prev = prv;
besEND

besFUNCTION(getparent)
  xmlDocPtr doc;

  besARGUMENTS("p")
    &doc
  besARGEND

  besRETURN_POINTER(doc->parent);
besEND

besFUNCTION(setparent)
  xmlDocPtr doc;
  xmlNodePtr par;

  besARGUMENTS("pp")
    &doc , &par
  besARGEND
  doc->parent = par;
besEND

besFUNCTION(sbxmlSetProp)
  xmlNodePtr node;
  char *pszName, *pszValue;


  besARGUMENTS("pzz")
    &node, &pszName , &pszValue
  besARGEND

  xmlSetProp(node,pszName,pszValue);

  besFREE(pszName);
  besFREE(pszValue);
besEND

besFUNCTION(sbxmlGetProp)
  xmlNodePtr node;
  char *pszName;
  char *pszValue;

  besARGUMENTS("pz")
    &node, &pszName
  besARGEND

  pszValue = xmlGetProp(node,pszName);
  besSET_RETURN_STRING( pszValue );
  if( pszValue )xmlMemFree(pszValue);
besEND

besFUNCTION(sbxmlNewNs)
  xmlNodePtr node;
  xmlChar *href;
  xmlChar *prefix;
  xmlNsPtr ns;

  besARGUMENTS("pzz")
    &node , &href , &prefix
  besARGEND

  ns = xmlNewNs(node,href,prefix);

  besFREE(href);
  besFREE(prefix);
  besRETURN_POINTER(ns);
besEND

besFUNCTION(sbxmlFreeNs)
  xmlNsPtr ns;

  besARGUMENTS("p")
    &ns
  besARGEND

  xmlFreeNs(ns);
besEND

besFUNCTION(sbxmlNewChild)
  xmlNodePtr node;
  xmlNsPtr ns;
  xmlChar *name;
  xmlChar *content;

  besARGUMENTS("p[p]z[z]")
    &node , &ns , &name , &content
  besARGEND

  node = xmlNewChild(node,ns,name,content);

  besFREE(name);
  besFREE(content);

  besRETURN_POINTER(node);
besEND

besFUNCTION(sbxmlNewTextChild)
  xmlNodePtr node;
  xmlNsPtr ns;
  xmlChar *name;
  xmlChar *content;

  besARGUMENTS("p[p]z[z]")
    &node , &ns , &name , &content
  besARGEND

  node = xmlNewTextChild(node,ns,name,content);

  besFREE(name);
  besFREE(content);

  besRETURN_POINTER(node);
besEND

besFUNCTION(sbxmlNewDocNode)
  xmlDocPtr doc;
  xmlNodePtr node;
  xmlNsPtr ns;
  xmlChar *name;
  xmlChar *content;

  besARGUMENTS("p[p]z[z]")
    &doc , &ns , &name , &content
  besARGEND

  node = xmlNewDocNode(doc,ns,name,content);

  besFREE(name);
  besFREE(content);

  besRETURN_POINTER(node);
besEND
besFUNCTION(sbxmlDocDumpMemory)
  VARIABLE Argument;
  xmlDocPtr p;
  xmlChar *mem;
  int size;

  GET_ARGUMENT_POINTER(p,1);
  xmlDocDumpMemory(p,&mem,&size);
  besALLOC_RETURN_STRING(size);
  memcpy(STRINGVALUE(besRETURNVALUE),mem,size);

besEND

/*
*TODO*
INSERT HERE THE NAME OF THE FUNCTION AND THE FUNCTION INTO THE
TABLE. THIS TABLE IS USED TO FIND THE FUNCTIONS WHEN THE MODULE
INTERFACE FILE IS COMPILED TO BE LINKED STATIC INTO A VARIATION
OF THE INTERPRETER.
*/

SLFST XML_SLFST[] ={

{ "versmodu" , versmodu },
{ "bootmodu" , bootmodu },
{ "finimodu" , finimodu },
{ "emsgmodu" , emsgmodu },
{ "sbxmlParseFile"     , sbxmlParseFile     },
{ "sbxmlNewDoc"        , sbxmlNewDoc        },
{ "sbxmlFreeDoc"       , sbxmlFreeDoc       },
{ "sbxmlNewNs"         , sbxmlNewNs         },
{ "sbxmlFreeNs"        , sbxmlFreeNs        },
{ "getchildren"        , getchildren        },
{ "setchildren"        , setchildren        },
{ "getnext"            , getnext            },
{ "setnext"            , setnext            },
{ "getprev"            , getprev            },
{ "setprev"            , setprev            },
{ "sbxmlSetProp"       , sbxmlSetProp       },
{ "sbxmlNewChild"      , sbxmlNewChild      },
{ "sbxmlNewTextChild"  , sbxmlNewTextChild  },
{ "sbxmlNewDocNode"    , sbxmlNewDocNode    },
{ "sbxmlDocDumpMemory" , sbxmlDocDumpMemory },
{ NULL , NULL }
  };

---