//
// Fineline BN 14-Juli-98
// 02-Sept-98 (WinMain.cpp erstmals vollständig korrekt finelined)
// 14-Sept-98 (Fineline.ini eingeführt)
// 22-Sept-98 (einige Neuerungen)
// 06-Okto-98 (Vorlauf fertig)
// 11-Okto-98 (Fineline.mdb GUI fertig)
// 21-Okto-98 wegen erheblicher unerwarteter Sonderfälle kann nicht alles
// berücksichtigt werden
//
//
//
//
/*
Folgendes wird nicht unterstützt:

^^^^^^^^^^^^^^^^^^^^^^^^
Extremfälle wie diese wo der Text schon nicht richtig formatiert ist könnte nicht korrekt erkannt werden
Es ist mir nicht möglich alle Varianten durchzuspielen. Ich hoffe der größte Teil ist abgedeckt.

if
(nTest==0)
{
i++;
} else
if
(nTest==11)
i--;
^^^^^^^^^^^^^^^^^^^^^^^^

^^^^^^^^^^^^^^^^^^^^^^^^
wird NICHT unterstützt:
/# if ((nKommentar) #/ if(wertx) nKommentar = 0;


wird NICHT unterstützt bei Mode=true:
if(nTest==0)

{
i++;
}


if(nTest==0)
i++;

else if(nTest==1){
i--;
}

Fineline nur für C nicht für C++ !!!
STIMMT DAS ÜBERHAUPT? Bitte beachten Sie, die Dateigröße der Quellcodes sollte nicht 1 MB überschreiten. Wenn doch Meldungsbox mit Hinweis zum Kontaktieren von BN
uneingeschränkte Vollversion mit Access-Oberfläche
Shareware kommandozeilen-orientiert mit Ini-Datei
Hinweis auf Internetseite von Fineline
ZURÜCKGESTELLT --- inkrementelles Fineline nur für geänderte Dateien
Fehler durch zu lange Zeilenlängen können nicht beachtet werden (z.B. Visual C++ 1.5)
Leistungsbeschreibung wieviel Codezeilen pro Minute, technische Details
ZURÜCKGESTELLT --- Leerzeichen zwischen if und ( können entfernt werden: if()
Prozentanzeige anhand Textposition in Chars und Gesamttextgröße
Trim ausschalten, wenn Kommentar
von {}-Position nach if-Block ohne CR oder in nächster Zeile optional
Getestet mit Netscape Quellcodes
was macht man mit mehrzeiligen Ausdrücken wo Klammern auftauchen --> soll irgendwie eingerückt werden?
ZURÜCKGESTELLT --- #bei Compiler-Directiven komplett Einrückung aus
Quellcode der finelined werden soll muß ohne Syntax-Fehler sein
ZURÜCKGESTELLT --- gewisse Funktionen wie Eingangsbereinigungsfunktion per Ini-Eintrag ein/ausschaltbar
bestimmte Kommentare vor Keywords könnten zum Problem werden
*/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "System.h"
#include "File.h"
#include "TextScan.h"
#include "TextRW.h"


#define CLASS_NAME "Fineline 1.0"
List AnzeigeHandle;
typedef struct{
char acText[81];
} Anzeige_;
Anzeige_ *Anzeige;
int nAnzeigeAktuellePosition=1;

#define __CFILE__ "WinMain"

typedef struct{
int Function;
int If;
int While;
int Switch;
int For;
int Case;
int DoWhile;
int Typedef;
int Struct;
int Union;
int Enum;
} Einrueck_;
Einrueck_ Einrueck;

#define FUNCTION_BEGIN 0
#define FUNCTION_END 1
#define IF_BEGIN 2
#define IF_END 3
#define WHILE_BEGIN 4
#define WHILE_END 5
#define SWITCH_BEGIN 6
#define SWITCH_END 7
#define FOR_BEGIN 8
#define FOR_END 9
#define CASE_BEGIN 10
#define BREAK_END 11
#define DOWHILE_BEGIN 12
#define DOWHILE_END 13
#define TYPEDEF_BEGIN 14
#define TYPEDEF_END 15
#define STRUCT_BEGIN 16
#define STRUCT_END 17
#define UNION_BEGIN 18
#define UNION_END 19
#define ENUM_BEGIN 20
#define ENUM_END 21
#define DUMMY_BEGIN 22
#define DUMMY_END 23
#define ELSE_BEGIN 24
#define ELSE_END 25


int nHandsOffComment=TRUE;
int nQuiet=FALSE; // ==TRUE keine genaue Anzeige beim Fineline.ini lesen
int nTabs=FALSE; // ==TRUE Tabs statt Leerzeichen zur Einrückung verwenden
int nDetails=TRUE; // ==TRUE finelined Zeilen werden aufgelistet am Bildschirm
int nMode=TRUE; // ==TRUE geschweifte Klammern oben neben if/else/...-Block

char acQuellDateiname[1024]={"c:\\test.c"};
char acZielDateiname[1024]={"c:\\test2.c"};
int nExit=FALSE;

long lAllokierterSpeicher=0;

TextFileRW Fineline;
TextFileRW SourceFile;
TextFileRW DestinationFile;
TextScan Source;
TextScan IniFile;
Piece Destination;
List EinrueckungHandle;
List EinrueckungHandleHistory;
typedef struct{
int nNr;
} Einrueckung_;
Einrueckung_ *Einrueckung;

typedef struct{
int nNr;
} EinrueckungHistory_;
EinrueckungHistory_ *EinrueckungHistory;

char WINMAIN_acString[1024];
char *acFinelineFile=NULL;
char *acSourceFile=NULL;
char acCR[10];
int nEinzug = 0;
int nGlobal = 0; // globaler Einzug
int nSingleLine=0;
char acDummyDelimitor[100];
char acDummySourceString[100];
char *acDelimitor=NULL;
char *acSourceString=NULL;
char *acDelimitor2=NULL;
char *acSourceString2=NULL;
char *acDelimitor_1=NULL;
char *acSourceString_1=NULL;
char *acDelimitor0=NULL;
char *acSourceString0=NULL;
char *acDestinationString=NULL;
char *acDestinationString2=NULL;
char *acDestinationString3=NULL;
char *acDelimitor3=NULL;
char *acSourceString3=NULL;

int nCounterNormal=0; // wird für normale Zeile benutzt (Handling der Klammern bzw. mehrzeile Befehle)
int nCounterNormalAktiv=FALSE; // wird für normale Zeile benutzt (Handling der Klammern bzw. mehrzeile Befehle)
int nCounterNormalErsteMal=FALSE; // wird für normale Zeile benutzt (Handling der Klammern bzw. mehrzeile Befehle)
int nCounterNormalAktivKennerFuerMode1=FALSE;

int nCounter=0;
int nCounterAktiv=FALSE;
int nCounterWarAktiv=FALSE;
int nCounterWarAktiv2=FALSE;
int nCounterAktivKennerFuerMode1=FALSE;

int nKommentar=FALSE;
int nEinrueckenVergroessern=TRUE;
int nDelimitor=FALSE;
int nPruefsummeGeschweifteKlammern=0;

// Prototypes
HINSTANCE g_hInst = NULL;
HWND g_hWnd = NULL;
BOOL InitClass(HINSTANCE hInst);
BOOL InitWindow(HINSTANCE hInst, int nCmdShow);
long FAR PASCAL WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
int WndParamCheck(void);
int FAR PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow);

int Print(char *acText);
int GetIniValue(char *acIni);
int GetIni(void);
int InitMaster(void);
int DeInitMaster(void);
int Init(void);
int DeInit(void);
int PrepareCode(void);
int MakeEinrueckungHistory(int nNr);
int TrimCR(char *acText);
int LeftTrim(char *acText);
int RightTrim(char *acText);
int Trim(char *acText);
int IsEqual(char *acText1, char *acText2, int nLaenge);
int SetDelimitors(void);
int BestimmeEinruecken(int nNr);
int DoEinruecken(char *acSuchDelimitor, int *nAnzahlEinzug);
int Suche(char *acSuchDelimitor);
int Normal(void);
void main(void);

//------------------------------------------------------------------
// Function : InitClass()
//------------------------------------------------------------------
BOOL InitClass(HINSTANCE hInst)
{
WNDCLASS wndClass;


wndClass.style = CS_HREDRAW | CS_VREDRAW;
wndClass.lpfnWndProc = WndProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
wndClass.hInstance = hInst;
wndClass.hIcon = LoadIcon(hInst, IDI_APPLICATION);
wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClass.hbrBackground = GetStockObject(WHITE_BRUSH);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = CLASS_NAME;

if (!RegisterClass(&wndClass)) return FALSE;

return TRUE;
}

//------------------------------------------------------------------
// Function : InitWindow()
//------------------------------------------------------------------
BOOL InitWindow(HINSTANCE hInst, int nCmdShow)
{
char acText[1024];


sprintf(acText, "%s - %s", CLASS_NAME, "Starting ...");
g_hWnd = CreateWindowEx(WS_EX_APPWINDOW,
CLASS_NAME,
acText,
WS_CAPTION | WS_SYSMENU,
0, 0,
600,
400,
NULL,
NULL,
hInst,
NULL);

if (!g_hWnd) return FALSE;

ShowWindow(g_hWnd, SW_SHOWNORMAL);

return TRUE;
}

//------------------------------------------------------------------
// Function : WndProc()
//------------------------------------------------------------------
long FAR PASCAL WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
HDC PaintDC;
char acText[256];
int i;
int nSize=14;
HFONT OldFont;
HFONT Font;


switch (message){
case WM_PAINT :
PaintDC = GetDC(hWnd);
Font = CreateFont((8 + 6), 0, 0, 0, 0, FALSE, FALSE, 0, 0, 0, 0, 0, 0, "Courier New");
OldFont = SelectObject(PaintDC, Font);
i = 0;
AnzeigeHandle.vlroot();
while(AnzeigeHandle.vlnext(&Anzeige)==TRUE){
sprintf(acText, "%-80.80s", Anzeige);
TextOut(PaintDC, 2, (nSize * i++), acText, strlen(acText));
}
SelectObject(PaintDC, OldFont);
DeleteObject(Font);
DeleteObject(OldFont);
ReleaseDC(hWnd, PaintDC);
break;
case WM_KEYDOWN:
switch (wParam){
case VK_ESCAPE:
PostMessage(g_hWnd, WM_CLOSE ,0 ,0);
break;
}
break;
case WM_CLOSE:
DestroyWindow(g_hWnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
}
return DefWindowProc(hWnd, message, wParam, lParam);
}

//------------------------------------------------------------------
// WndParamCheck
//------------------------------------------------------------------
int WndParamCheck(void)
{
MSG msg;


if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)){
if (msg.message == WM_QUIT){
PostQuitMessage(msg.wParam);
return (TRUE);
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return(FALSE);
}

//------------------------------------------------------------------
// WinMain
//------------------------------------------------------------------
int FAR PASCAL WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
int i;


sprintf(acCR, "%c%c", 0xD, 0xA);
AnzeigeHandle.vlInit();
i = 0;
while(i<25){
i++;
if(AnzeigeHandle.vlnew(&Anzeige, sizeof(Anzeige_))==TRUE){
sprintf(Anzeige->acText, "%-80.80s", "");
} else {
AnzeigeHandle.vlDeInit();
return 1;
}
}

g_hInst = hInst;
if(!InitClass(hInst)){
AnzeigeHandle.vlDeInit();
return 1;
}
if(!InitWindow(hInst, nCmdShow)){
AnzeigeHandle.vlDeInit();
return 1;
}
sprintf(WINMAIN_acString, "%s", "Fineline 1.0 for C - Copyright (c) 1998 Bernd Noetscher Sep 1998"); Print(WINMAIN_acString);
sprintf(WINMAIN_acString, "%s", "NOT REGISTERED for business, commercial, or government use."); Print(WINMAIN_acString);
sprintf(WINMAIN_acString, "%s", "All Rights Reserved. Fineline Beatymaker Utility: Makes your lines fine!"); Print(WINMAIN_acString);
sprintf(WINMAIN_acString, "%s", "For further details view Fineline.htm"); Print(WINMAIN_acString);
sprintf(WINMAIN_acString, "%s", "Visit my homepage http://home.t-online.de/home/bernd.noetscher/fineline.htm"); Print(WINMAIN_acString);
sprintf(WINMAIN_acString, "%s", ""); Print(WINMAIN_acString);

main();
while (TRUE){
if(WndParamCheck()==TRUE){
nExit = TRUE;
AnzeigeHandle.vlDeInit();
return(TRUE);
}
}
AnzeigeHandle.vlDeInit();
return(TRUE);
}

//------------------------------------------------------------------
// Print
//------------------------------------------------------------------
int Print(char *acText)
{
int nRet=FALSE;
long lAnzahl;
int i;
int nLaenge;
int nX=1;
Anzeige_ *TmpAnzeige;


AnzeigeHandle.vlanz(&lAnzahl);
if(AnzeigeHandle.vlnum(nAnzeigeAktuellePosition, &Anzeige)==TRUE){
sprintf(Anzeige->acText, "%-80.80s", acText);

// acCR entfernen
nLaenge = (signed)strlen(Anzeige->acText);
for(nX=0;nX<nLaenge;nX++){
if(Anzeige->acText[nX]==0xD || Anzeige->acText[nX]==0xA){
Anzeige->acText[nX] = 0;
} else if(Anzeige->acText[nX]==0x09){
Anzeige->acText[nX] = ' ';
}
}
nAnzeigeAktuellePosition++;
if(nAnzeigeAktuellePosition>lAnzahl){
i = 0;
while(i<25){
i++;

if(AnzeigeHandle.vlnum(i + 1, &TmpAnzeige)==TRUE){
if(AnzeigeHandle.vlnum(i, &Anzeige)==TRUE){
memcpy(Anzeige, TmpAnzeige, sizeof(Anzeige_));
}
}
}
nAnzeigeAktuellePosition = lAnzahl;
if(AnzeigeHandle.vlnum(nAnzeigeAktuellePosition, &Anzeige)==TRUE){
sprintf(Anzeige->acText, "%s", "");
}
}
}
InvalidateRect((HDC)g_hWnd, NULL, FALSE);
UpdateWindow(g_hWnd);
return(nRet);
}


//------------------------------------------------------------------
// GetIniValue
//------------------------------------------------------------------
int GetIniValue(char *acIni)
{
int nRet=-1;
char *acIniSourceString;
char *acIniDelimitor;
int nPosition;
int nKommentar=FALSE;
int nNochmal=FALSE;


if(WndParamCheck()==TRUE){
nExit = TRUE;
}

Nochmal:
IniFile.DeleteAllDelimitors();
IniFile.SetDelimitor(acCR);
IniFile.SetDelimitor(";");
IniFile.SetDelimitor(acIni);
if(nNochmal==FALSE){
nPosition = IniFile.GetPositionChars();
}
while(IniFile.ReadNextWord()==TRUE){
IniFile.GetReadedDelimitor((char *)&acIniDelimitor);
if(IsEqual(acIniDelimitor, ";", 1)){
nKommentar = TRUE;
} else if(IsEqual(acIniDelimitor, acCR, 2)){
nKommentar = FALSE;
} else if(nKommentar==FALSE && IsEqual(acIniDelimitor, acIni, strlen(acIni))){
IniFile.DeleteAllDelimitors();
IniFile.SetDelimitor("=");
IniFile.SetDelimitor(acCR);
IniFile.SetDelimitor(";");
if(IniFile.ReadNextWord()==TRUE){
IniFile.GetReadedDelimitor((char *)&acIniDelimitor);
if(IsEqual(acIniDelimitor, "=", 1)){
IniFile.DeleteAllDelimitors();
IniFile.SetDelimitor(acCR);
IniFile.SetDelimitor(";");
if(IniFile.ReadNextWord()==TRUE){
IniFile.GetReadedWord((char *)&acIniSourceString);
nRet = atoi(acIniSourceString);
}
} else { // nachdem der Ini-Eintrag gefunden (z. b. Mode) konnte nach dem = kein korrekter Wert ermittelt werden -> Suche fortsetzten
nNochmal = TRUE;
goto Nochmal;
}
}
}
}
IniFile.SetPositionChars(nPosition);
return(nRet);
}

//------------------------------------------------------------------
// GetIni
//------------------------------------------------------------------
int GetIni(void)
{
int nRet=FALSE;
int nWert;
int nMin = 500;
int nMax = 800;


nMax -= nMin;
IniFile.Init(acFinelineFile);

sprintf(WINMAIN_acString, "%s", "Reading Fineline.ini ..."); Print(WINMAIN_acString);
// Default-Werte
Einrueck.Function = 2;
Einrueck.If = 3;
Einrueck.While = 6;
Einrueck.Switch = 7;
Einrueck.For = 4;
Einrueck.Case = 2;
Einrueck.DoWhile = 6;
Einrueck.Typedef = 3;
Einrueck.Struct = 3;
Einrueck.Union = 3;
Einrueck.Enum = 3;

nQuiet = FALSE;
nTabs = FALSE;
nDetails = TRUE;
nGlobal = 0;
nMode = FALSE;

sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Quiet"))>=0){
nQuiet = nWert;
if(nQuiet>1 || nQuiet<0){
nQuiet = FALSE;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Quiet=", nQuiet); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Quiet=", nQuiet); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Tabs"))>=0){
nTabs = nWert;
if(nTabs>1 || nTabs<0){
nTabs = FALSE;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Tabs=", nTabs); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Tabs=", nTabs); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Details"))>=0){
nDetails = nWert;
if(nDetails>1 || nDetails<0){
nDetails = TRUE;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Details=", nDetails); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Details=", nDetails); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Global"))>=0){
nGlobal = nWert;
if(nGlobal>20 || nGlobal<0){
nGlobal = 0;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Global=", nGlobal); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Global=", nGlobal); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Mode"))>=0){
nMode = nWert;
if(nMode>1 || nMode<0){
nMode = FALSE;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Mode=", nMode); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Mode=", nMode); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Function"))>=0){
Einrueck.Function = nWert;
if(Einrueck.Function>20 || Einrueck.Function<0){
Einrueck.Function = 2;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Function=", Einrueck.Function); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Function=", Einrueck.Function); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("If"))>=0){
Einrueck.If = nWert;
if(Einrueck.If>20 || Einrueck.If<0){
Einrueck.If = 3;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. If=", Einrueck.If); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "If=", Einrueck.If); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("While"))>=0){
Einrueck.While = nWert;
if(Einrueck.While>20 || Einrueck.While<0){
Einrueck.While = 6;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. While=", Einrueck.While); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "While=", Einrueck.While); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Switch"))>=0){
Einrueck.Switch = nWert;
if(Einrueck.Switch>20 || Einrueck.Switch<0){
Einrueck.Switch = 7;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Switch=", Einrueck.Switch); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Switch=", Einrueck.Switch); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("For"))>=0){
Einrueck.For = nWert;
if(Einrueck.For>20 || Einrueck.For<0){
Einrueck.For = 4;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. For=", Einrueck.For); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "For=", Einrueck.For); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Case"))>=0){
Einrueck.Case = nWert;
if(Einrueck.Case>20 || Einrueck.Case<0){
Einrueck.Case = 2;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Case=", Einrueck.Case); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Case=", Einrueck.Case); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("DoWhile"))>=0){
Einrueck.DoWhile = nWert;
if(Einrueck.DoWhile>20 || Einrueck.DoWhile<0){
Einrueck.DoWhile = 6;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. DoWhile=", Einrueck.DoWhile); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "DoWhile=", Einrueck.DoWhile); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Typedef"))>=0){
Einrueck.Typedef = nWert;
if(Einrueck.Typedef>20 || Einrueck.Typedef<0){
Einrueck.Typedef = 3;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Typedef=", Einrueck.Typedef); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Typedef=", Einrueck.Typedef); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Struct"))>=0){
Einrueck.Struct = nWert;
if(Einrueck.Struct>20 || Einrueck.Struct<0){
Einrueck.Struct = 3;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Struct=", Einrueck.Struct); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Struct=", Einrueck.Struct); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Union"))>=0){
Einrueck.Union = nWert;
if(Einrueck.Union>20 || Einrueck.Union<0){
Einrueck.Union = 3;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Union=", Einrueck.Union); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Union=", Einrueck.Union); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, ((__LINE__ - nMin) * 100 / nMax)); SetWindowText(g_hWnd, WINMAIN_acString);
//
if((nWert = GetIniValue("Enum"))>=0){
Einrueck.Enum = nWert;
if(Einrueck.Enum>20 || Einrueck.Enum<0){
Einrueck.Enum = 3;
sprintf(WINMAIN_acString, "%s%d", "Bad Value. Set to default. Enum=", Einrueck.Enum); Print(WINMAIN_acString);
} else {
if(nQuiet==FALSE){
sprintf(WINMAIN_acString, "%s%d", "Enum=", Einrueck.Enum); Print(WINMAIN_acString);
}
}
}
if(nExit==TRUE){
IniFile.DeInit();
return(FALSE);
}
sprintf(WINMAIN_acString, "%s - Reading Fineline.ini ... %3d%%", CLASS_NAME, 100); SetWindowText(g_hWnd, WINMAIN_acString);

IniFile.DeInit();

return(nRet);
}

//------------------------------------------------------------------
// InitMaster
//------------------------------------------------------------------
int InitMaster(void)
{
int nRet=FALSE;
char acDateiname[1024];


sprintf(acDateiname, "%s", acQuellDateiname);
if(Fineline.Open("C:\\Fineline.ini")==TRUE){
if((acFinelineFile = (char *)Mem_Alloc(Fineline.GetFileSize() + 1))!=NULL){
memset(acFinelineFile, 0, Fineline.GetFileSize() + 1);
Fineline.ReadAll(acFinelineFile);
GetIni();
if(nExit==FALSE){
nRet = TRUE;
}
} else {
Fineline.Close();
sprintf(WINMAIN_acString, "%s", "Not enough memory to read Fineline.ini.");
AusnahmeFehler(WINMAIN_acString, __CFILE__, __LINE__);
}
} else {
sprintf(WINMAIN_acString, "%s", "Can not open Fineline.ini.");
AusnahmeFehler(WINMAIN_acString, __CFILE__, __LINE__);
}
if(nRet==TRUE){
Fineline.Close();
}
return(nRet);
}

//------------------------------------------------------------------
// DeInitMaster
//------------------------------------------------------------------
int DeInitMaster(void)
{
int nRet=FALSE;


Mem_Free(acFinelineFile, Fineline.GetFileSize());
acFinelineFile = NULL;
return(nRet);
}

//------------------------------------------------------------------
// Init
//------------------------------------------------------------------
int Init(void)
{
int nRet=FALSE;
char acDateiname[1024];


sprintf(acDateiname, "%s", acQuellDateiname);
if(nExit==FALSE){
if(SourceFile.Open(acDateiname)==TRUE){
if((acSourceFile = (char *)Mem_Alloc(SourceFile.GetFileSize() + 1))!=NULL){
memset(acSourceFile, 0, SourceFile.GetFileSize() + 1);
SourceFile.ReadAll(acSourceFile);
if((nRet = PrepareCode())==FALSE){
SourceFile.Close();
}
} else {
sprintf(WINMAIN_acString, "Not enough memory to read %s.", acDateiname);
AusnahmeFehler(WINMAIN_acString, __CFILE__, __LINE__);
}
}
}
if(nRet==TRUE){
SourceFile.Close();
}
return(nRet);
}

//------------------------------------------------------------------
// DeInit
//------------------------------------------------------------------
int DeInit(void)
{
int nRet=FALSE;


Mem_Free(acSourceFile, SourceFile.GetFileSize());
acSourceFile = NULL;
return(nRet);
}

//------------------------------------------------------------------
// PrepareCode
//------------------------------------------------------------------
int PrepareCode(void)
{
int nRet=TRUE;
int nLokalKommentar;
char cChecked;
char cChecked2;
char cChecked3;
char cChecked4;
char cCheckedb0;
char cCheckedb1;
char cCheckedb2;
int i;
long lSize;
char *acPointer;
char acDateiname[1024];
int nLen;
int nGefunden;
int nGefunden2;
int nGefunden3;
int nZaehler;
int nKommentar2;
int nLokalKommentar2;
int nKlammern;
int nAltePosition=0;
char cZeichen;
int nWarLeer;
int nErsteMal;
int nFrageZeichen;


sprintf(WINMAIN_acString, "%s - Preparing code ...", CLASS_NAME); SetWindowText(g_hWnd, WINMAIN_acString);
sprintf(acDateiname, "%s", acQuellDateiname);
lSize = (SourceFile.GetFileSize() + 1);
nKommentar = FALSE;
nLokalKommentar = nKommentar;
nLen = (signed)strlen(acSourceFile);
nKlammern = 0;
for(i=0;i<nLen;i++){
cChecked = acSourceFile[i];
if((i + 1)<nLen){
cChecked2 = acSourceFile[i + 1];
} else {
cChecked2 = 0;
}
if((i + 2)<nLen){
cChecked3 = acSourceFile[i + 2];
} else {
cChecked3 = 0;
}
if((i + 3)<nLen){
cChecked4 = acSourceFile[i + 3];
} else {
cChecked4 = 0;
}
if((nLokalKommentar==FALSE || nLokalKommentar==1) && cChecked==34){ // " 34
if(nLokalKommentar==FALSE){
nLokalKommentar = 1;
} else {
nLokalKommentar = FALSE;
}
} else if((nLokalKommentar==FALSE || nLokalKommentar==2) && cChecked==39){ // ' 39
if(nLokalKommentar==FALSE){
nLokalKommentar = 2;
} else {
nLokalKommentar = FALSE;
}
} else if((nKommentar==FALSE && cChecked=='/' && cChecked2=='/') || (nKommentar==3 && cChecked==0xD && cChecked2==0xA)){ // //
if(nLokalKommentar==FALSE){
nLokalKommentar = 3;
} else {
nLokalKommentar = FALSE;
}
} else if(nLokalKommentar==FALSE && cChecked=='/' && cChecked2=='*'){ // /*
nLokalKommentar = 4;
} else if(nLokalKommentar==4 && cChecked=='*' && cChecked2=='/'){ // */
nLokalKommentar = FALSE;
}
nKommentar = nLokalKommentar;
if(nLokalKommentar==FALSE){
nZaehler = 1;
nGefunden = 0;
nGefunden2 = 0;
nGefunden3 = 0;
nKommentar2 = nKommentar;
nLokalKommentar2 = nKommentar2;
cZeichen = 0;
nWarLeer = FALSE;
nErsteMal = TRUE;
nFrageZeichen = FALSE;
while((i + nZaehler)<nLen){
cCheckedb1 = acSourceFile[i + nZaehler];
if((i + nZaehler + 1)<nLen){
cCheckedb2 = acSourceFile[i + nZaehler + 1];
} else {
cCheckedb2 = 0;
}
if(nZaehler>1){
cCheckedb0 = cCheckedb1;
} else {
cCheckedb2 = 0;
}

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

if((cCheckedb1==0xD && cCheckedb2==0xA)){
break;
} else {
if(cChecked==')'){
nGefunden = nGefunden;
}
if(nWarLeer==TRUE){
cZeichen = cCheckedb1;
nWarLeer = FALSE;
}
if((nWarLeer==TRUE || (nErsteMal==TRUE)) && (cCheckedb1==0x09 || cCheckedb1==' ')){
nGefunden2++;
nWarLeer = TRUE;
nErsteMal = FALSE;
} else if(nGefunden2==0 || nFrageZeichen==TRUE){
nGefunden3++;
}
if((cChecked!=0x09 && cChecked!=' ')){
nGefunden++;
}
if(((cCheckedb0==' ' || cCheckedb0==0x09) && cCheckedb1=='?' && (cCheckedb2==' ' || cCheckedb2==0x09)) || (cCheckedb0==')' && cCheckedb1=='?')){
nFrageZeichen = TRUE; // für Operator (xyz==0 ? 1 : 1)
nGefunden3++;
}
}
}
nZaehler++;
}
if(cChecked=='('){
nKlammern++;
} else if(cChecked==')'){
nKlammern--;
}

if(((cChecked2!=0xD || cChecked3!=0xA) && nGefunden>0 && nKlammern==0) && (
cChecked==';'
|| cChecked==':'
|| cChecked=='{'
|| (cChecked==')' && cZeichen!=';' && cChecked2!=';' && nGefunden2>0))
)
{
if(((cChecked==';' || cChecked==':' || cChecked==')') && cChecked2!='{' && cChecked2!='}') && (nZaehler - 1)>0 && (nZaehler - 1)==(nGefunden3 + nGefunden2)){
cChecked = cChecked;
} else {
lSize += 2;
if((acPointer = (char *)Mem_Alloc(lSize))==NULL){
Mem_Free(acSourceFile, lSize);
sprintf(WINMAIN_acString, "Not enough memory to read %s.(2)", acDateiname);
AusnahmeFehler(WINMAIN_acString, __CFILE__, __LINE__);
acSourceFile = NULL;
return(FALSE);
} else {
memcpy(acPointer, acSourceFile, i + 1);
memcpy(acPointer + i + 1, acCR, 2);
memcpy(acPointer + i + 3, acSourceFile + i + 1, lSize - i - 3);
Mem_Free(acSourceFile, lSize);
acSourceFile = acPointer;
nAltePosition = i;
i += 2;
nLen = (signed)strlen(acSourceFile);
}
}

}
}
}

return(nRet);
}

//------------------------------------------------------------------
// MakeEinrueckungHistory
//------------------------------------------------------------------
int MakeEinrueckungHistory(int nNr)
{
int nRet=TRUE;
long lAnzahl;


if(nMode==FALSE){
return(nRet);
}
EinrueckungHandleHistory.vlnew(&EinrueckungHistory, sizeof(Einrueckung_));
EinrueckungHandle.vlanz(&lAnzahl);
if(lAnzahl>0){
if(nNr==-1){

}
EinrueckungHistory->nNr = nNr;
} else {
EinrueckungHistory->nNr = -1;
}
return(nRet);
}

//------------------------------------------------------------------
// TrimCR
//------------------------------------------------------------------
int TrimCR(char *acText)
{
int nRet=TRUE;
int nX=1;
int nLaenge;


// CR weg
nLaenge = (signed)strlen(acText);
while(nLaenge>2 && (nX<nLaenge - 1) && (char)(acText[nLaenge - nX - 1])==0xD || (char)(acText[nLaenge - nX])==0xA){
nX = 3;
break;
}
nX--;
if(nX>0){
memset(acText + (nLaenge - nX), 0, 1);
}
return(nRet);
}

//------------------------------------------------------------------
// LeftTrim
//------------------------------------------------------------------
int LeftTrim(char *acText)
{
int nRet=TRUE;
int nX=0;
int nLaenge;
int nNochmal=FALSE;


// Leerzeichen weg
nLaenge = (signed)strlen(acText);
while(nX<nLaenge && strncmp(acText + nX, " ", 1)==FALSE){
nX++;
}
memmove(acText, acText + nX, (nLaenge - nX));
memset(acText + (nLaenge - nX), 0, 1);

// Tabs weg
nX = 0;
nLaenge = (signed)strlen(acText);
while(nX<(nLaenge)){
if(acText[nX + 0]==0x09){
memset(acText + nX, ' ', 1);
nNochmal = TRUE;
}
nX++;
}
if(nNochmal==TRUE){
LeftTrim(acText);
}
return(nRet);
}

//------------------------------------------------------------------
// RightTrim
//------------------------------------------------------------------
int RightTrim(char *acText)
{
int nRet=TRUE;
int nX=1;
int nLaenge;


// Leerzeichen weg
nLaenge = (signed)strlen(acText);
while(nX<nLaenge && strncmp(acText + nLaenge - nX, " ", 1)==FALSE){
nX++;
}
nX--;
if(nX>0){
memset(acText + (nLaenge - nX), 0, 1);
}

// Tabs weg
nX = 1;
nLaenge = (signed)strlen(acText);
while(nX<nLaenge && acText[nLaenge - nX]==0x09){
nX++;
}
nX--;
if(nX>0){
memset(acText + (nLaenge - nX), 0, 1);
}
return(nRet);
}

//------------------------------------------------------------------
// Trim
//------------------------------------------------------------------
int Trim(char *acText)
{
int nRet=TRUE;


LeftTrim(acText);
RightTrim(acText);
return(nRet);
}

//------------------------------------------------------------------
// IsEqual
//------------------------------------------------------------------
int IsEqual(char *acText1, char *acText2, int nLaenge)
{
int nRet=FALSE;
int nCaseSensitiv=TRUE;
char cChecked;


if(strncmp(acText1, acCR, 2)==FALSE || strncmp(acText2, acCR, 2)==FALSE){
nCaseSensitiv = FALSE;
} else if(strncmp(acText1, "{", 1)==FALSE || strncmp(acText2, "{", 1)==FALSE){
nCaseSensitiv = FALSE;
} else if(strncmp(acText1, "}", 1)==FALSE || strncmp(acText2, "}", 1)==FALSE){
nCaseSensitiv = FALSE;
}

if(nCaseSensitiv==TRUE){
if(strncmp(acText1, acText2, nLaenge)==FALSE){
memcpy(&cChecked, (acText1 + nLaenge), 1);
if(CBezeichner(cChecked)==TRUE){
nRet = TRUE;
}
}
} else {
if(strncmp(acText1, acText2, nLaenge)==FALSE){
nRet = TRUE;
}
}
return(nRet);
}

//------------------------------------------------------------------
// SetDelimitors
//------------------------------------------------------------------
int SetDelimitors(void)
{
int nRet=TRUE;


Source.SetDelimitor(acCR);
Source.SetDelimitor("{");
Source.SetDelimitor("}");
Source.SetDelimitor("case");
Source.SetDelimitor("break");
Source.SetDelimitor("default");
return(nRet);
}

//------------------------------------------------------------------
// BestimmeEinruecken
//------------------------------------------------------------------
int BestimmeEinruecken(int nNr)
{
int nRet=FALSE;


switch(nNr){
case FUNCTION_BEGIN: // Functionbody-Anfang
nRet = Einrueck.Function;
break;
case FUNCTION_END: // Functionbody-Ende
nRet = Einrueck.Function * -1;
break;
case IF_BEGIN: // if-Anfang
nRet = Einrueck.If;
break;
case IF_END: // if-Ende
nRet = Einrueck.If * -1;
break;
case WHILE_BEGIN: // while-Anfang
nRet = Einrueck.While;
break;
case WHILE_END: // while-Ende
nRet = Einrueck.While * -1;
break;
case SWITCH_BEGIN: // switch-Anfang
nRet = Einrueck.Switch;
break;
case SWITCH_END: // switch-Ende
nRet = Einrueck.Switch * -1;
break;
case FOR_BEGIN: // for-Anfang
nRet = Einrueck.For;
break;
case FOR_END: // for-Ende
nRet = Einrueck.For * -1;
break;
case CASE_BEGIN: // case-Anfang
nRet = Einrueck.Case;
break;
case BREAK_END: // break-Ende
nRet = Einrueck.Case * -1;
break;
case DOWHILE_BEGIN: // do-while-Anfang
nRet = Einrueck.DoWhile;
break;
case DOWHILE_END: // do-while-Ende
nRet = Einrueck.DoWhile * -1;
break;
case TYPEDEF_BEGIN: // typedef struct-Anfang
nRet = Einrueck.Typedef;
break;
case TYPEDEF_END: // typedef struct-Ende
nRet = Einrueck.Typedef * -1;
break;
case STRUCT_BEGIN: // struct-Anfang
nRet = Einrueck.Struct;
break;
case STRUCT_END: // struct-Ende
nRet = Einrueck.Struct * -1;
break;
case UNION_BEGIN: // union-Anfang
nRet = Einrueck.Union;
break;
case UNION_END: // union-Ende
nRet = Einrueck.Union * -1;
break;
case ENUM_BEGIN: // enum-Anfang
nRet = Einrueck.Enum;
break;
case ENUM_END: // enum-Ende
nRet = Einrueck.Enum * -1;
break;
case DUMMY_BEGIN: // Dummy-Anfang
nRet = 0;
break;
case DUMMY_END: // Dummy-Ende
nRet = 0;
break;
case ELSE_BEGIN: // else-Anfang
nRet = Einrueck.If;
break;
case ELSE_END: // else-Ende
nRet = Einrueck.If * -1;
break;
}
return(nRet);
}

//------------------------------------------------------------------
// Einruecken
//------------------------------------------------------------------
int DoEinruecken(char *acSuchDelimitor, int *nAnzahlEinzug)
{
int nNr=-1;
long lAnzahl=0;
int nFehler=FALSE;
int nWert;


EinrueckungHandle.vlanz(&lAnzahl);

if(nCounterAktiv==FALSE && IsEqual(acSourceString, "if", 2)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = IF_BEGIN;
nNr = Einrueckung->nNr;
} else if(nCounterAktiv==FALSE && IsEqual(acSourceString, "else", 4)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = ELSE_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString, "while", 5)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = WHILE_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString, "switch", 6)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = SWITCH_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString, "for", 3)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = FOR_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acDelimitor, "case", 4) || IsEqual(acDelimitor, "default", 7)){
if(lAnzahl>0){
if(Einrueckung->nNr!=CASE_BEGIN){ // Vorher schon case z. B. case 0: case 1: {} break;
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = CASE_BEGIN;
} else {
nEinzug = nEinzug + BestimmeEinruecken((Einrueckung->nNr + 1));
}
nNr = Einrueckung->nNr;
}
} else if(IsEqual(acDelimitor, "break", 5)){
if(lAnzahl>0){
if(Einrueckung->nNr==CASE_BEGIN){ // wenn nicht CASE_BEGIN ist der Quellcode fehlerhaft (vielleicht break doppelt in 2 Zeilen)
EinrueckungHandle.vldelet(&Einrueckung);
EinrueckungHandle.vlanz(&lAnzahl);
if(lAnzahl>0){
EinrueckungHandle.vllast(&Einrueckung);
}
} else {
nFehler = TRUE;
}
nNr = BREAK_END;
}
} else if(IsEqual(acSourceString, "do", 2)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = DOWHILE_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString, "typedef struct", 14)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = TYPEDEF_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString, "struct", 6) || IsEqual(acSourceString, "extern struct", 13)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = STRUCT_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString, "union", 5) || IsEqual(acSourceString, "extern union", 12)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = UNION_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString, "enum", 4) || IsEqual(acSourceString, "extern enum", 11)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = ENUM_BEGIN;
nNr = Einrueckung->nNr;
} else if(lAnzahl==1 && IsEqual(acSourceString, "}", 1)){ // acSourceString ???
EinrueckungHandle.vldelet(&Einrueckung);
EinrueckungHandle.vlanz(&lAnzahl);
if(lAnzahl>0){
EinrueckungHandle.vllast(&Einrueckung);
}
nNr = 1;
//
} else if((nCounterWarAktiv==TRUE || (IsEqual(acSourceString0, "if", 2) && !IsEqual(acDelimitor, "}", 1) || IsEqual(acSourceString0, "else", 4)))){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
if(IsEqual(acSourceString0, "if", 2)){
Einrueckung->nNr = IF_BEGIN;
} else if(IsEqual(acSourceString0, "else", 4)){
Einrueckung->nNr = ELSE_BEGIN;
}
nNr = Einrueckung->nNr;
if(nCounterWarAktiv==TRUE){
nCounterWarAktiv = FALSE;
}
} else if((IsEqual(acSourceString0, "while", 5))){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = WHILE_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString0, "switch", 6) && IsEqual(acDelimitor, "{", 1)){ // IsEqual(acDelimitor, "{" deshalb weil wenn zwischen case 0: und break nicht steht ist acSourceString0==switch
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = SWITCH_BEGIN;
nNr = Einrueckung->nNr;
} else if((IsEqual(acSourceString0, "for", 3))){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = FOR_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acDelimitor0, "case", 4) || IsEqual(acDelimitor0, "default", 7)){
if(lAnzahl>0){
if(Einrueckung->nNr!=CASE_BEGIN){ // Vorher schon case z. B. case 0: case 1: {} break;
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = CASE_BEGIN;
} else {
nEinzug = nEinzug + BestimmeEinruecken((Einrueckung->nNr + 1));
}
nNr = Einrueckung->nNr;
}
} else if(IsEqual(acDelimitor0, "break", 5)){
if(lAnzahl>0){
if(Einrueckung->nNr==CASE_BEGIN){ // wenn nicht CASE_BEGIN ist der Quellcode fehlerhaft (vielleicht break doppelt in 2 Zeilen)
EinrueckungHandle.vldelet(&Einrueckung);
EinrueckungHandle.vlanz(&lAnzahl);
if(lAnzahl>0){
EinrueckungHandle.vllast(&Einrueckung);
}
} else {
nFehler = TRUE;
}
nNr = BREAK_END;
}
} else if(IsEqual(acSourceString0, "do", 2)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = DOWHILE_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString0, "typedef struct", 14)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = TYPEDEF_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString0, "struct", 6) || IsEqual(acSourceString0, "extern struct", 13)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = STRUCT_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString0, "union", 5) || IsEqual(acSourceString0, "extern union", 12)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = UNION_BEGIN;
nNr = Einrueckung->nNr;
} else if(IsEqual(acSourceString0, "enum", 4) || IsEqual(acSourceString0, "extern enum", 11)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = ENUM_BEGIN;
nNr = Einrueckung->nNr;
} else if(lAnzahl==0){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = 0;
nNr = Einrueckung->nNr;
} else {
if(lAnzahl>0){
if(IsEqual(acDelimitor, "{", 1)){
EinrueckungHandle.vlnew(&Einrueckung, sizeof(Einrueckung_));
Einrueckung->nNr = DUMMY_BEGIN;
nNr = Einrueckung->nNr;
} else if (IsEqual(acDelimitor, "}", 1)){
nNr = Einrueckung->nNr + 1;
EinrueckungHandle.vldelet(&Einrueckung);
EinrueckungHandle.vlanz(&lAnzahl);
if(lAnzahl>0){
EinrueckungHandle.vllast(&Einrueckung);
if((Einrueckung->nNr + 1)==SWITCH_END){ // wenn nach dem letztes case kein break folgte
nWert = BestimmeEinruecken(nNr);
nNr = DoEinruecken("}", nAnzahlEinzug);
*nAnzahlEinzug = *nAnzahlEinzug + nWert;
return(nNr);

}

}
}
}
}
if(nFehler==TRUE){
*nAnzahlEinzug = 0;
} else {
*nAnzahlEinzug = BestimmeEinruecken(nNr);
}

return(nNr);
}

//------------------------------------------------------------------
// Suche
//------------------------------------------------------------------
int Suche(char *acSuchDelimitor)
{
int nRet=FALSE;
int nNr=-1;
int nLaenge=0;
int nAnzahlEinzug=0;
char cKenner;


if(strlen(acDelimitor)==strlen(acSuchDelimitor) && IsEqual(acSuchDelimitor, acDelimitor, strlen(acSuchDelimitor))){
nDelimitor = TRUE;
if(strlen(acSourceString)!=0){
Normal();
}
if(nEinrueckenVergroessern==TRUE){
nNr = DoEinruecken(acSuchDelimitor, &nAnzahlEinzug);
} else {
if(IsEqual(acSourceString0, "do", 5) && !IsEqual(acSourceString, "while", 5)){
nNr = DOWHILE_END; // siehe beim Bestücken von "nEinrueckenVergroessern" unten in 'main'
nDelimitor = FALSE; // speziell für do while notwendig
}
}
if(nAnzahlEinzug<0 && nNr!=BREAK_END){
if(nEinrueckenVergroessern==TRUE){
nEinzug = nEinzug + nAnzahlEinzug;
}
}
if(nKommentar==FALSE && strlen(acDelimitor)>0){
if(strlen(acSourceString)!=0 || nNr==CASE_BEGIN || nNr==BREAK_END || nNr==DOWHILE_END || nNr==TYPEDEF_END || nNr==STRUCT_END || nNr==UNION_END || nNr==ENUM_END){
if(nNr==CASE_BEGIN || nNr==DOWHILE_END || nNr==TYPEDEF_END || nNr==STRUCT_END || nNr==UNION_END || nNr==ENUM_END){
nLaenge = strlen(acDelimitor) + 1 + strlen(acSourceString2) + strlen(acCR);

MakeEinrueckungHistory(nNr);

Destination.vlnew (&acDestinationString, (nLaenge + 1 + nEinzug + nGlobal));
if(nTabs==TRUE){
memset(acDestinationString, 0x09, nEinzug + nGlobal);
} else {
memset(acDestinationString, ' ', nEinzug + nGlobal);
}
if(IsEqual(acDelimitor, "default", 7) || nNr==TYPEDEF_END || nNr==STRUCT_END || nNr==UNION_END || nNr==ENUM_END){
if(strlen(acSourceString2)>0){
cKenner = acSourceString2[0];
}
if((nNr==TYPEDEF_END || nNr==STRUCT_END || nNr==UNION_END || nNr==ENUM_END) && strlen(acSourceString2)>0 && cKenner!=';'){
sprintf(acDestinationString + strlen(acDestinationString), "%s %s%s", acDelimitor, acSourceString2, acCR);
} else {
sprintf(acDestinationString + strlen(acDestinationString), "%s%s%s", acDelimitor, acSourceString2, acCR);
}
} else {
sprintf(acDestinationString + strlen(acDestinationString), "%s %s%s", acDelimitor, acSourceString2, acCR);
}

if(nEinrueckenVergroessern==TRUE && IsEqual(acSourceString0, "do", 5)){ // siehe beim Bestücken von "nEinrueckenVergroessern" unten in 'main'
} else {
Source.ReadNextWord();
if(nNr==DOWHILE_END || nNr==TYPEDEF_END || nNr==STRUCT_END || nNr==UNION_END || nNr==ENUM_END){ // damit die nächste Leerzeile nicht verschluckt wird
nDelimitor = FALSE;
}
}
} else if(nNr==BREAK_END){
nLaenge = strlen(acDelimitor) + 1 + strlen(acSourceString2) + strlen(acCR);

MakeEinrueckungHistory(nNr);
Destination.vlnew (&acDestinationString, (nLaenge + 1 + nEinzug + nGlobal));
if(nTabs==TRUE){
memset(acDestinationString, 0x09, nEinzug + nGlobal);
} else {
memset(acDestinationString, ' ', nEinzug + nGlobal);
}
sprintf(acDestinationString + strlen(acDestinationString), "%s%s%s", acDelimitor, acSourceString2, acCR);

Source.ReadNextWord();
} else {
nLaenge = strlen(acDelimitor);

MakeEinrueckungHistory(nNr);
Destination.vlnew (&acDestinationString, (nLaenge + 1 + nEinzug + nGlobal));
if(nTabs==TRUE){
memset(acDestinationString, 0x09, nEinzug + nGlobal);
} else {
memset(acDestinationString, ' ', nEinzug + nGlobal);
}
sprintf(acDestinationString + strlen(acDestinationString), "%s", acDelimitor);

}
} else {
/*
if(nNr==-1){
if(nCounter>0 && nCounterAktivKennerFuerMode1==nCounter){ // beim ersten mal
MakeEinrueckungHistory(ELSE_BEGIN);
}
} else {
MakeEinrueckungHistory(nNr);
}*/

MakeEinrueckungHistory(nNr);
Destination.vlnew (&acDestinationString, (strlen(acDelimitor) + 1 + nEinzug + nGlobal + strlen(acCR)));
if(nTabs==TRUE){
memset(acDestinationString, 0x09, nEinzug + nGlobal);
} else {
memset(acDestinationString, ' ', nEinzug + nGlobal);
}
sprintf(acDestinationString + strlen(acDestinationString), "%s%s", acDelimitor, acCR);

}
}
if(nAnzahlEinzug>0 || nNr==BREAK_END){
if(nEinrueckenVergroessern==TRUE){
nEinzug = nEinzug + nAnzahlEinzug;
}
}
nRet = TRUE;
}
return(nRet);
}

//------------------------------------------------------------------
// Normal
//------------------------------------------------------------------
int Normal(void)
{
int nRet=FALSE;
int nNr=-1;
int nAnzahlEinzug;
int nKorrektur=TRUE;
int nNochmehr=0;
long lAnzahl;
int nFlag1;
int nFlag2;
int nTestCount;
int nTestCountAktiv;


if(strlen(acSourceString)>0){
if(nKommentar==FALSE && (nCounter>=1 || (nCounterNormal>=1 && nCounterNormalErsteMal==FALSE) || nCounterWarAktiv==TRUE) && !IsEqual(acSourceString, "if", 2) && !IsEqual(acSourceString, "else", 4)){
nNochmehr = Einrueck.If;
}

Destination.vlnew (&acDestinationString, (strlen(acSourceString) + 1 + nEinzug + nGlobal + strlen(acCR) + nNochmehr));

// bei "else if": wenn else und if in getrennten Zeilen stehen, wird beides in gleiche Zeile geschrieben
if(nKommentar==FALSE && IsEqual(acSourceString, "if", 2) && IsEqual(acSourceString0, "else", 4) && strlen(acSourceString0)==4){
} else {
if(nTabs==TRUE){
memset(acDestinationString, 0x09, nEinzug + nGlobal + nNochmehr);
} else {
memset(acDestinationString, ' ', nEinzug + nGlobal + nNochmehr);
}
}
// bei "else if": wenn else und if in getrennten Zeilen stehen, wird beides in gleiche Zeile geschrieben
if(nKommentar==FALSE && IsEqual(acSourceString, "else", 4) && IsEqual(acSourceString2, "if", 2) && strlen(acSourceString)==4){
sprintf(acDestinationString + strlen(acDestinationString), "%s ", acSourceString);
} else {
sprintf(acDestinationString + strlen(acDestinationString), "%s%s", acSourceString, acCR);
}

if(nKommentar==FALSE
&& IsEqual(acDelimitor, acCR, 2) && ((!IsEqual(acDelimitor2, "{", 1)) && (!IsEqual(acDelimitor2, "}", 1)))){
if(nCounterAktiv==FALSE && IsEqual(acSourceString, "if", 2)){
if(nEinrueckenVergroessern==TRUE){
nNr = DoEinruecken("if", &nAnzahlEinzug);
nEinzug = nEinzug + nAnzahlEinzug;
}
nSingleLine++;
nKorrektur = FALSE;
if(nCounter==0){
nCounterWarAktiv = FALSE;
}
} else if(nCounterAktiv==FALSE && IsEqual(acSourceString, "else", 4)){
// bei "else if": wenn else und if in getrennten Zeilen stehen, wird beides in gleiche Zeile geschrieben
if(IsEqual(acSourceString, "else", 4) && IsEqual(acSourceString2, "if", 2) && strlen(acSourceString)==4){
} else {
if(nEinrueckenVergroessern==TRUE){
nNr = DoEinruecken("else", &nAnzahlEinzug);
nEinzug = nEinzug + nAnzahlEinzug;
}
nSingleLine++;
nKorrektur = FALSE;
if(nCounter==0){
nCounterWarAktiv = FALSE;
}
}
} else if(IsEqual(acSourceString, "for", 3)){
if(nEinrueckenVergroessern==TRUE){
nNr = DoEinruecken("for", &nAnzahlEinzug);
nEinzug = nEinzug + nAnzahlEinzug;
}
nSingleLine++;
nKorrektur = FALSE;
if(nCounter==0){
nCounterWarAktiv = FALSE;
}
} else if(IsEqual(acSourceString, "while", 5)){
if(nEinrueckenVergroessern==TRUE){
nNr = DoEinruecken("while", &nAnzahlEinzug);
nEinzug = nEinzug + nAnzahlEinzug;
}
nSingleLine++;
nKorrektur = FALSE;
if(nCounter==0){
nCounterWarAktiv = FALSE;
}
} else if(IsEqual(acSourceString, "typedef struct", 14)){
if(nEinrueckenVergroessern==TRUE){
nNr = DoEinruecken("typedef struct", &nAnzahlEinzug);
nEinzug = nEinzug + nAnzahlEinzug;
}
nSingleLine++;
nKorrektur = FALSE;
if(nCounter==0){
nCounterWarAktiv = FALSE;
}
} else if(IsEqual(acSourceString, "struct", 6) || IsEqual(acSourceString, "extern struct", 13)){
if(nEinrueckenVergroessern==TRUE){
nNr = DoEinruecken("struct", &nAnzahlEinzug);
nEinzug = nEinzug + nAnzahlEinzug;
}
nSingleLine++;
nKorrektur = FALSE;
if(nCounter==0){
nCounterWarAktiv = FALSE;
}
} else if(IsEqual(acSourceString, "union", 5) || IsEqual(acSourceString, "extern union", 12)){
if(nEinrueckenVergroessern==TRUE){
nNr = DoEinruecken("union", &nAnzahlEinzug);
nEinzug = nEinzug + nAnzahlEinzug;
}
nSingleLine++;
nKorrektur = FALSE;
if(nCounter==0){
nCounterWarAktiv = FALSE;
}
} else if(IsEqual(acSourceString, "enum", 4) || IsEqual(acSourceString, "extern enum", 11)){
if(nEinrueckenVergroessern==TRUE){
nNr = DoEinruecken("enum", &nAnzahlEinzug);
nEinzug = nEinzug + nAnzahlEinzug;
}
nSingleLine++;
nKorrektur = FALSE;
if(nCounter==0){
nCounterWarAktiv = FALSE;
}
} else {
if(nKommentar==FALSE && nCounterWarAktiv==TRUE){
nCounterWarAktiv2--;
if(nCounterWarAktiv2==TRUE){
nCounterWarAktiv2= FALSE;
nCounterWarAktiv = FALSE;
} else {
nCounterWarAktiv2 = nCounter + 3;
}
}
}
}
/*
if(nCounterAktiv==FALSE && IsEqual(acSourceString, "if", 2)
|| IsEqual(acSourceString, "else", 4)){
if(nNr==-1){
if(nCounterNormal>0 && nCounterNormalAktivKennerFuerMode1==nCounterNormal){ // beim ersten mal
MakeEinrueckungHistory(ELSE_BEGIN);
}
} else {
MakeEinrueckungHistory(nNr);
}
} else {
MakeEinrueckungHistory(nNr);
}
*/
MakeEinrueckungHistory(nNr);

if(nEinrueckenVergroessern==TRUE){

if(nKommentar==FALSE && nKorrektur==TRUE && nSingleLine>0){

// nTestCount = nCounter;
// nTestCountAktiv = nCounterAktiv;
// if(nTestCount==0 || nTestCountAktiv==FALSE){
nTestCount = nCounterNormal;
nTestCountAktiv = nCounterNormalAktiv;
// }
if(nSingleLine<=1 && nTestCount>1 && (IsEqual(acSourceString0, "if", 2) || IsEqual(acSourceString0, "else", 4))){
// nTestCount = 0;
// nTestCountAktiv = FALSE;
}

if(!IsEqual(acSourceString2, "else", 4)){
nFlag1 = TRUE;
} else {
nFlag1 = FALSE;
}
if((nTestCount==0/* || IsEqual(acSourceString0, "if", 2)*/)
&& ((strlen(acSourceString2)!=0 && (nTestCountAktiv==FALSE/* || IsEqual(acSourceString0, "if", 2)*/))
|| (strlen(acSourceString2)==0 && !IsEqual(acSourceString3, "else", 4)))){
nFlag2 = TRUE;
} else {
nFlag2 = FALSE;
}

if(((nTestCount<=1/* || IsEqual(acSourceString0, "if", 2)*/) && (IsEqual(acSourceString0, "else", 4) || IsEqual(acSourceString_1, "else", 4))) || (nFlag1==TRUE && nFlag2==TRUE)){
while(nSingleLine>0){ // normal oder else ohne {} -> else eine Stufe zurück
nSingleLine--;
nNr = Einrueckung->nNr + 1;
EinrueckungHandle.vldelet(&Einrueckung);
EinrueckungHandle.vlanz(&lAnzahl);
if(lAnzahl>0){
EinrueckungHandle.vllast(&Einrueckung);
}
if(nEinrueckenVergroessern==TRUE){
nEinzug += BestimmeEinruecken(nNr);
}
}
} else if(nTestCount<=1){
nSingleLine--;
nNr = Einrueckung->nNr + 1;
EinrueckungHandle.vldelet(&Einrueckung);
EinrueckungHandle.vlanz(&lAnzahl);
if(lAnzahl>0){
EinrueckungHandle.vllast(&Einrueckung);
}
if(nEinrueckenVergroessern==TRUE){
nEinzug += BestimmeEinruecken(nNr);
}
}
}
}
nCounter--;
if(nCounter==0){
nCounterAktiv = FALSE;
nCounterWarAktiv = TRUE;
}
nCounterNormal--; // wird für normale Zeile benutzt (Handling der Klammern bzw. mehrzeile Befehle)
if(nCounterNormal==0){
nCounterNormalAktiv = FALSE;
}

nRet = TRUE;
}
nDelimitor = FALSE;
return(nRet);
}

//------------------------------------------------------------------
// main
//------------------------------------------------------------------
void main(void)
{
int nRet=FALSE, nRet2=FALSE;
char acDateiname[1024];
long lLaenge;
int nPosition;
int nWeiter, nWeiter2;
int i, nKlammern;
int nMerker;
int nLokalKommentar;
int nLokalKommentar2;
int nKommentar2;
char cChecked, cChecked2;
int nErsterDurchlauf;
long lPosition2;
long lAnzeigeStartPosition;
long lAnzeigeEndePosition;
int nNormaleZeile;
int nReturn;
int nNr0=-1, nNr=-1, nNr2=-1, nNr3=-1, nNr4=-1;
int nWarSchon;
int nWarSchon2;
long lAnzahl;
int nZeileUeberspringen;
int nErr;
int nKlammernGeschweift=FALSE;


sprintf(acDummyDelimitor, "%s", "");
sprintf(acDummySourceString, "%s", "");
acSourceString2 = acDummyDelimitor;
acDelimitor2 = acDummySourceString;
acSourceString0 = acDummyDelimitor;
acDelimitor0 = acDummySourceString;
acSourceString3 = acDummyDelimitor;
acDelimitor3 = acDummySourceString;
acDelimitor_1 = acDummyDelimitor;
acSourceString_1 = acDummySourceString;

if(InitMaster()==TRUE){
if(Init()==TRUE){
sprintf(WINMAIN_acString, "%s", ""); Print(WINMAIN_acString);
sprintf(acDateiname, "%s", acZielDateiname);
if(DestinationFile.CreateOpen(acDateiname)==TRUE){

sprintf(WINMAIN_acString, "%s - Making %s ...", CLASS_NAME, acQuellDateiname);
SetWindowText(g_hWnd, WINMAIN_acString);
EinrueckungHandle.vlInit();
EinrueckungHandleHistory.vlInit();
Destination.vlInit();
DestinationFile.SetCR(FALSE);

Source.Init(acSourceFile);
SetDelimitors();
sprintf(WINMAIN_acString, "Making %s ...", acQuellDateiname); Print(WINMAIN_acString);

while(Source.ReadNextWord()==TRUE){

if(WndParamCheck()==TRUE){
nExit = TRUE;
Source.DeInit();
sprintf(WINMAIN_acString, "%s", "Exit. Nothing saved ..."); Print(WINMAIN_acString);
EinrueckungHandleHistory.vlDeInit();
EinrueckungHandle.vlDeInit();
Destination.vlDeInit();
DestinationFile.Close();
DeInit();
return;
}

Source.GetReadedWord((char *)&acSourceString);

if(nHandsOffComment==TRUE && nKommentar!=FALSE){ // bei Kommentar kein Trim
} else {
Trim(acSourceString);
}

Source.GetReadedDelimitor((char *)&acDelimitor);

nPosition = Source.GetPositionChars();

nWeiter = FALSE;

nMerker = nKommentar;
nKlammern = 0;
if(nCounterAktiv==FALSE/* || ((IsEqual(acSourceString2, "if", 2) || IsEqual(acSourceString2, "else", 4)))*/){
nCounter = 0;
// nCounterAktiv = FALSE;
}
if(nCounterNormalAktiv==FALSE){
nCounterNormal = 0;
}
nRet = nRet2 = FALSE;
nLokalKommentar = FALSE;
nErsterDurchlauf = TRUE;
nNormaleZeile = FALSE;

while(nWeiter==FALSE && (nRet = Source.ReadNextWord())==TRUE){
Source.GetReadedWord((char *)&acSourceString2);
Trim(acSourceString2);
if(nKommentar==FALSE){
if(nLokalKommentar!=4){
nLokalKommentar = FALSE; // soll beim Klammernzählen auf die Kommentare achten
}
for(i=0;i<(signed)strlen(acSourceString2);i++){
cChecked = acSourceString2[i];
if((i + 1)<(signed)strlen(acSourceString2)){
cChecked2 = acSourceString2[i + 1];
} else {
cChecked2 = 0;
}
if((nLokalKommentar==FALSE || nLokalKommentar==1) && cChecked==34){ // " 34
if(nLokalKommentar==FALSE){
nLokalKommentar = 1;
} else {
nLokalKommentar = FALSE;
}
} else if((nLokalKommentar==FALSE || nLokalKommentar==2) && cChecked==39){ // ' 39
if(nLokalKommentar==FALSE){
nLokalKommentar = 2;
} else {
nLokalKommentar = FALSE;
}
} else if((nKommentar==FALSE && cChecked=='/' && cChecked2=='/') || (nKommentar==3 && cChecked==0xD && cChecked2==0xA)){ // //
if(nLokalKommentar==FALSE){
nLokalKommentar = 3;
} else {
nLokalKommentar = FALSE;
}
} else if(nLokalKommentar==FALSE && cChecked=='/' && cChecked2=='*'){ // /*
nLokalKommentar = 4;
} else if(nLokalKommentar==4 && cChecked=='*' && cChecked2=='/'){ // */
nLokalKommentar = FALSE;
}
nKommentar = nLokalKommentar;
if(nLokalKommentar==FALSE){
if(acSourceString2[i]=='('){
if(nErsterDurchlauf==TRUE // prüft ob die Klammern in verschiedenen Zeilen zu if/else gehören oder zu einem normalen Befehl in mehreren Zeilen
//&& !IsEqual(acSourceString0, "if", 2) && !IsEqual(acSourceString0, "else", 4)
&& !IsEqual(acSourceString2, "if", 2) && !IsEqual(acSourceString2, "else", 4)){
nKlammern++;
nErsterDurchlauf = FALSE;
nNormaleZeile = TRUE;
} else {
nKlammern++;
nErsterDurchlauf = FALSE;
}
} else if(acSourceString2[i]==')'){
if(nKlammern>0){
nKlammern--;
}
}
}
}
}
Source.GetReadedDelimitor((char *)&acDelimitor2);

if(nKommentar!=FALSE || (nKlammern==0 && ((!IsEqual(acSourceString, "if", 2)
&& !IsEqual(acSourceString, "else", 4))
|| strlen(acSourceString2)!=0 || !IsEqual(acDelimitor2, acCR, 2)))){
nWeiter = TRUE;

if(nKommentar==FALSE){
nWeiter2 = FALSE;
while(nWeiter2==FALSE && (nRet2 = Source.ReadNextWord())==TRUE){
Source.GetReadedWord((char *)&acSourceString3);
Trim(acSourceString3);
Source.GetReadedDelimitor((char *)&acDelimitor3);
if(strlen(acSourceString3)!=0 || !IsEqual(acDelimitor3, acCR, 2)){
nWeiter2 = TRUE;
}
}
}

}
if((nWeiter==FALSE) && nKlammern>0 && nCounterAktiv==FALSE && nCounterNormalAktiv==FALSE){
if(nNormaleZeile==TRUE){// wird für normale Zeile benutzt (Handling der Klammern bzw. mehrzeile Befehle)
nCounterNormal++;
} else {
nCounter++;
}
}
nErsterDurchlauf = FALSE;

}
if(nCounter>0){
if(nCounterAktiv==FALSE){
nCounterAktiv = TRUE;
nCounterAktivKennerFuerMode1 = nCounter;
}
}
if(nCounterNormal>0){ // wird für normale Zeile benutzt (Handling der Klammern bzw. mehrzeile Befehle)
if(nCounterNormalAktiv==FALSE){
nCounterNormalAktiv = TRUE;
nCounterNormalErsteMal = 2;
nCounterNormal += 2;
nCounterNormalAktivKennerFuerMode1 = nCounterNormal;
} else {
nCounterNormalErsteMal--;
}
}
if(nRet==FALSE){
acSourceString2 = acDummyDelimitor;
acDelimitor2 = acDummySourceString;
}
if(nRet2==FALSE){
acSourceString3 = acDummyDelimitor;
acDelimitor3 = acDummySourceString;
}
nKommentar = nMerker;
Source.SetPositionChars(nPosition);

if(nEinrueckenVergroessern==FALSE){
nEinrueckenVergroessern = TRUE;
if(nCounterWarAktiv==TRUE){ // könnte bei leeren if's if(i==0){} nicht auf false sein
nCounterWarAktiv = FALSE;
}
}

if(nEinrueckenVergroessern==-1){
nEinrueckenVergroessern = FALSE;
}
if(nEinrueckenVergroessern== -2){
nEinrueckenVergroessern = -1;
}
if(IsEqual(acDelimitor, "{", 1)
&& ((strlen(acSourceString2)==0 && strlen(acSourceString3)==0 && IsEqual(acDelimitor3, "}", 1))
|| (strlen(acSourceString2)==0 && IsEqual(acDelimitor2, "}", 1)))){

nEinrueckenVergroessern = -2;
}
if(nKommentar==4){
nEinrueckenVergroessern = nEinrueckenVergroessern;
}

Destination.vlanz(&lLaenge);
if(lLaenge>0){
Destination.vlreq(&acDestinationString, &lAnzeigeStartPosition, &lLaenge);
}

if(Suche("{")==TRUE){
nPruefsummeGeschweifteKlammern++;
} else if(Suche("}")==TRUE){
nPruefsummeGeschweifteKlammern--;
} else if(Suche("default")==TRUE){
} else if(Suche("case")==TRUE){
} else if(Suche("break")==TRUE){
} else if(nDelimitor==FALSE && strlen(acSourceString)==0 && strlen(acDelimitor)==strlen(acCR) && IsEqual(acCR, acDelimitor, strlen(acCR))){
if(strlen(acDelimitor)>0){
/*
EinrueckungHandle.vlanz(&lAnzahl);
if(lAnzahl>0){
if(Einrueckung->nNr==DUMMY_BEGIN){
MakeEinrueckungHistory(-1);
Destination.vlnew (&acDestinationString, 1 + strlen(acCR));
sprintf(acDestinationString + strlen(acDestinationString), "1%s%s", acDestinationString, acCR);
} else {
MakeEinrueckungHistory(-1);
Destination.vlnew (&acDestinationString, 1 + strlen(acCR));
sprintf(acDestinationString + strlen(acDestinationString), "%s%s", acDestinationString, acCR);
}
} else {*/
MakeEinrueckungHistory(-1);
Destination.vlnew (&acDestinationString, 1 + strlen(acCR));
sprintf(acDestinationString + strlen(acDestinationString), "%s%s", acDestinationString, acCR);
//}
}
nDelimitor = FALSE;
} else {
Normal();
}

Destination.vlanz(&lLaenge);
if(lLaenge>0){
Destination.vlreq(&acDestinationString, &lAnzeigeEndePosition, &lLaenge);
}

if(lAnzeigeEndePosition!=lAnzeigeStartPosition){
sprintf(WINMAIN_acString, "%s - Making %s ... %3d%%", CLASS_NAME, acQuellDateiname, (nPosition * 100 / Source.GetTextSize()));
SetWindowText(g_hWnd, WINMAIN_acString);
if(nDetails==TRUE){
if(Destination.vlnum(lAnzeigeStartPosition, &acDestinationString, &lLaenge)==TRUE){
while(Destination.vlnext(&acDestinationString, &lLaenge)==TRUE){
sprintf(WINMAIN_acString, "%-80.80s", acDestinationString); Print(WINMAIN_acString);
}
}
Destination.vlnum(lAnzeigeEndePosition, &acDestinationString, &lLaenge);
}
}

if(nCounterNormal<=1){
acSourceString_1 = acSourceString0;
acDelimitor_1 = acDelimitor0;
}
if(strlen(acSourceString)!=0){
acSourceString0 = acSourceString;
acDelimitor0 = acDelimitor;
} else if(IsEqual(acSourceString0, "else", 4)){ // bei geschachtelten if's notwendig
acSourceString0 = acDummyDelimitor;
acDelimitor0 = acDummySourceString;
} else if(IsEqual(acDelimitor, "case", 4) || IsEqual(acDelimitor, "break", 5) ||IsEqual(acDelimitor, "default", 7)){
acSourceString0 = acDummyDelimitor;
acDelimitor0 = acDummySourceString;
}

if(nPruefsummeGeschweifteKlammern==0){ // wenn Anzahl der {}==0, dann zurücksetzten, bei der Funktion wird frisch aufgesetzt
EinrueckungHandle.vlanz(&lAnzahl);
if(lAnzahl>0){
nEinzug = 0;
EinrueckungHandle.vlDeInit();
EinrueckungHandle.vlInit();
sprintf(WINMAIN_acString, "%s", "Unknown error while processing current function. Sourcecode corrupt? Reseting."); Print(WINMAIN_acString);
}
}
}

Source.DeInit();

sprintf(WINMAIN_acString, "%s", "Saving ..."); Print(WINMAIN_acString);

if(nMode==FALSE){
Destination.vlroot();
while(Destination.vlnext(&acDestinationString, &lLaenge)==TRUE){
DestinationFile.WriteTextRow(acDestinationString);
}
} else { // ==TRUE geschweifte Klammern oben neben if/else/...-Block
nKlammern = 0;
nReturn = TRUE;
Destination.vlroot();
EinrueckungHandleHistory.vlroot();
EinrueckungHandleHistory.vlanz(&lAnzahl);
Destination.vlanz(&lAnzahl);
nKommentar = FALSE;
nKommentar2 = FALSE;
// nKlammernGeschweift = FALSE;
while(Destination.vlnext(&acDestinationString, &lLaenge)==TRUE){

Destination.vlreq(&acDestinationString, &lAnzeigeStartPosition, &lLaenge);
Destination.vlnum(lAnzeigeStartPosition, &acDestinationString, &lLaenge);

if(EinrueckungHandleHistory.vlnum((lAnzeigeStartPosition - 1), &EinrueckungHistory)){
nNr0 = EinrueckungHistory->nNr;
} else {
nNr0 = -1;
}
if(EinrueckungHandleHistory.vlnum(lAnzeigeStartPosition, &EinrueckungHistory)){
nNr = EinrueckungHistory->nNr;
} else {
nNr = -1;
}
if(EinrueckungHandleHistory.vlnum((lAnzeigeStartPosition + 1), &EinrueckungHistory)){
nNr2 = EinrueckungHistory->nNr;
} else {
nNr2 = -1;
}
if(EinrueckungHandleHistory.vlnum((lAnzeigeStartPosition + 2), &EinrueckungHistory)){
nNr3 = EinrueckungHistory->nNr;
} else {
nNr3 = -1;
}
if(EinrueckungHandleHistory.vlnum((lAnzeigeStartPosition + 3), &EinrueckungHistory)){
nNr4 = EinrueckungHistory->nNr;
} else {
nNr4 = -1;
}
EinrueckungHandleHistory.vlnum(lAnzeigeStartPosition, &EinrueckungHistory);

if(Destination.vlnext(&acDestinationString2, &lLaenge)==TRUE){
nZeileUeberspringen = FALSE;
nErr = FALSE;
/*
if(nNr==IF_BEGIN || nNr==IF_BEGIN){
Trim(acDestinationString2);
if(strlen(acDestinationString2)==0){

while(nZeileUeberspringen==FALSE && (nErr = Destination.vlnext(&acDestinationString2, &lLaenge))==TRUE){
Trim(acDestinationString2);
if(strlen(acDestinationString2)==0){
break;
}
nLokalKommentar2 = nKommentar2;
nWarSchon2 = FALSE;
for(i=0;i<(signed)strlen(acDestinationString2);i++){
cChecked = acDestinationString2[i];
if((i + 1)<(signed)strlen(acDestinationString2)){
cChecked2 = acDestinationString2[i + 1];
} else {
cChecked2 = 0;
}
if((nLokalKommentar2==FALSE || nLokalKommentar2==1) && cChecked==34){ // " 34
if(nLokalKommentar2==FALSE){
nLokalKommentar2 = 1;
} else {
nLokalKommentar2 = FALSE;
}
} else if((nLokalKommentar2==FALSE || nLokalKommentar2==2) && cChecked==39){ // ' 39
if(nLokalKommentar2==FALSE){
nLokalKommentar2 = 2;
} else {
nLokalKommentar2 = FALSE;
}
} else if((nKommentar2==FALSE && cChecked=='/' && cChecked2=='/') || (nKommentar==3 && cChecked==0xD && cChecked2==0xA)){ // //
if(nLokalKommentar2==FALSE){
nLokalKommentar2 = 3;
} else {
nLokalKommentar2 = FALSE;
} */
// } else if(nLokalKommentar2==FALSE && cChecked=='/' && cChecked2=='*'){ // /*
//nLokalKommentar2 = 4;
//} else if(nLokalKommentar2==4 && cChecked=='*' && cChecked2=='/'){ // */
/* nLokalKommentar2 = FALSE;
}
nKommentar2 = nLokalKommentar2;
if(nLokalKommentar2==FALSE && nWarSchon2==FALSE){
if(acDestinationString2[i]=='{'){
nWarSchon2 = TRUE;
nZeileUeberspringen = TRUE;
}
}
}
}
}
}

Destination.vlreq(&acDestinationString2, &lLaenge, &lPosition2);
Destination.vlnum(lPosition2, &acDestinationString2, &lLaenge);
*/
if(nErr==TRUE || nZeileUeberspringen==FALSE){
Destination.vlnum(lAnzeigeStartPosition, &acDestinationString, &lLaenge);
}
} else {
acDestinationString2 = acDummySourceString;
}

nLokalKommentar = nKommentar;
nWarSchon = FALSE;
for(i=0;i<(signed)strlen(acDestinationString2);i++){
cChecked = acDestinationString2[i];
if((i + 1)<(signed)strlen(acDestinationString2)){
cChecked2 = acDestinationString2[i + 1];
} else {
cChecked2 = 0;
}
if((nLokalKommentar==FALSE || nLokalKommentar==1) && cChecked==34){ // " 34
if(nLokalKommentar==FALSE){
nLokalKommentar = 1;
} else {
nLokalKommentar = FALSE;
}
} else if((nLokalKommentar==FALSE || nLokalKommentar==2) && cChecked==39){ // ' 39
if(nLokalKommentar==FALSE){
nLokalKommentar = 2;
} else {
nLokalKommentar = FALSE;
}
} else if((nKommentar==FALSE && cChecked=='/' && cChecked2=='/') || (nKommentar==3 && cChecked==0xD && cChecked2==0xA)){ // //
if(nLokalKommentar==FALSE){
nLokalKommentar = 3;
} else {
nLokalKommentar = FALSE;
}
} else if(nLokalKommentar==FALSE && cChecked=='/' && cChecked2=='*'){ // /*
nLokalKommentar = 4;
} else if(nLokalKommentar==4 && cChecked=='*' && cChecked2=='/'){ // */
nLokalKommentar = FALSE;
}
nKommentar = nLokalKommentar;
if(nLokalKommentar==FALSE && nWarSchon==FALSE){
if(acDestinationString2[i]=='{'){
nKlammernGeschweift++;
if(nKlammernGeschweift>1){
nWarSchon = TRUE;
TrimCR(acDestinationString);
nReturn = FALSE;
i = (signed)strlen(acDestinationString2);
if(nNr2==DOWHILE_BEGIN || (nNr2==DOWHILE_END || nNr4==DOWHILE_END)){ // nNr2==DOWHILE_END || nNr4==DOWHILE_END) für leere do-whiles
sprintf(acDestinationString + strlen(acDestinationString), "%s", " ");
}
}
} else if(acDestinationString2[i]=='}'){
nKlammernGeschweift--;
nWarSchon = TRUE;
nKlammern--;
nReturn = TRUE;
if(nNr2==IF_END && ((nNr3==ELSE_BEGIN) || (nNr4==ELSE_BEGIN))){
nReturn = -3;
}

i = (signed)strlen(acDestinationString2);

} else if((i + 3 + 0)<(signed)strlen(acDestinationString2)
&& acDestinationString2[i + 0 + 0]=='e'
&& acDestinationString2[i + 1 + 0]=='l'
&& acDestinationString2[i + 2 + 0]=='s'
&& acDestinationString2[i + 3 + 0]=='e'
){
/*
nWarSchon = TRUE;
nKlammern--;
nReturn = TRUE;
if(nNr0==IF_BEGIN && (nNr2==ELSE_BEGIN || nNr3==ELSE_BEGIN)){
nReturn = -3;
}

i = (signed)strlen(acDestinationString2);
*/
nWarSchon = TRUE;
nKlammern--;
nReturn = TRUE;
if(strlen(acDestinationString)>=3 && acDestinationString[strlen(acDestinationString) - 3]=='}'){
TrimCR(acDestinationString);
sprintf(acDestinationString + strlen(acDestinationString), "%s", " ");
LeftTrim(acDestinationString2);
}

i = (signed)strlen(acDestinationString2);


} else if(nReturn==FALSE){
nWarSchon = TRUE;
LeftTrim(acDestinationString);
nReturn = TRUE;
} else if(nReturn==-1){
nWarSchon = TRUE;
LeftTrim(acDestinationString);
nReturn = TRUE;
} else if(nReturn==-2){
nWarSchon = TRUE;
LeftTrim(acDestinationString);
TrimCR(acDestinationString);
if(strlen(acDestinationString)==4 && IsEqual(acDestinationString, "else", 4)){ // nur nach else Leerzeichen einfügen
sprintf(acDestinationString + strlen(acDestinationString), "%s", " ");
}
nReturn = -1;
} else if(nReturn==-3){
nWarSchon = TRUE;
TrimCR(acDestinationString);
sprintf(acDestinationString + strlen(acDestinationString), "%s", " ");
nReturn = -2;
}
}
}
DestinationFile.WriteTextRow(acDestinationString);
}
}
EinrueckungHandle.vlDeInit();
EinrueckungHandleHistory.vlDeInit();
Destination.vlDeInit();
DestinationFile.Close();
} else {
sprintf(WINMAIN_acString, "Can not open %s.", acDateiname);
AusnahmeFehler(WINMAIN_acString, __CFILE__, __LINE__);
}
DeInit();
}
DeInitMaster();
}
PostMessage(g_hWnd, WM_CLOSE ,0 ,0);
return;
}