//
// TextScan BN 18-Mai-98
//
//
//
//
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <io.h>
#include <stdio.h>
#include <string.h>

#include "WinMain.h"
#include "System.h"
#include "TextScan.h"

#define __CFILE__ "TextScan"
char TEXTSCAN_acString[1024];

extern int nKommentar;

// *****************************************************************
// Init
// *****************************************************************
TextScan::Init (char *acText)
{
int nRet=FALSE;


if(nStatus==FALSE){
ListeBegrenzer.vlInit();
ListeGeleseneWoerter.vlInit();
ListeGeleseneBegrenzer.vlInit();
nAktuelle_Position_Zeichen = 0;
nTextGesamtLaenge = strlen(acText);
acTextPointer = acText;
nStatus = nRet = TRUE;
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.Init] nStatus==TRUE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// DeInit
// *****************************************************************
TextScan::DeInit ()
{
int nRet=FALSE;


if(nStatus==TRUE){
ListeBegrenzer.vlDeInit();
ListeGeleseneWoerter.vlDeInit();
ListeGeleseneBegrenzer.vlDeInit();
nAktuelle_Position_Zeichen = 0;
nTextGesamtLaenge = 0;
acTextPointer = NULL;
nStatus = FALSE;
nRet = TRUE;
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.DeInit] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// ReadNextWord
// *****************************************************************
TextScan::ReadNextWord (void)
{
int nRet=FALSE;
char *acDelimitor;
long lLaenge;
int nDelimitorGefunden;
long lAltePosition;
char *acDummy;
char cChecked, cChecked2, cChecked3;
char acCR[10];
int nWeiter;


sprintf(acCR, "%c%c", 0xD, 0xA);
if(nStatus==TRUE){
if(nAktuelle_Position_Zeichen<nTextGesamtLaenge){
nDelimitorGefunden = FALSE;
lAltePosition = nAktuelle_Position_Zeichen;
while(nDelimitorGefunden==FALSE && nAktuelle_Position_Zeichen<=nTextGesamtLaenge){

memcpy(&cChecked, (acTextPointer + nAktuelle_Position_Zeichen), 1);
// cChecked = acTextPointer[nAktuelle_Position_Zeichen];
if(nAktuelle_Position_Zeichen<nTextGesamtLaenge){
memcpy(&cChecked2, (acTextPointer + nAktuelle_Position_Zeichen + 1), 1);
// cChecked2 = acTextPointer[nAktuelle_Position_Zeichen];
} else {
cChecked2 = 0;
}

if((nKommentar==FALSE || nKommentar==1) && cChecked==34){ // " 34
if(nKommentar==FALSE){
nKommentar = 1;
} else {
nKommentar = FALSE;
}
} else if((nKommentar==FALSE || nKommentar==2) && cChecked==39){ // ' 39
if(nKommentar==FALSE){
nKommentar = 2;
} else {
nKommentar = FALSE;
}
} else if((nKommentar==FALSE && cChecked=='/' && cChecked2=='/') || (nKommentar==3 && cChecked==0xD && cChecked2==0xA)){ // //
if(nKommentar==FALSE){
nKommentar = 3;
} else {
nKommentar = FALSE;
}
} else if(nKommentar==FALSE && cChecked=='/' && cChecked2=='*'){ // /*
nKommentar = 4;
} else if(nKommentar==4 && cChecked=='*' && cChecked2=='/'){ // */
nKommentar = FALSE;
}

if(nKommentar==FALSE || nKommentar==4){
ListeBegrenzer.vlroot();
while(nDelimitorGefunden==FALSE && ListeBegrenzer.vlnext(&acDelimitor, &lLaenge)){
if(strncmp((acTextPointer + nAktuelle_Position_Zeichen), acDelimitor, lLaenge)==FALSE){

if(nKommentar==FALSE || (nKommentar==4 && strncmp(acDelimitor, acCR, 2)==FALSE)){

// case, break und default müssen genau geprüft werden --> Delimitors
nWeiter = TRUE;
if(strncmp(acDelimitor, "case", 4)==FALSE && (nAktuelle_Position_Zeichen + 3 + 1)<=nTextGesamtLaenge){
memcpy(&cChecked3, (acTextPointer + nAktuelle_Position_Zeichen + 3 + 1), 1);
if ((nAktuelle_Position_Zeichen + 3 + 1)<=nTextGesamtLaenge && strncmp((acTextPointer + nAktuelle_Position_Zeichen + 3 + 1), "{", 1)==FALSE
|| (nAktuelle_Position_Zeichen + 3 + 1)<=nTextGesamtLaenge && strncmp((acTextPointer + nAktuelle_Position_Zeichen + 3 + 1), "}", 1)==FALSE
|| (nAktuelle_Position_Zeichen + 3 + 2)<=nTextGesamtLaenge && strncmp((acTextPointer + nAktuelle_Position_Zeichen + 3 + 1), acCR, 2)==FALSE
|| (nAktuelle_Position_Zeichen + 3 + 1)<=nTextGesamtLaenge && CBezeichner(cChecked3)==TRUE)

{
} else {
nWeiter = FALSE;
}
} else if(strncmp(acDelimitor, "break", 5)==FALSE && (nAktuelle_Position_Zeichen + 4 + 1)<=nTextGesamtLaenge){
memcpy(&cChecked3, (acTextPointer + nAktuelle_Position_Zeichen + 4 + 1), 1);
if ((nAktuelle_Position_Zeichen + 4 + 1)<=nTextGesamtLaenge && strncmp((acTextPointer + nAktuelle_Position_Zeichen + 4 + 1), "{", 1)==FALSE
|| (nAktuelle_Position_Zeichen + 4 + 1)<=nTextGesamtLaenge && strncmp((acTextPointer + nAktuelle_Position_Zeichen + 4 + 1), "}", 1)==FALSE
|| (nAktuelle_Position_Zeichen + 4 + 2)<=nTextGesamtLaenge && strncmp((acTextPointer + nAktuelle_Position_Zeichen + 4 + 1), acCR, 2)==FALSE
|| (nAktuelle_Position_Zeichen + 4 + 1)<=nTextGesamtLaenge && CBezeichner(cChecked3)==TRUE)

{
} else {
nWeiter = FALSE;
}
} else if(strncmp(acDelimitor, "default", 7)==FALSE && (nAktuelle_Position_Zeichen + 6 + 1)<=nTextGesamtLaenge){
memcpy(&cChecked3, (acTextPointer + nAktuelle_Position_Zeichen + 6 + 1), 1);
if ((nAktuelle_Position_Zeichen + 6 + 1)<=nTextGesamtLaenge && strncmp((acTextPointer + nAktuelle_Position_Zeichen + 6 + 1), "{", 1)==FALSE
|| (nAktuelle_Position_Zeichen + 6 + 1)<=nTextGesamtLaenge && strncmp((acTextPointer + nAktuelle_Position_Zeichen + 6 + 1), "}", 1)==FALSE
|| (nAktuelle_Position_Zeichen + 6 + 2)<=nTextGesamtLaenge && strncmp((acTextPointer + nAktuelle_Position_Zeichen + 6 + 1), acCR, 2)==FALSE
|| (nAktuelle_Position_Zeichen + 6 + 1)<=nTextGesamtLaenge && CBezeichner(cChecked3)==TRUE)

{
} else {
nWeiter = FALSE;
}
}

if(nWeiter==TRUE){
nDelimitorGefunden = TRUE;
nAktuelle_Position_Zeichen += (lLaenge - 1);
}
}
}
}
}
nAktuelle_Position_Zeichen++;
}
nRet = TRUE;
if((nAktuelle_Position_Zeichen - lAltePosition - lLaenge)<=0){
ListeGeleseneWoerter.vlnew(&acDummy, 1);
memset(acDummy, 0, 1);
} else {
ListeGeleseneWoerter.vlnew(&acDummy, nAktuelle_Position_Zeichen - lAltePosition - lLaenge + 1);
memset(acDummy, 0, nAktuelle_Position_Zeichen - lAltePosition - lLaenge + 1);
memcpy(acDummy, (acTextPointer + lAltePosition), nAktuelle_Position_Zeichen - lAltePosition - lLaenge);
}
if(nDelimitorGefunden==FALSE){
ListeGeleseneBegrenzer.vlnew(&acDummy, strlen(" ") + 1);
memset(acDummy, 0, strlen(" ") + 1);
memcpy(acDummy, " ", strlen(" "));
} else {
ListeGeleseneBegrenzer.vlnew(&acDummy, lLaenge + 1);
memset(acDummy, 0, lLaenge + 1);
memcpy(acDummy, acDelimitor, lLaenge);
}
}
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.ReadNextWord] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// GetReadedWord
// *****************************************************************
TextScan::GetReadedWord (char *acReadedWord)
{
int nRet=FALSE;
long lLaenge;


if(nStatus==TRUE){
nRet = ListeGeleseneWoerter.vllast(acReadedWord, &lLaenge);
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.GetReadedWord] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// GetReadedDelimitor
// *****************************************************************
TextScan::GetReadedDelimitor (char *acReadedDelimitor)
{
int nRet=FALSE;
long lLaenge;


if(nStatus==TRUE){
nRet = ListeGeleseneBegrenzer.vllast(acReadedDelimitor, &lLaenge);
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.GetReadedDelimitor] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// GetReadedWords
// *****************************************************************
TextScan::GetReadedWords (int nFirst, char *acReadedWord, long *lLength)
{
int nRet=FALSE;
char *acGelesenesWort;


if(nStatus==TRUE){
if(nFirst==TRUE){
ListeGeleseneWoerter.vlroot();
}
nRet = ListeGeleseneWoerter.vlnext(&acGelesenesWort, lLength);
if(nRet==TRUE){
memcpy(acReadedWord, &acGelesenesWort, sizeof(long));
}
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.GetReadedWords] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// GetReadedDelimitors
// *****************************************************************
TextScan::GetReadedDelimitors (int nFirst, char *acReadedDelimitor, long *lLength)
{
int nRet=FALSE;
char *acGelesenesTrennzeichen;


if(nStatus==TRUE){
if(nFirst==TRUE){
ListeGeleseneBegrenzer.vlroot();
}
nRet = ListeGeleseneBegrenzer.vlnext(&acGelesenesTrennzeichen, lLength);
if(nRet==TRUE){
memcpy(acReadedDelimitor, &acGelesenesTrennzeichen, sizeof(long));
}
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.GetReadedDelimitors] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// SetDelimitor
// *****************************************************************
TextScan::SetDelimitor (char *acText)
{
int nRet=FALSE;
long lLaenge;
char *acDelimitor;


if(nStatus==TRUE){
lLaenge = strlen(acText);
nRet = ListeBegrenzer.vlnew(&acDelimitor, lLaenge);
memcpy(acDelimitor, acText, lLaenge);
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.SetDelimitor] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// SetDelimitor
// *****************************************************************
TextScan::SetDefaultDelimitor (void)
{
int nRet=FALSE;


if(nStatus==TRUE){
nRet = SetDelimitor (" ");
if(nRet==TRUE){
nRet = SetDelimitor (".");
}
if(nRet==TRUE){
nRet = SetDelimitor (":");
}
if(nRet==TRUE){
nRet = SetDelimitor ("!");
}
if(nRet==TRUE){
nRet = SetDelimitor ("?");
}
if(nRet==TRUE){
nRet = SetDelimitor (",");
}
if(nRet==TRUE){
nRet = SetDelimitor (";");
}
if(nRet==TRUE){
nRet = SetDelimitor ("+");
}
if(nRet==TRUE){
nRet = SetDelimitor ("-");
}
if(nRet==TRUE){
nRet = SetDelimitor ("/");
}
if(nRet==TRUE){
nRet = SetDelimitor ("*");
}
if(nRet==TRUE){
nRet = SetDelimitor ("<");
}
if(nRet==TRUE){
nRet = SetDelimitor (">");
}
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.SetDefaultDelimitor] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}


// *****************************************************************
// GetDelimitor
// *****************************************************************
TextScan::GetDelimitors (int nFirst, char *acDelimitor, long *lLength)
{
int nRet=FALSE;
char *acTrennzeichen;


if(nStatus==TRUE){
if(nFirst==TRUE){
ListeBegrenzer.vlroot();
}
nRet = ListeBegrenzer.vlnext(&acTrennzeichen, lLength);
if(nRet==TRUE){
memcpy(acDelimitor, &acTrennzeichen, sizeof(long));
}
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.GetDelimitors] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// DeleteDelimitor
// *****************************************************************
TextScan::DeleteDelimitor (char *acText)
{
int nRet=FALSE, nWeiter=FALSE;
char *acTrennzeichen;
long lLaenge;


if(nStatus==TRUE){
ListeBegrenzer.vlroot();
while(nWeiter==FALSE && ListeBegrenzer.vlnext(&acTrennzeichen, &lLaenge)){
if(strncmp(acTrennzeichen, acText, strlen(acText))==FALSE){
nWeiter = TRUE;
ListeBegrenzer.vldelet(acTrennzeichen, &lLaenge);
}
}
nRet = nWeiter;
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.DeleteDelimitor] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// DeleteAllDelimitors
// *****************************************************************
TextScan::DeleteAllDelimitors (void)
{
int nRet=FALSE;


if(nStatus==TRUE){
nRet = ListeBegrenzer.vlDeInit();
if(nRet==TRUE){
nRet = ListeBegrenzer.vlInit();
}
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.DeleteAllDelimitors] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// GetPositionChars
// *****************************************************************
TextScan::GetPositionChars (void)
{
int nRet=FALSE;


if(nStatus==TRUE){
nRet = nAktuelle_Position_Zeichen;
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.GetPositionChars] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// GetTextSize
// *****************************************************************
TextScan::GetTextSize (void)
{
int nRet=FALSE;


if(nStatus==TRUE){
nRet = nTextGesamtLaenge;
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.GetTextSize] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}

// *****************************************************************
// SetPositionChars
// *****************************************************************
TextScan::SetPositionChars (int nNumber)
{
int nRet=FALSE;


if(nStatus==TRUE){
if(nTextGesamtLaenge>=nNumber){
nAktuelle_Position_Zeichen = nNumber;
nRet = TRUE;
}
} else {
sprintf(TEXTSCAN_acString, "%s", "[TextScan.SetPositionChars] nStatus==FALSE");
AusnahmeFehler(TEXTSCAN_acString, __CFILE__, __LINE__);
}
return(nRet);
}