/* proparse.p
 * 2001 by John Green, Joanju Limited
 *
 * API for proparse.dll.
 *
 * Notes on Proparse's MEMPTR return
 * =================================
 * 1. The memory pointed to by the returned MEMPTR (see uses of "ptr")
 *    is managed by proparse.dll. Do not attempt to free that memory with SET-SIZE, etc.
 * 2. The memory pointed to by ptr (null terminated char string) is only guaranteed
 *    to remain allocated until the next function call into Proparse. At that point, it will
 *    have been freed, and trying to access it will likely cause a memory violation. So,
 *    immediately after calling a Proparse function, this API copies the string pointed to
 *    by ptr into a regular Progress CHARACTER variable.
 */


DEFINE VARIABLE c1          AS CHARACTER NO-UNDO.
DEFINE VARIABLE fullname    AS CHARACTER NO-UNDO.
DEFINE VARIABLE i1          AS INTEGER   NO-UNDO.
DEFINE VARIABLE ptr         AS MEMPTR    NO-UNDO.

FUNCTION parserConfigGet RETURNS CHARACTER (theFlag AS CHARACTER) FORWARD.
FUNCTION parserConfigSet RETURNS LOGICAL (theFlag AS CHARACTER, theValue AS CHARACTER) FORWARD.


ON "CLOSE" OF THIS-PROCEDURE DO:
  /* We do NOT unload the DLL here. The DLL is intended to stay loaded through the session. */
  DELETE PROCEDURE THIS-PROCEDURE.
END.

/* Although the DLL is in the PROPATH, it is probably not in the system search PATH,
 * so the OS won't find it unless we search the DLL and load it into memory
 * If we're on Unixes, this isn't relevant as we only use LoadLibraryA on WIN32 platforms.
 */
IF OPSYS <> 'UNIX':U THEN DO:
  FILE-INFO:FILE-NAME = "proparse/proparse.dll":U.
  fullname = FILE-INFO:FULL-PATHNAME.
  IF fullname = ? THEN
     MESSAGE "Did not find proparse/proparse.dll in the PROPATH" VIEW-AS ALERT-BOX.
  ELSE
     RUN LoadLibraryA (fullname).
END.
ELSE DO: /* opsys is unix. Run init, which loads the DLL persistent. */
  RUN init (OUTPUT i1).
END.


/* --- Load environment settings and schema --- */
RUN ComparePreviousConfig.
IF parserConfigGet("init") = "false" THEN DO:

  IF SESSION:BATCH-MODE THEN
     parserConfigSet("batch-mode", "true").
  parserConfigSet("opsys", OPSYS).
  parserConfigSet("propath", PROPATH).
  parserConfigSet("proversion", PROVERSION).
  parserConfigSet("window-system", SESSION:WINDOW-SYSTEM).

  IF NUM-DBS > 0 THEN
    RUN proparse/api/loaddb1.p.

  parserConfigSet("init","true").

END.

RETURN.


PROCEDURE ComparePreviousConfig :
/* ------------------------------------------------------------------------
   purpose : compare currently connected databases with the list of
             databases in the previous run of proparse.p.
             If different databases are connected, or if propath changed,
             then we will need to load the schema again
   ------------------------------------------------------------------------ */
   DEFINE VARIABLE hp           AS HANDLE NO-UNDO.
   DEFINE VARIABLE hpcomparecfg AS HANDLE NO-UNDO.

   /* find running instance of comparecfg.p, or load a new one */
   hp = SESSION:FIRST-PROCEDURE.
   DO WHILE VALID-HANDLE(hp) :
      IF hp:PRIVATE-DATA = "proparse/api/comparecfg.p" THEN
         ASSIGN
            hpcomparecfg = hp
            hp = ?.
      ELSE
         ASSIGN
            hp = hp:NEXT-SIBLING.
   END.
   IF NOT VALID-HANDLE (hpcomparecfg) THEN
      RUN proparse/api/comparecfg.p PERSISTENT SET hpcomparecfg.

   /* do the compare */
   RUN CompareConfiguration IN hpcomparecfg (INPUT THIS-PROCEDURE:handle).
END PROCEDURE.


/* For WIN32 platforms only. */
PROCEDURE LoadLibraryA EXTERNAL "kernel32.dll":U :
   DEFINE INPUT PARAMETER cName AS CHAR.
END PROCEDURE.


/* All of these procedures (below) which refer to "proparse.dll" work for Unix users
 * (as well as WIN32 users) as Unix users will set up a link from proparse.dll to proparse.so
 */

FUNCTION parserAttrGet RETURNS CHARACTER (theHandle AS INTEGER, theKey AS CHARACTER):
  RUN attrGetS(theHandle, theKey, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE attrGetS EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theHandle AS LONG.
  DEFINE INPUT PARAMETER theKey AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS MEMPTR.
END.

FUNCTION parserAttrGetI RETURNS INTEGER (theHandle AS INTEGER, theKey AS INTEGER):
  RUN attrGetI(theHandle, theKey, OUTPUT i1).
  RETURN i1.
END.
PROCEDURE attrGetI EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theHandle AS LONG.
  DEFINE INPUT PARAMETER theKey AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserAttrSet RETURNS LOGICAL (theHandle AS INTEGER, theKey AS INTEGER, theValue AS INTEGER):
  RUN attrSet(theHandle, theKey, theValue, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE attrSet EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theHandle AS LONG.
  DEFINE INPUT PARAMETER theKey AS LONG.
  DEFINE INPUT PARAMETER theValue AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserAttrStringGet RETURNS CHARACTER (theHandle AS INTEGER, theKey AS INTEGER):
  RUN attrStringGet(theHandle, theKey, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE attrStringGet EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theHandle AS LONG.
  DEFINE INPUT PARAMETER theKey AS LONG.
  DEFINE RETURN PARAMETER theReturn AS MEMPTR.
END.

FUNCTION parserAttrStringSet RETURNS LOGICAL (theHandle AS INTEGER, theKey AS INTEGER, theValue AS CHARACTER):
  RUN attrStringSet(theHandle, theKey, theValue, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE attrStringSet EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theHandle AS LONG.
  DEFINE INPUT PARAMETER theKey AS LONG.
  DEFINE INPUT PARAMETER theValue AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserConfigGet RETURNS CHARACTER (theFlag AS CHARACTER):
  RUN configGet(theFlag, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE configGet EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theFlag AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS MEMPTR.
END.

FUNCTION parserConfigSet RETURNS LOGICAL (theFlag AS CHARACTER, theValue AS CHARACTER):
  RUN configSet(theFlag, theValue, OUTPUT i1).
  RETURN TRUE.
END.
PROCEDURE configSet EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theFlag AS CHARACTER.
  DEFINE INPUT PARAMETER theValue AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserCopyHandle RETURNS LOGICAL (fromHandle AS INTEGER, toHandle AS INTEGER):
  RUN copyHandle(fromHandle, toHandle, OUTPUT i1).
  RETURN true.
END.
PROCEDURE copyHandle EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER fromHandle AS LONG.
  DEFINE INPUT PARAMETER toHandle   AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserDictAdd RETURNS LOGICAL (theText AS CHARACTER, theType AS CHARACTER):
  RUN dictAdd(theText, theType, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE dictAdd EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theText AS CHARACTER.
  DEFINE INPUT PARAMETER theType AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserDictDelete RETURNS LOGICAL (theText AS CHARACTER):
  RUN dictDelete(theText, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE dictDelete EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theText AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserDiff RETURNS CHARACTER (file1 AS CHARACTER, file2 AS CHARACTER):
  RUN diff(file1, file2, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE diff EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER file1 AS CHARACTER.
  DEFINE INPUT PARAMETER file2 AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS MEMPTR.
END.

FUNCTION parserErrorClear RETURNS LOGICAL:
  RUN errorClear(OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE errorClear EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserErrorGetIsCurrent RETURNS LOGICAL:
  RUN errorGetIsCurrent(OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE errorGetIsCurrent EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserErrorGetStatus RETURNS INTEGER:
  RUN errorGetStatus(OUTPUT i1).
  RETURN i1.
END.
PROCEDURE errorGetStatus EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserErrorGetText RETURNS CHARACTER:
  RUN errorGetText(OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE errorGetText EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER errorMessage AS MEMPTR.
END.

FUNCTION parserGetHandle RETURNS INTEGER:
  RUN getHandle (OUTPUT i1).
  RETURN i1.
END.
PROCEDURE getHandle EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER ret AS LONG.
END.

FUNCTION parserGetIndexFilename RETURNS CHARACTER (indexnum AS INTEGER):
  RUN getIndexFilename (indexnum, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE getIndexFilename EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER indexnum AS LONG.
  DEFINE RETURN PARAMETER filename AS MEMPTR.
END.

FUNCTION parserGetNodeColumn RETURNS INTEGER (ofHandle AS INTEGER):
  RUN getNodeColumn (ofHandle, OUTPUT i1).
  RETURN i1.
END.
PROCEDURE getNodeColumn EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE RETURN PARAMETER colnum   AS LONG.
END.

FUNCTION parserGetNodeFileIndex RETURNS INTEGER (ofHandle AS INTEGER):
  RUN getNodeFileIndex (ofHandle, OUTPUT i1).
  RETURN i1.
END.
PROCEDURE getNodeFileIndex EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE RETURN PARAMETER indexnum AS LONG.
END.

FUNCTION parserGetNodeFilename RETURNS CHARACTER (ofHandle AS INTEGER):
  RUN getNodeFilename (ofHandle, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE getNodeFilename EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE RETURN PARAMETER filename AS MEMPTR.
END.

FUNCTION parserGetNodeLine RETURNS INTEGER (ofHandle AS INTEGER):
  RUN getNodeLine (ofHandle, OUTPUT i1).
  RETURN i1.
END.
PROCEDURE getNodeLine EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE RETURN PARAMETER linenum  AS LONG.
END.

FUNCTION parserGetNodeText RETURNS CHARACTER (ofHandle AS INTEGER):
  RUN getNodeText (ofHandle, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE getNodeText EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE RETURN PARAMETER nodeText AS MEMPTR.
END.

FUNCTION parserGetNodeType RETURNS CHARACTER (ofHandle AS INTEGER):
  RUN getNodeType (ofHandle, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE getNodeType EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE RETURN PARAMETER type     AS MEMPTR.
END.

FUNCTION parserGetNodeTypeI RETURNS INTEGER (ofHandle AS INTEGER):
  RUN getNodeTypeI (ofHandle, OUTPUT i1).
  RETURN i1.
END.
PROCEDURE getNodeTypeI EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserGetTokenTypeName RETURNS CHARACTER (tokenTypeNumber AS INTEGER):
  RUN getTokenTypeName (tokenTypeNumber, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE getTokenTypeName EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER tokenTypeNumber AS LONG.
  DEFINE RETURN PARAMETER name AS MEMPTR.
END.

FUNCTION parserGetTokenTypeNumber RETURNS INTEGER (tokenTypeName AS CHARACTER):
  RUN getTokenTypeNumber (tokenTypeName, OUTPUT i1).
  RETURN i1.
END.
PROCEDURE getTokenTypeNumber EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER tokenTypeName AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserGetVersion RETURNS CHARACTER:
  RUN getVersion (OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE getVersion EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER version AS MEMPTR.
END.
	
FUNCTION parserHiddenAddToFront RETURNS LOGICAL (theHandle AS INTEGER, newType AS CHARACTER, newText AS CHARACTER):
  RUN hiddenAddToFront (theHandle, newType, newText, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE hiddenAddToFront EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER theHandle AS LONG.
  DEFINE INPUT  PARAMETER newType AS CHARACTER.
  DEFINE INPUT  PARAMETER newText AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserHiddenDelete RETURNS LOGICAL (theHandle AS INTEGER):
  RUN hiddenDelete (theHandle, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE hiddenDelete EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER theHandle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserHiddenGetBefore RETURNS LOGICAL (handle AS INTEGER):
  RUN hiddenGetBefore (handle, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE hiddenGetBefore EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER handle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserHiddenGetColumn RETURNS INTEGER:
  RUN hiddenGetColumn (OUTPUT I1).
  RETURN i1.
END.
PROCEDURE hiddenGetColumn EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserHiddenGetFilename RETURNS CHARACTER:
  RUN hiddenGetFilename (OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE hiddenGetFilename EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS MEMPTR.
END.

FUNCTION parserHiddenGetFirst RETURNS LOGICAL (handle AS INTEGER):
  RUN hiddenGetFirst (handle, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE hiddenGetFirst EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER handle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserHiddenGetLine RETURNS INTEGER:
  RUN hiddenGetLine (OUTPUT I1).
  RETURN i1.
END.
PROCEDURE hiddenGetLine EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserHiddenGetNext RETURNS LOGICAL:
  RUN hiddenGetNext (OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE hiddenGetNext EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserHiddenGetPrevious RETURNS LOGICAL:
  RUN hiddenGetPrevious (OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE hiddenGetPrevious EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserHiddenGetText RETURNS CHARACTER:
  RUN hiddenGetText (OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE hiddenGetText EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS MEMPTR.
END.

FUNCTION parserHiddenGetType RETURNS CHARACTER:
  RUN hiddenGetType (OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE hiddenGetType EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS MEMPTR.
END.

FUNCTION parserHiddenInsertAfter RETURNS LOGICAL (newType AS CHARACTER, newText AS CHARACTER):
  RUN hiddenInsertAfter (newType, newText, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE hiddenInsertAfter EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER newType AS CHARACTER.
  DEFINE INPUT  PARAMETER newText AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserHiddenSetText RETURNS LOGICAL (newText AS CHARACTER):
  RUN hiddenSetText (newText, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE hiddenSetText EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER newText AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserHiddenSetType RETURNS LOGICAL (newType AS CHARACTER):
  RUN hiddenSetType (newType, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE hiddenSetType EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER newType AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserInit RETURNS LOGICAL:
  RUN init (OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE init EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.
	
FUNCTION parserIsSameNode RETURNS LOGICAL (handle1 AS INTEGER, handle2 AS INTEGER):
  RUN isSameNode (handle1, handle2, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE isSameNode EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER handle1 AS LONG.
  DEFINE INPUT  PARAMETER handle2 AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserIsValidNode RETURNS LOGICAL (theHandle AS INTEGER):
  RUN isValidNode (theHandle, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE isValidNode EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER theHandle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.
	
FUNCTION parserIwdiff RETURNS CHARACTER (file1 AS CHARACTER, file2 AS CHARACTER):
  RUN iwdiff (file1, file2, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE iwdiff EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER file1 AS CHARACTER.
  DEFINE INPUT PARAMETER file2 AS CHARACTER.
  DEFINE RETURN PARAMETER version AS MEMPTR.
END.

FUNCTION parserNodeCreate RETURNS LOGICAL (intoHandle AS INTEGER, newType AS CHARACTER, newText AS CHARACTER):
  RUN nodeCreate (intoHandle, newType, newText, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE nodeCreate EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER intoHandle AS LONG.
  DEFINE INPUT  PARAMETER newType AS CHARACTER.
  DEFINE INPUT  PARAMETER newText AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserNodeCreateI RETURNS LOGICAL (intoHandle AS INTEGER, newType AS INTEGER, newText AS CHARACTER):
  RUN nodeCreateI (intoHandle, newType, newText, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE nodeCreateI EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER intoHandle AS LONG.
  DEFINE INPUT  PARAMETER newType AS LONG.
  DEFINE INPUT  PARAMETER newText AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserNodeFirstChild RETURNS CHARACTER (ofHandle AS INTEGER, intoHandle AS INTEGER):
  RUN nodeFirstChild (ofHandle, intoHandle, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE nodeFirstChild EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE INPUT  PARAMETER intoHandle AS LONG.
  DEFINE RETURN PARAMETER nodeType AS MEMPTR.
END.

FUNCTION parserNodeFirstChildI RETURNS INTEGER (ofHandle AS INTEGER, intoHandle AS INTEGER):
  RUN nodeFirstChildI (ofHandle, intoHandle, OUTPUT i1).
  RETURN i1.
END.
PROCEDURE nodeFirstChildI EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE INPUT  PARAMETER intoHandle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.


FUNCTION parserNodeNextSibling RETURNS CHARACTER (ofHandle AS INTEGER, intoHandle AS INTEGER):
  RUN nodeNextSibling (ofHandle, intoHandle, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE nodeNextSibling EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE INPUT  PARAMETER intoHandle AS LONG.
  DEFINE RETURN PARAMETER nodeType AS MEMPTR.
END.

FUNCTION parserNodeNextSiblingI RETURNS INTEGER (ofHandle AS INTEGER, intoHandle AS INTEGER):
  RUN nodeNextSiblingI (ofHandle, intoHandle, OUTPUT i1).
  RETURN i1.
END.
PROCEDURE nodeNextSiblingI EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE INPUT  PARAMETER intoHandle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserNodeParent RETURNS CHARACTER (ofHandle AS INTEGER, intoHandle AS INTEGER):
  RUN nodeParent (ofHandle, intoHandle, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE nodeParent EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE INPUT  PARAMETER intoHandle AS LONG.
  DEFINE RETURN PARAMETER nodeType AS MEMPTR.
END.

FUNCTION parserNodePrevSibling RETURNS CHARACTER (ofHandle AS INTEGER, intoHandle AS INTEGER):
  RUN nodePrevSibling (ofHandle, intoHandle, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE nodePrevSibling EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE INPUT  PARAMETER intoHandle AS LONG.
  DEFINE RETURN PARAMETER nodeType AS MEMPTR.
END.

FUNCTION parserNodeStateHead RETURNS CHARACTER (ofHandle AS INTEGER, intoHandle AS INTEGER):
  RUN nodeStateHead (ofHandle, intoHandle, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE nodeStateHead EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER ofHandle AS LONG.
  DEFINE INPUT  PARAMETER intoHandle AS LONG.
  DEFINE RETURN PARAMETER nodeType AS MEMPTR.
END.

FUNCTION parserNodeTop RETURNS CHARACTER (intoHandle AS INTEGER):
  RUN nodeTop (intoHandle, OUTPUT ptr).
  RETURN GET-STRING(ptr, 1).
END.
PROCEDURE nodeTop EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT  PARAMETER intoHandle AS LONG.
  DEFINE RETURN PARAMETER nodeType AS MEMPTR.
END.

FUNCTION parserParse RETURNS LOGICAL (filename AS CHARACTER):
  RUN parse (filename, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE parse EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER filename AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserParseCreate RETURNS INTEGER (parseType AS CHARACTER, filename AS CHARACTER):
  RUN parseCreate(parseType, filename, OUTPUT i1).
  RETURN i1.
END.
PROCEDURE parseCreate EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER parseType AS CHARACTER.
  DEFINE INPUT PARAMETER filename AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserParseDelete RETURNS LOGICAL (parseNum AS INTEGER):
  RUN parseDelete(parseNum, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE parseDelete EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER parseNum AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserParseGetTop RETURNS LOGICAL (parseNum AS INTEGER, intoHandle AS INTEGER):
  RUN parseGetTop(parseNum, intoHandle, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE parseGetTop EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER parseNum AS LONG.
  DEFINE INPUT PARAMETER intoHandle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserQueryClear RETURNS LOGICAL (queryName AS CHARACTER):
  RUN queryClear (queryName, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE queryClear EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER queryName AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserQueryCreate RETURNS INTEGER (fromNode AS INTEGER, queryName AS CHARACTER, nodeType AS CHARACTER):
  RUN queryCreate (fromNode, queryName, nodeType, OUTPUT i1).
  RETURN i1.
END.
PROCEDURE queryCreate EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER fromNode AS LONG.
  DEFINE INPUT PARAMETER queryName AS CHARACTER.
  DEFINE INPUT PARAMETER nodeType AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserQueryGetResult RETURNS LOGICAL (queryName AS CHARACTER, resultNum AS INTEGER, intoHandle AS INTEGER):
  RUN queryGetResult (queryName, resultNum, intoHandle, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE queryGetResult EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER queryName AS CHARACTER.
  DEFINE INPUT PARAMETER resultNum AS LONG.
  DEFINE INPUT PARAMETER intoHandle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserReleaseHandle RETURNS LOGICAL (theHandle AS INTEGER):
  RUN releaseHandle (theHandle, OUTPUT i1).
  RETURN TRUE.
END.
PROCEDURE releaseHandle EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theHandle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserSchemaAddDb RETURNS LOGICAL (name AS CHARACTER):
  RUN schemaAddDb (name, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE schemaAddDb EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER name AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserSchemaAddTable RETURNS LOGICAL (name AS CHARACTER):
  RUN schemaAddTable (name, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE schemaAddTable EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER name AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserSchemaAliasCreate RETURNS LOGICAL (aliasname AS CHARACTER, dbasename AS CHARACTER):
  RUN schemaAliasCreate (aliasname, dbasename, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE schemaAliasCreate EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER aliasname AS CHARACTER.
  DEFINE INPUT PARAMETER dbasename AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserSchemaAliasDelete RETURNS LOGICAL (aliasname AS CHARACTER):
  RUN schemaAliasDelete (aliasname, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE schemaAliasDelete EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER aliasname AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserSchemaClear RETURNS LOGICAL ():
  RUN schemaClear (OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE schemaClear EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserSetNodeFirstChild RETURNS LOGICAL (parentHandle AS INTEGER, childHandle AS INTEGER):
  RUN setNodeFirstChild (parentHandle, childHandle, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE setNodeFirstChild EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER parentHandle AS LONG.
  DEFINE INPUT PARAMETER childHandle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserSetNodeNextSibling RETURNS LOGICAL (leftHandle AS INTEGER, rightHandle AS INTEGER):
  RUN setNodeNextSibling (leftHandle, rightHandle, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE setNodeNextSibling EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER leftHandle AS LONG.
  DEFINE INPUT PARAMETER rightHandle AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserSetNodeText RETURNS LOGICAL (ofHandle AS INTEGER, newText AS CHARACTER):
  RUN setNodeText (ofHandle, newText, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE setNodeText EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER ofHandle AS LONG.
  DEFINE INPUT PARAMETER newText AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserSetNodeType RETURNS LOGICAL (ofHandle AS INTEGER, newType AS CHARACTER):
  RUN setNodeType (ofHandle, newType, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE setNodeType EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER ofHandle AS LONG.
  DEFINE INPUT PARAMETER newType AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserSetNodeTypeI RETURNS LOGICAL (ofHandle AS INTEGER, newType AS INTEGER):
  RUN setNodeTypeI (ofHandle, newType, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE setNodeTypeI EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER ofHandle AS LONG.
  DEFINE INPUT PARAMETER newType AS LONG.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.

FUNCTION parserWriteNode RETURNS LOGICAL (theHandle AS INTEGER, filename AS CHARACTER):
  RUN writeNode (theHandle, filename, OUTPUT i1).
  IF i1 < 1 THEN RETURN FALSE. ELSE RETURN TRUE.
END.
PROCEDURE writeNode EXTERNAL "proparse.dll" CDECL PERSISTENT:
  DEFINE INPUT PARAMETER theHandle AS LONG.
  DEFINE INPUT PARAMETER filename AS CHARACTER.
  DEFINE RETURN PARAMETER theReturn AS LONG.
END.