// *********************************************************************
//   Created with MBC (V) 4.0-Beta4 (2022/07/26)Ported to OSX by Armando Rivera
//   Ported from BCX32 BASIC To C/C++ Translator (V) 5.12
//   BCX (c) 1999 - 2018 by Kevin Diggins
//   LinuxBC (c) 2009 by Mike Henning 
//   MBC (c) 2009 - 2018 by Armando Rivera
// *********************************************************************
//   Translated for compiling with the g++ Compiler
//   g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$.cc -ldl -o $FILE$
// *********************************************************************
#include <stdbool.h>
#include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string.h>
#include <stddef.h>
#include <stdlib.h>
#include <setjmp.h>
#include <time.h>
#include <stdarg.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#include <dlfcn.h>


// ***************************************************
// Compiler Defines
// ***************************************************
  #define C_EXPORT extern "C"
  #define C_IMPORT extern "C"

#ifndef stat
  #define lstat stat
#endif
#ifndef _fcloseall
  #define _fcloseall _fcloseall
#endif
#ifndef HWND
  #define HWND GHWND
#endif
#ifndef MAX_PATH
  #define MAX_PATH 2048
#endif
#ifndef CALLBACK
  #define CALLBACK
#endif
typedef unsigned int HINSTANCE;
typedef void* LPVOID;
typedef char* PCHAR;
typedef unsigned char BYTE;
typedef unsigned int  UINT;
typedef unsigned char UCHAR;
typedef unsigned char* PUCHAR;
typedef unsigned long ULONG;
typedef unsigned long* ULONG_PTR;
typedef unsigned long DWORD;

#ifndef TRUE
  #define TRUE 1
#endif

#ifndef FALSE
  #define FALSE 0
#endif
#define BOOL bool

// ***************************************************

typedef long (*CPP_FARPROC)(char *);


// *************************************************
//            User Defined Constants
// *************************************************

#define Version "4.0-Beta4 (2022/07/26)"
#define __BCX__ 1
#define vt_VarMin 2
#define vt_VarMax vt_VARIANT 
#define fprintf ReDirectFPrint 
#define MaxElements 128
#define MaxTypes 512
#define MaxLocalVars 512
#define MaxGlobalVars 4096
#define MaxLib 64
#define c_SglQt 39
#define c_DblQt 34
#define c_LPar 40
#define c_RPar 41
#define c_Komma 44
#define c_LtBkt 91
#define c_RtBkt 93
#define BCX_STR_RUNTIME "Runtime Functions"
#define BCX_STR_MAIN_PROG "Main Program"
#define BCX_STR_SYS_VARS "System Variables"
#define BCX_STR_STD_MACROS "Standard Macros"
#define BCX_STR_STD_PROTOS "Standard Prototypes"
#define BCX_STR_USR_PROCS "User Subs and Functions"
#define BCX_STR_USR_VARS "User Global Variables"
#define BCX_STR_USR_PROTOS "User Prototypes"
#define BCX_STR_USR_CONST "User Defined Constants"
#define BCX_STR_USR_TYPES "User Defined Types, Classes (CPP Mode), And Unions"
#define FUNCTIONPARSE_CLASS struct _FUNCTIONPARSE*
#define VarTypes "%$#!@¦"
#define ARGTYPE_CLASS struct _ARGTYPE*
#define PROTOSTORE_CLASS struct _PROTOSTORE*
#define ELEMENT_CLASS struct _ELEMENT*
#define USERTYPEDEFS_CLASS struct _USERTYPEDEFS*
#define VARINFO_CLASS struct _VARINFO*
#define VARCODE_CLASS struct _VARCODE*
#define iMatchLft(A,B) iMatch (A ,B ,0)
#define iMatchWrd(A,B) iMatch (A ,B ,1)
#define iMatchRgt(A,B) iMatch (A ,B ,2)
// *************************************************
//        User's GLOBAL ENUM blocks
// *************************************************

enum
  {
    vt_UNKNOWN,
    vt_STRLIT,
    vt_INTEGER,
    vt_SINGLE,
    vt_DOUBLE,
    vt_LDOUBLE,
    VT_LLONG,
    vt_STRVAR,
    vt_DECFUNC,
    vt_NUMBER,
    vt_FILEPTR,
    vt_UDT,
    vt_STRUCT,
    vt_UNION,
    vt_BOOL,
    vt_CHAR,
    vt_LPSTRPTR,
    vt_PCHAR,
    vt_CHARPTR,
    vt_VOID,
    vt_LONG,
    vt_DWORD,
    vt_FARPROC,
    vt_LPBYTE,
    vt_LRESULT,
    vt_BYTE,
    vt_SHORT,
    vt_USHORT,
    vt_UINT,
    vt_ULONG,
    vt_HWND,
    vt_HDC,
    vt_COLORREF,
    vt_HANDLE,
    vt_HINSTANCE,
    vt_WNDCLASSEX,
    vt_HFONT,
    vt_VARIANT
  };


enum
  {
    mt_ProcessSetCommand,
    mt_FuncSubDecC_Dec,
    mt_FuncSubDecC_Dec2,
    mt_Opts,
    mt_Opts2,
    mt_Opts3,
    mt_OverLoad,
    mt_OverLoad2,
    mt_FuncSubx1,
    mt_FuncSubx2
  };



// *************************************************
//   User Defined Types, Classes (CPP Mode), And Unions
// *************************************************

typedef struct _functionParse
{
  int     NumArgs;
  int     CommaPos[128];
}functionParse, *LPFUNCTIONPARSE;


typedef struct _ARGTYPE
{
  char Arg[2048];
  int     ArgType;
}ARGTYPE, *LPARGTYPE;


typedef struct _ProtoStore
{
   char  Prototype[2048];
   char  Condition[512];
   int  CondLevel;
}ProtoStore, *LPPROTOSTORE;


typedef struct _Element
{
   int  ElementType;
   int  ElementID;
   int  ElementDynaPtr;
   char  ElementName[64];
}Element, *LPELEMENT;


typedef struct _UserTypeDefs
{
   int  TypeofDef;
   int  EleCnt;
   struct _Element  Elements[MaxElements];
   char  VarName[64];
}UserTypeDefs, *LPUSERTYPEDEFS;


typedef struct _VarInfo
{
   int  VarLine;
   int  VarType;
   int  VarDef;
   int  VarPntr;
   int  VarSF;
   int  VarExtn;
   int  VarCondLevel;
   int  VarEmitFlag;
   int  VarConstant;
   char  VarName[64];
   char  VarDim[128];
   char  VarModule[300];
   char  VarCondDef[128];
}VarInfo, *LPVARINFO;


typedef struct _VARCODE
{
   int  VarNo;
   int  Method;
   int  IsPtrFlag;
  char Header[2048];
  char Proto[2048];
  char Functype[2048];
  char StaticOut[2048];
  char Token[2048];
  char AsToken[2048];
}VARCODE, *LPVARCODE;


// *************************************************
//                System Variables
// *************************************************

char    TAB [2]={9,0};   // Horz Tab
char    LF  [2]={10,0};  // Line Feed
char    ESC [2]={27,0};  // Escape
char    SPC [2]={32,0};  // Space
char    DQ  [2]={34,0};  // Double-Quote
char    DDQ [3]={34,34,0}; // Double-Double-Quote
char    CRLF[3]={13,10,0}; // Carr Rtn & Line Feed
char    *AR_fgets_retval;

// *************************************************
//            User Global Variables
// *************************************************

static PCHAR   *G_argv;
static int     G_argc;
static int     NoRT;
static int     ByrefCnt;
static char    CurLine[65535];
static int     gLinesWritten;
static int     LoopLocalCnt;
static int     GlobalVarCnt;
static int     TypeDefsCnt;
static int     LocalVarCnt;
static int     LocalDynArrCount;
static int     LocalDynaCnt;
static int     GlobalDynaCnt;
static int     ModuleNdx;
static int     FPtrNdx;
static int     SplitCnt;
static int     SplitCur;
static char    SrcTmp[65535];
static int     StartNdx;
static int     ExitNdx;
static VARCODE VarCode;
static int     UmQt;
static char    LD_FLAGS[65535];
static char    Accelerator[65535];
static char    CallType[65535];
static int     CaseFlag;
static char    CaseVar[65535];
static char    Cmd[65535];
static char    Compiler[65535];
static char    CmdLineConst[65535];
static char    CmdLineFileOut[65535];
static int     CurrentFuncType;
static char    DimType[65535];
static int     DllCnt;
static int     LoadLibsCnt;
static float   Elapsed;
static int     EndOfProgram;
static int     EntryCnt;
static int     ErrFile;
static char    szFile[65535];
static char    Filnam[65535];
static int     ForceMainToFunc;
static char    Funcname[65535];
static char    Handl[65535];
static int     HFileCnt;
static char    HFile[65535];
static int     InConditional;
static char    InIfDef[65535];
static int     Indent;
static int     InFunc;
static int     InMain;
static int     IsCallBack;
static int     TurboSize;
static int     UseCProto;
static int     InTypeDef;
static int     IsAuto;
static int     NoTypeDeclare;
static int     IsDim;
static int     IsExported;
static int     IsRegister;
static int     IsStatic;
static int     IsStdFunc;
static int     IsLocal;
static int     IsRaw;
static int     IsApple;
static int     KillCFile;
static char    Keyword1[65535];
static int     LastCmd;
static int     LinesRead;
static char    Linker[65535];
static char    Lookup[65535];
static int     MakeDLL;
static int     Ndx;
static int     NoMain;
static int     NoDllMain;
static int     OkayToSend;
static char    Op[65535];
static int     OptionBase;
static char    OutfileClone[65535];
static int     PassOne;
static int     ProtoCnt;
static int     Pusher;
static int     Quiet;
static int     ReDirect;
static FILE   *SaveOutfileNum;
static char    Scoot[65535];
static int     ShowStatus;
static int     SrcCnt;
static int     SrcFlag;
static int     TrcFlag;
static int     TestForBcxIni;
static char    FileIn[65535];
static char    FileOut[65535];
static char    FileErr[65535];
static char    T[65535];
static int     Test;
static int     Statements;
static int     TestState;
static char    Tipe[65535];
static int     TranslateSlash;
static int     UseCpp;
static int     UseFlag;
static int     InNameSpace;
static int     Use_Virtual;
static char    vproc[65535];
static int     UseStdCall;
static int     UseLCaseTbl;
static char    Var[65535];
static int     XitCount;
static char    Z[65535];
static char    ConstLastDef[65535];
static int     Use_AnsiToWide;
static int     Use_Asc;
static int     Use_AppExeName;
static int     Use_AppExePath;
static int     Use_Boolstr;
static int     Use_Bor;
static int     Use_Band;
static int     Use_Bnot;
static int     Use_BcxSplitPath;
static int     Use_Bin;
static int     Use_Bin2dec;
static int     Use_Osx;
static int     Use_Cvd;
static int     Use_Cvld;
static int     Use_Cvi;
static int     Use_Cvl;
static int     Use_Cvs;
static int     Use_Chr;
static int     Use_Cdbl;
static int     Use_Cldbl;
static int     Use_Csng;
static int     Use_Clear;
static int     Use_Cbool;
static int     Use_Cint;
static int     Use_Clng;
static int     Use_Cls;
static int     Use_Color;
static int     Use_Command;
static int     Use_ContainedIn;
static int     Use_Console;
static int     Use_CopyFile;
static int     Use_Static;
static int     Use_Crlf;
static int     Use_Curdir;
static int     Use_Del;
static int     Use_Download;
static int     Use_Dynacall;
static int     Use_DynamicA;
static int     Use_Embed;
static int     Use_Enclose;
static int     Use_Environ;
static int     Use_EnumFile;
static int     Use_Eof;
static int     Use_Exist;
static int     Use_ExitCode;
static int     Use_Extract;
static int     Use_LoadFile;
static int     Use_FillArray;
static int     Use_Findfirst;
static int     Use_Findnext;
static int     Use_FindInType;
static int     Use_Fint;
static int     Use_Fix;
static int     Use_FileLocked;
static int     Use_Frac;
static int     Use_Fracl;
static int     Use_Freefile;
static int     Use_Get;
static int     Use_GetCh;
static int     Use_GenFree;
static int     Use_Gosub;
static int     Use_Gtk;
static int     Use_Glib;
static int     Use_Hex;
static int     Use_Hex2Dec;
static int     Use_Iif;
static int     Use_Imod;
static int     Use_Inkey;
static int     Use_InkeyD;
static int     Use_Ins;
static int     Use_Instr;
static int     Use_Inchr;
static int     Use_Isptr;
static int     Use_iReplace;
static int     Use_IRemove;
static int     Use_Instrrev;
static int     Use_Join;
static int     Use_Keypress;
static int     Use_Lcase;
static int     Use_Ldouble;
static int     Use_Left;
static int     Use_Like;
static int     Use_Lineinput;
static int     Use_Loc;
static int     Use_Locate;
static int     Use_Lof;
static int     Use_Lpad;
static int     Use_Ltrim;
static int     Use_Mcase;
static int     Use_Mid;
static int     Use_Midstr;
static int     Use_Mkd;
static int     Use_Mkld;
static int     Use_Mki;
static int     Use_Mkl;
static int     Use_Mks;
static int     Use_Min;
static int     Use_Max;
static int     Use_Now;
static int     Use_Numqsortdint;
static int     Use_Numqsortaint;
static int     Use_Numqsortdfloat;
static int     Use_Numqsortafloat;
static int     Use_Numqsortddouble;
static int     Use_Numqsortadouble;
static int     Use_Idxqsort;
static int     Use_IdxqsortSt;
static int     Use_PtrqsortSt;
static int     Use_Oct;
static int     Use_Overloaded;
static int     Use_OSVersion;
static int     Use_Pause;
static int     Use_PeekStr;
static int     Use_Put;
static int     Use_QBColor;
static int     Use_Randomize;
static int     Use_Rec;
static int     Use_RecCount;
static int     Use_Remain;
static int     Use_Remove;
static int     Use_Repeat;
static int     Use_Replace;
static int     Use_Reverse;
static int     Use_Right;
static int     Use_Rpad;
static int     Use_Rnd;
static int     Use_Exp;
static int     Use_Retain;
static int     Use_Round;
static int     Use_Rtrim;
static int     Use_Run;
static int     Use_Scan;
static int     Use_Inputbuffer;
static int     Use_SearchPath;
static int     Use_StrUpLow;
static int     Use_Shell;
static int     Use_Sgn;
static int     Use_SingleFile;
static int     Use_Space;
static int     Use_Split;
static int     Use_DSplit;
static int     Use_StartupCode;
static int     Use_Stristr;
static int     Use_StrStr;
static int     Use_Str;
static int     Use_Strl;
static int     Use_Str_Cmp;
static int     Use_Strim;
static int     Use_String;
static int     Use_Strptr;
static int     Use_Strqsorta;
static int     Use_Strqsortd;
static int     Use_Strtoken;
static int     Use_DynStrqsorta;
static int     Use_DynStrqsortd;
static int     Use_Swap;
static int     Use_Sysdir;
static int     Use_SysStr;
static int     Use_sziif;
static int     Use_Tally;
static int     Use_Tempdir;
static int     Use_TempFileName;
static int     Use_Threads;
static int     Use_Time;
static int     Use_Timer;
static int     Use_Trim;
static int     Use_Turbo;
static int     Use_Ubound;
static int     Use_Ucase;
static int     Use_Using;
static int     Use_VChr;
static int     Use_Verify;
static int     Use_Val;
static int     Use_Vall;
static int     Use_WideToAnsi;
static int     Use_Wx;
static int     Use_WxC;
static int     Use_Ctor;
static int     Use_Instat;
static int     Use_Socket;
static int     Use_IOS;
static int     Use_RegEx;
static int     Use_BEL;
static int     Use_BS;
static int     Use_CR;
static int     Use_DDQ;
static int     Use_DQ;
static int     Use_EOF;
static int     Use_ESC;
static int     Use_FF;
static int     Use_LF;
static int     Use_NUL;
static int     Use_SPC;
static int     Use_TAB;
static int     Use_VT;
static char    prcFile[65535];
static char    udtFile[65535];
static char    datFile[65535];
static char    cstFile[65535];
static char    ovrFile[65535];
static char    hdrFile[65535];
static char    setFile[65535];
static char    enuFile[65535];
static char    *szTmp;
static char    *Src;
static char    *AbortSrc;
static char    *WarnMsg;
static char    *RmLibs;
static FILE   *SourceFile;
static FILE   *FP2;
static FILE   *FP3;
static FILE   *FP4;
static FILE   *FP5;
static FILE   *FP6;
static FILE   *FP7;
static FILE   *FP8;
static FILE   *FP9;
static FILE   *FP11;
static FILE   *Outfile;
static FILE   *FP1;
static int     DoCountLines;
static FILE   *FP10;
static FILE   *ResIn;
static FILE   *ResOut;
static FILE   *UserResIn;
static FILE   *fpErr;
static FILE   *fpHFile;
static FILE   *FP68;
static FILE   *fpdef;
static int     SFPOINTER;
static int     WithCnt;
static char    ByrefVars[1024][65535];
static int     LoopLocalVar[256];
static int     BaseTypeDefsCnt[16];
static char    Modules[256][65535];
static int     ModuleLineNos[256];
static FILE   *FPtr[256];
static char    Stk[4096][65535];
static ProtoStore ProtoType[1024];
static char    SrcStk[128][65535];
static char    SplitStk[128][65535];
static char    CaseStk[256][65535];
static int     CaseElseFlag[256];
static char    Entry[256][65535];
static char    Xit[256][65535];
static char    LocalDynArrName[256][65535];
static char    GlobalDynaStr[256][65535];
static char    DynaStr[256][65535];
static char    StartSub[32][65535];
static char    ExitSub[32][65535];
static char    Library[MaxLib][65535];
static int     GlobalVarHash[MaxGlobalVars];
static VarInfo GlobalVars[MaxGlobalVars];
static VarInfo LocalVars[MaxLocalVars];
static UserTypeDefs TypeDefs[MaxTypes];
static char    DllDecl[800][512];
static char    Loadlibs[128][512];
static char    HFiles[128][65535];
static char    TypeName[16][65535];
static char    WithVar[8][65535];



// *************************************************
//               Standard Macros
// *************************************************

#define FDRV   2
#define FPATH  4
#define FNAME  8
#define FEXT  16
#define BAND &
#define BOR |
#define imod(a,b)((a)%(b))
#define VAL(a)(double)atof(a)


// *************************************************
//               Standard Prototypes
// *************************************************

int     str_cmp(char*, char*);
int     EoF (FILE*);
void    cls(void);
void    locate (int,int,int=1,int=12);
void    midstr (char*, int, int, char *);
char*   BCX_TmpStr(size_t);
char*   sziif (bool,char*,char*);
char*   TempFileName (char*,char*);
char*   AppExePath (void);
char*   AppExeName (void);
char*   lcase (char*);
char*   ucase (char*);
char*   mid (char*, int, int=-1);
char*   ltrim (char*,char=32);
char*   rtrim (char*,char=32);
char*   trim (char*);
char*   strim   (char*);
char*   left (char*,int);
char*   right (char*,int);
char*   rpad (char*,int,int=32);
char*   lpad (char*,int,int=32);
char*   stringx (int,int);
char*   extract (char*,char*);
char*   remain (char*,char*);
char*   command (int=-1);
char*   replace (char*,char*,char*);
char*   iReplace (char*,char*,char*);
void    Shell (char *);
char*   space (int a);
char*   str (double);
char*   curdir (void);
char*   tempdir (void);
char*   Environ (char*);
char*   _strupr_(char *);
char*   _strlwr_(char *);
char*   BcxSplitPath (char *, int);
void    _splitpath_(const char* path, char* drv, char* dir, char* name, char* ext);
char*   StrToken (char*,char*,int);
char*   RemoveStr (char*,char*);
char*   IRemoveStr (char*,char*);
char*   join (int, ... );
char*   enc (char*, int=0, int=0);
char*   chr(int,int=0,int=0,int=0,int=0,int=0,int=0,int=0,int=0,int=0);
char*   vchr (int,...);
int     InstrRev (char*,char*,int=0,int=0);
int     instr_b(char*,char*,int=0,int=0);
char    *MakeLCaseTbl(void);
char    *_stristr_(char*,char*);
char    *_strstr_(char*,char*);
int     inchr (char*,char*);
int     tally (char*,char*,int=0);
BOOL    Exist   (char*);
char*   ins (char *S, int i, char *a);
char*   del (char*,int,int);
DWORD   lof (char*);
double  Round (double,int);
float   rnd (void);
double  _MIN_ (double,double);
double  _MAX_ (double,double);
int     containedin(char * ,char **,int=0);

// *************************************************
//               User Prototypes
// *************************************************

int     main (int, PCHAR* );
void    EmitCmdLineConst (void);
void    EmitCompilerDefines (void);
void    MakeFreeGlobals (void);
void    ProcessSetCommand (int);
int     Directives (void);
int     SubVarType (int);
char    * PrintWriteFormat (int);
void    EmitInputCode (void);
void    EmitFileInputCode (void);
void    AddFuncs (void);
int     CheckLocal (char *, int* );
int     CheckGlobal (char *, int* );
int     CheckType (char *);
void    ExportInternalConst (void);
int     RestrictedWords (char *);
int     DataType (char *);
void    CloseAll (void);
char    * Clean (char *);
void    RemoveAll (char* ,char* ,int=0);
void    Warning (char* ,int=0);
PCHAR   GetVarTypeName (int);
int     HashNumber (char *);
void    AddLibrary (char *);
void    RemoveLibrary (char *);
void    EmitLibs (void);
void    AddGlobal (char* ,int,int,char* ,int,int,int,int,int=0);
void    AddLocal (char* ,int,int,char* ,int,int,int,int=0);
int     IsNumber (char *);
int     IsNumberEx (char *);
void    StripTabs (void);
void    PushFileIO (void);
void    PopFileIO (void);
int     Inset (char *, char *);
void    CheckParQuotes (void);
void    ClearIfThenStacks (void);
int     IsQuoted (char *);
void    PostProcess (void);
void    XParse (char *);
void    TokenSubstitutions (void);
void    JoinStrings (int, int);
void    Transforms (void);
void    Parse (char *);
void    FuncSubDecs1 (char *);
void    RemEmptyTokens (void);
void    FuncSubDecs2 (char *, int);
void    FuncSubDecs3 (VARCODE* );
void    AddTypeDefs (char *, int);
int     DefsID (char *);
void    GetTypeInfo (char *, int* , int* , int* );
void    AddTypedefElement (int, int, char *, char *, int);
char    * GetElement (int, int* , int* , int);
int     GetElementInfo (int* , int* , char *);
void    HandleNonsense (void);
void    ValidVar (char *);
void    PointerFix (void);
void    DimDynaString (char *, int, int);
int     SubFuncTest (void);
int     DimSubFunc (int);
void    Emit (void);
void    Abort (char *);
void    BumpDown (void);
void    BumpUp (void);
int     BraceCount (char *);
char*   BracketHandler (char *, int);
void    Push (char *);
void    Pop (char *);
void    EmitEpilog (void);
void    EmitProlog (void);
void    DeclareVariables (void);
int     GetNumArgs (int,int* =NULL);
void    GetVarCode (VARCODE* );
void    AddProtos (void);
void    RunTimeFunctions (void);
int     JoinLines (char *);
void    StripCode (char *);
void    ProcSingleLineIf (int* );
int     SplitLines (char *);
int     iMatch (char *, char *, int);
int     iMatchNQ (char *, char *);
int     SpecialCaseHandler (char *);
void    FastLexer (char* ,char* ,char* ,int=1);
void    InsertTokens (int, int, ...);
void    EmitExportDef (char *);
char    * GetArg (int, functionParse* );
int     SepFuncArgs (int, functionParse* , int);
PCHAR   MakeDecProto (functionParse* );
void    AsmUnknownStructs (int);
void    EmitIfCond (char *);
void    PrintGlobal (int, int, char *, char *, char *, char *);
void    ReDirectFPrint (FILE*, char *, ...);
int     IsReservedWord (char *);
int     GetAsPos (void);
void    FreeGlobals (void);


// *************************************************
//            User Global Initialized Arrays
// *************************************************


// *************************************************
//              User GLOBAL SET Statements
// *************************************************

static char* VarTypeLookup[]=
{
  "int","int","char *","double","float","FILE *","long double"
};

static char VarConst[2][8]=
{
  "",
  "const "
};

static char VarStorage[6][18]=
{
  "static ",
  "extern ",
  "",
  "static volatile ",
  "extern volatile ",
  "volatile "
};

static char* ReservedWord[]=
{
  "IF",
  "ELSEIF",
  "THEN",
  "ELSE",
  "AND",
  "OR",
  "NOT",
  "BOR",
  "BAND",
  "XOR",
  ""
};


// *******************************************************************************
// Developer Guidelines
// *******************************************************************************
// Code should be written in BCX Basic. If it can not be written in BCX Basic for
// some reason or results in code that seems too inefficient then this may be a
// cue that a new Basic function is needed.
// * All KEYWORDS should be capitalized
// * Use two space indentation
// * Use spaces not tabs
// * Record all notes in reverse chronological order
// * And most importantly....Have fun!
// ******************************************************************************************
// This section is used to communicate to-do 's, changes, ideas, suggestions, etc.
// ******************************************************************************************
// -------------------------------------------
// 2022-07-26 Armando Rivera
// After a LONG time away....
//   * Changed max size of szTmp$, Src$, and AbortSrc$ (65535)to avoid potential buffer overflows
//   * Changed max size of WarnMsg$ (65536) to avoid potential buffer overflow
//   * Removed the "register" decorator from EOF function to comply with C++17 standard
//   * The above addressed warnings thrown by C++17, which is the standard on modern Linux.
//   * Removed cdecl/stdcall from "Declare Function" (dynamic linking), since cdecl is the standard on *nix systems
// -------------------------------------------
// 2018-12-12 Armando Rivera
//   * Changed BcxRegEx function to REGMATCH
//   * Changed BcxRegEx keyword to REGMATCH
//   * Added $MODULE as alias to $INCLUDE to support external modules.  ** MUST BE AT TOP OF MAIN SOURCE FILE **
//   * Added $LDFLAGS directive to support external modules
// -------------------------------------------
// -------------------------------------------
// 2016-02-15 Armando Rivera
// -------------------------------------------
//   * Changed default string size to 65K from 
//     2k, which was limiting.
//   * Updated output of PRINT command, eliminating
//     leading spaces from numbers.
// -------------------------------------------
// 2015-07-03 Armando Rivera
// -------------------------------------------
//   * Changed $OSX flag to use Cocoa instead of Carbon in MacOS
//     This is in preparation of the new custom libcocoa library
//     that I'm currently creating that will allow mbc
//     to create 64bit GUI applications in OSX
// -------------------------------------------
// 2013-06-26 Armando Rivera
// -------------------------------------------
//   * Added BcxRegex keyword, based on Posix Regex in Libc
//   * Broke up main source file into files containing Runtime, Declarations, etc.
//   * Added BYTE type
// 
// -------------------------------------------
// 2013-06-17 Armando Rivera
// -------------------------------------------
//   * Tweaked HEX$ so that it will emit 2-digit hex numbers
//   * Added PUCHAR (unsigned char*) typedef
// -------------------------------------------
// 2011-03-11 Armando Rivera
// -------------------------------------------
//   * Added Wayne's suggestion to support Reference Variables as return types.
// 
// -------------------------------------------
// 2011-03-10 Armando Rivera
// -------------------------------------------
//   * Ported $PROJECT directive from ConsoleBC.  This doesn't emit the RTL yet, but it's a start.
//     It's the first step towards re-writing the RT code to leverage CPP/WX.
// 
//   * Fixed bug where BCX_TmpStr sometimes wasn't emitted when returning a string from a function
// 
//   * Added Named Enum support.  Syntax:
//       myenum AS ENUM
//       …
//       END ENUM
// 
//       This required moving the Enum emit code to before the User Prototype emit code
//       to allow passing the named enum to user defined functions.
// 
// -------------------------------------------
// 2011-01-23 Armando Rivera
// -------------------------------------------
//   * Initial Beta1 Release
// 
//   * Fixed bug in INPUT statement to remove trailing newlines (James Fuller)
// 
//   * Removed COLOR statements to avoid terminal output issues with redirected
//     translator output (James Fuller)
// 
//   * Added CONST keyword when declaring variables (Global, Local, and as Function/Sub parameters)
//     At the moment, this is experimental (meaning I haven't fully tested it) but it seems to work
// 
//   * Added PRIVATE keyword for CPP classes
// -------------------------------------------
// 2010/12/21  Armando Rivera
// -------------------------------------------
//   * Cleaned up code emission so that unneeded defines/global vars are not emitted
// 
//   * Added new $IOS directive, which is MAC ONLY, to compile source for iDevices (iPhone/iTouch/AppleTV2)
//     At this point in time, running binaries built this way requires a jailbroken iDevice.
//     This is experimental, and for console apps only for now.
//     A simple console example is in the Examples/IOS folder
// -------------------------------------------
// 2010/12/11  Armando Rivera
// -------------------------------------------
//  * Add new Socket keywords: BcxSocket, BcxSocketSend, BcxSocketRead, and BcxSocketClose
//   See the BcxSocket.bas demo in the Examples/Socket folder for info.
// 
//  * Added kbhit() , which doesn't exist outside of Windows
//   This is a custom sub which emulates what kbhit() does
// 
//  * Changed the conditional emission of term.h to only be emitted when
//   Use_Keypress is TRUE (InKey)
// 
// -------------------------------------------
// 2010/12/01  Armando Rivera
// -------------------------------------------
//  * Changed wxApp emission to use BCXPLITHPATH$, per James Fuller's suggestion.
// 
//  * Added support for Abstract Classes (gcc doesn't have the INTERFACE keyword)
// 
//   Example:
//    Class MyAbstractClass
//     public
// 
//      virtual sub Proc1() = 0
//      Virtual sub Proc2()=0
//      virtual function Proc3(a$,b$) as integer = 0
// 
//    End Class
// -------------------------------------------
// 2010/11/30  Armando Rivera
// -------------------------------------------
//  * Removed $CLASS/$ENDCLASS $NAMESPACE/$ENDNAMESPACE
//   Using either will emit a message stating that they have been replaced.
// 
//  * Addded NAMESPACE / END NAMESPACE
//   This allows creating methods within the NAMESPACE like so:
// 
//   $CPP
//   $NOMAIN
//   $EXECON
//   '==============================================================================
//   NAMESPACE Dlg_01
//    Sub DoIt()
//     Print "Dlg_01"
//    End Sub
// 
//    Function GetString$(A$) as string
//     function = "The String you Passed Was: " + enc$(A$)
//    end function
//   END NAMESPACE
//   '==============================================================================
//   Function main(argc as INTEGER, argv as PCHAR ptr) as INTEGER
//    Print "James"
//    Dlg_01::DoIt()
//    print Dlg_01::GetString$("Hello, World!")
//   End Function
// 
//   * If using $WX, the #define for Clear() will not be emitted due to conflict
//     with Classes that have that method defined
// 
//   * Made the inclusion of "term.h" conditional based on whether $WX/$WXC
//     is used.  "term.h" is required for the implementation of
//     the PAUSE keyword in CONSOLE apps.
// 
// -------------------------------------------
// 2010/11/25  Armando Rivera
// -------------------------------------------
//   * Changed code so that in $CPP mode, the case of the emitted
//     .cpp filename is preserved (James Fuller bug report)
// 
// -------------------------------------------
// 2010/11/24  Armando Rivera
// -------------------------------------------
//   * Minor change in StripCode() to correct
//     possible overflow issue under 64bit Linux (James Fuller bug report)
// 
//   * Added $WXC Directive to support WX Console-Based Apps
//     Using this switch, neither a wxApp or the IMPLEMENT_APP() macro are
//     auto added to the translated source (James Fuller request)
// -------------------------------------------
// 2010/11/20  Armando Rivera
// -------------------------------------------
//  * Changed $DLL directive so that it would generate *nix Shared Libraries.
//  * Added $DLL support to $EXECON
//  * Added required flags to LD_FLAGS$ for creating *nix Shared Libraries
//   Example:
//    $dll
//    $execon
// 
//    function printdemo() export
//     print "This was called from a Dynamic Library"
//    end function
// 
//   Note that this is currently only useful for creating shared libraries
//   for **OTHER** languages; it won't work with MBC created apps because of
//   duplicate naming conflicts.
// 
// -------------------------------------------
// 2010/11/18  Armando Rivera
// -------------------------------------------
//   * Removed "-Os" compiler optimization flag from $EXECON for fastest tranlator compliation
//     during Alpha testing stage.
// 
//     This will be re-added when translator is not longer in Alpha status
// 
//   * Added USE_CTOR global as flag for supporting Constructor/Destructor syntax
// 
//   * Added "USING" keyword for CONSTRUCTOR/DESTRUCTOR methods.  It is used like this:
// 
//       CONSTRUCTOR MainWin::MainWin(title as wxString, winStyle as long) USING wxFrame( 0, -1, title, wxPoint(50,50), wxSize(490,296), winStyle )
// 
//     Which will emit:
// 
//       MainWin::MainWin (wxString title, long winStyle)
//       : wxFrame( 0, -1, title, wxPoint(50,50), wxSize(490,296), winStyle )
//       {
// 
//   * Added code to extract and emit derived class methods
// 
// -------------------------------------------
// 2010/11/17  Armando Rivera
// -------------------------------------------
//   * Added new CLASS / END CLASS / PUBLIC / PROTECTED / CONSTRUCTOR / DESTRUCTOR keywords.
//     These additions flesh out Basic-Like C++ CLASS support, superceding $CLASS/$ENDCLASS,
//     and now allows syntax like the following:
// 
//         $CPP
//         $NOMAIN
//         $execon
// 
//         class MyClass
// 
//          protected
//           first as string
//           secnd$
//           third%
// 
//          public
//           type ATest
//            a as PCHAR
//            b as long
//            c as single
//            d as float
//           end type
// 
//          Constructor MyClass(a$, b)
//          Destructor MyClass()
//         end class
// 
//         FUNCTION main(argc as INTEGER, argv as PCHAR ptr) as INTEGER
//           RAW theClass as MyClass PTR
// 
//           theClass = new MyClass("Hello", 12)
// 
//           print (char*)theClass->ATest.a
//           print theClass->ATest.b
//         END FUNCTION
// 
//         Constructor MyClass::MyClass(a$,b)
//           ATest.a = a$
//           ATest.b = b
//         END Constructor
//         '
//         Destructor MyClass::~MyClass()
// 
//         END Destructor
// 
// -------------------------------------------
// 2010/11/12  Armando Rivera
// -------------------------------------------
//   * Added code that (mostly) eliminates the need for a trailing ";" in $class/$endclass
// 
//   * Added code to allow the use of "SUB" in $class/$endclass.  It just substitutes "void" for "sub"
//     at this point.
// 
//   * Fixed "THIS" keyword code so that it emits a lowercase "this".  Linux/OSX aren't affected
//     by this breaking COM statements. :-P  Thanks to JCFULLER for the tip!
// 
//   * For $CPP mode, added typedefs for std::string (CSTRING) and std::fstream (CFILE)
//     These are direct replacements for STRING and FILE, and allows the full use of each
//     C++ object/class.
// 
//     So instead of "dim mystring as string", for example, you would do "dim mystring as CSTRING".
//     You would then have access to all of std::string's methods like .replace, .substr, .compare, etc.
// 
//     I'm considering doing the same with the other toolkit directives ($OSX, $GTK, etc) but we'll see...
// 
//   * Added "inherits" in $CPP mode so that subclassing can be done like so:
// 
//     $class MyClass inherits AnotherClass
// 
//   * For $WX mode, added code to automatically emit the required derived wxApp class.
//    Note that it will be named the same as your sourcefile (minus the extension), and you MUST provide
//    a "FUNCTION ::OnInit() as bool" for it:
// 
//     FUNCTION TestApp::OnInit() as bool
//      <initialize app here>
//     END FUNCTION
// 
//   * For $WX mode, made "$NOMAIN" the default, so no need to pass that directive
// 
//   * Colorized some of the compiler output text.  Just because I can.
// 
//   * Back-ported Wayne's changes to "WITH" to allow the use of "->" syntax
// 
//   * TODO:
//       Finish off the $class/$endclass code to allow full basic syntax for method and variable
//       declarations.
// 
//       Remove ALL remaining WIN32 related code and ifdefs.
//       No need for that stuff under Linux/OSX, the Windows version of BCX can handle all
//       of the Windows stuff one might need.
// 
//       Other stuff I can't remember right now…..
// -------------------------------------------
// 2010/03/31  Armando Rivera
// Beginning with this version of the console compiler,
// the goal is to have a 100% unified code-base, because
// I'm fracking tired of trying to maintain separate builds
// for different Operating Systems.
// -------------------------------------------
// 
//   * Added $OSX, $GTK¸$GLIB and $WX Directives
//     (Use_Osx, Use_Wx, Use_Gtk, Use_Glib and LD_FLAGS$ Globals added)
// 
//     $OSX will automatically enable Carbon GUI support, and if $EXECON is invoked
//     will also build a Universal Binary with 32bit and 64bit support
// 
//     $GTK will automatically enable GTK/GLIB support, and if $EXECON is invoked
//     will build the executable linking in libgtk and it's support libraries.
// 
//     $GLIB will automatically enable >GLIB ONLY< support, and if $EXECON is invoked
//     will build the executable linking in libglib and it's support libraries.
// 
//     $WX will automatically enable wxWidgets with $CPP set to "TRUE", and if $EXECON
//     is invoked will build the executable linking in libwx and it's support libraries
// 
//     This is, in part, in preparation for moving the GTK support from the core of the
//     LinuxBC translator to an external library which will be linked in as required.  This
//     will GREATLY simplify maintenence of the translator core once the lib  is ready.
// 
//   * Changed alls instances of byte* to UCHAR* in SWAP() Function
// 
//   * Added internal return values for PUT/GET to get rid of ALL compiler warnings.
// 
//   * Updated runtime functions calling PUT()/GET()/fread()/fwrite  so that they
//     will not trigger compiler warnings
// 
//   * Reworked the way functions declared using C_DECLARE with the LIB and ALIAS keywords
//     are emitted.  This is so that you can dynamically load functions from a shared
//     library at runtime via dlopen/dlsym.
// 
//     The syntax is:
//     C_DECLARE FUNCTION <YOUR FUNCTION NAME> LIB <shared library> ALIAS <quoted name of actual function (<parameters>) AS <return type>
// 
//     For example:
//     C_DECLARE FUNCTION b64encode LIB "libglib-2.0.so" ALIAS "g_base64_encode" (txt AS char*, length AS integer) AS string
//     C_DECLARE FUNCTION g_base64_decode LIB "libglib-2.0.so" ALIAS "g_base64_decode" (txt AS char*, length AS INTEGER PTR) AS string
// 
//     NOTE that the ALIAS is the actual name of the function you want to call from the shared library.
//     This is so you avoid redeclaration errors if you attempt to link to a library (libm is a good example)
//     that is already compile-time linked with g++.
// 
//     NOTE 2: There is currently no checking whether the function was loaded without error.  It is on the TODO list.
// 
//   * Changed compiler invocation to include -Wformat and -D_FORTIFY_SOURCE=2 (Ubuntu Standard)
// 
//   * Fixed User Include File handling in order to support mixed case filenames
// 
//   * Updated the CURDIR$, TEMPDIR$, AND SHELL code to eliminate warnings emitted when compiling on
//     a system that has "_FORTIFY_SOURCE=2" enabled by default in GCC/G++ (Ubuntu)
// 
//   * Fixed a potential overflow problem with LINE INPUT that would also cause G++ to emit
//      warnings as above.
// 
//   *Re-coded the $RESOURCE directive and the GETRESOURCE$ function to allow
//    linking of Resources under Linux/Unix.  Using $RESOURCE generates a #define
//    allowing you to reference the embedded resource using an arbitrary IDENTIFIER.
// 
//   For example:
// 
//     DIRECTIVE    FILE    IDENTIFIER
//     -------------------------------
//     $RESOURCE "file.txt"  "myres"
// 
// 
//   Note that you reference the resource using the identifier you passed as the
//   SECOND parameter to the $RESOURCE directive, minus the quotes.
// 
//   "file.txt" above can be any arbitrary file on one's system
// 
//   At the moment, the resource is returned as a string with the GETRESOURCE$ function.
//   *****************************************************************************************************
//   ** YOU WILL HAVE TO ENSURE THAT A BUFFER WITH ENOUGH SPACE TO HOLD THE RESOURCE HAS BEEN ALLOCATED **
//   *****************************************************************************************************
//   To aid in this, a constant is automatically created with the size of the resource.  It will have the
//   name you specified as the second parameter to $RESOURCE, with _SIZE appended.
//   Using the example above, the constant would be defined as: myres_SIZE
// 
// 
//   You should be able to manually cast the reference *itself* to what you require, since it is
//   merely a pointer to the location of the resource itself.
// 
//   The resource will be converted to an object file, named using the filename provided with ".o" apppended.
//   "file.txt" will be converted to "file.txt.o" in the above example, which can then be linked
//   to the final executable via $EXECON "file.txt.o" or $EXEGUI "file.txt.o"
// 
//   * Tweaked $GUI directive and GUI keyword so that one can use the directive without
//   having all of the support for BCX_* form objects automatically added to one's app.
// 
//   This is usefull when using GtkBuilder or Glade to build the user interface.
// 
// -------------------------------------------
// 2010-01-17 Armando Rivera
// -------------------------------------------
//   modified the $CLASS/$ENDCLASS directives to allow creation and inheritance of C++ Classes
// 
//   modified the Function/Sub prototype emitter so that it would not emit prototypes
//     for C++ Class Methods, which are supposed to be prototyped within the Class itself
// 
//   made the inclusion of <term.h> conditional based on whether UseCPP is true/false
//     it will not be included if UseCpp is "true" because some C++ toolkits (wxWidgets)
//     throw a "redefined" error when it's included
// 
// -------------------------------------------
// 2010-01-15 Armando Rivera
// -------------------------------------------
//   per wmhalsdorf's recommendation, modified SplitLines and Emit procs to support
//     C++ Method syntax (CLASSNAME::METHOD) [see Yahoo group Message #40282]
// 
// -------------------------------------------
// 2010-01-10 Armando Rivera
// -------------------------------------------
//   changed $CPP directive to output lowercase filenames
// 
// -------------------------------------------
// 2009-10-18 Armando Rivera
// -------------------------------------------
//   added Carbon.h as a default include, to support Carbon/CoreFoundation calls
//   added Carbon framework to $execon section
//   removed TRUE and FALSE defines, which are now provided by Carbon.h
//   changed Handle$ to Handl$ to resolve conflict with Carbon.h
// 
// -------------------------------------------
// 2009-10-13 Armando Rivera
// -------------------------------------------
//   added typedef for "byte" type (typedef unsigned char byte;)
// 

// *************************************************
//                 Runtime Functions
// *************************************************

char *BCX_TmpStr (size_t Bites)
{
  static int   StrCnt;
  static char *StrFunc[512];
  StrCnt=((StrCnt+1) &511);
    #if defined BCX_MAX_VAR_SIZE
  if(Bites*sizeof(char)>BCX_MAX_VAR_SIZE)
  {
  printf("Buffer Overflow caught in BCX_TmpStr - requested space of %d EXCEEDS %d\n",(int)(Bites*sizeof(char)),BCX_MAX_VAR_SIZE);
  abort();
  }
  #endif
  StrFunc[StrCnt]=(char*)realloc(StrFunc[StrCnt],Bites + 128);
  return (char*)memset(StrFunc[StrCnt],0,Bites+128);
}


int str_cmp (char *a, char *b)
{
  int counter=0;
  for(;;)
   {
    if((a[counter]^b[counter]))
     {
      if((UINT) a[counter]>= (UINT) b[counter])
      return  1;
      return -1;
     }
    if(!a[counter]) return 0;
    counter++;
   }
}


int EoF (FILE* stream)
{
  int c, status = ((c = fgetc(stream)) == EOF);
  ungetc(c,stream);
  return status;
}


char *left (char *S, int length)
{
  int tmplen = strlen(S);
  if(length<1) return BCX_TmpStr(1);
  if(length<tmplen) tmplen=length;
  char *strtmp = BCX_TmpStr(tmplen);
  return (char*)memcpy(strtmp,S,tmplen);
}


char *right (char *S, int length)
{
  int tmplen = strlen(S);
  char *BCX_RetStr = BCX_TmpStr(tmplen);
  tmplen -= length;
  if (tmplen<0) tmplen = 0;
  return strcpy(BCX_RetStr, &S[tmplen]);
}


char *rpad (char *a, int L, int c)
{
  char *strtmp;
  int s = strlen(a);
  if((L-s)<1) return a;
  strtmp=BCX_TmpStr(L);
  strcpy(strtmp,a);
  memset(&strtmp[s],c,(L-s));
  return strtmp;
}


char *lpad (char *a, int L, int c)
{
  char *strtmp;
  L=L-strlen(a);
  if(L<1) return a;
  strtmp = BCX_TmpStr(L);
  memset(strtmp,c,L);
  return strcat(strtmp,a);
}


char *mid (char *S, int start, int length)
{
  char *strtmp;
  int tmplen = strlen(S);
  if(start>tmplen||start<1) return BCX_TmpStr(1);
  if (length<0 || length>(tmplen-start)+1)
    length = (tmplen-start)+1;
  strtmp = BCX_TmpStr(length);
  return (char*)memcpy(strtmp,&S[start-1],length);
}


char *trim (char *S)
{
  while(*S==32 || *S==9 || *S==10 || *S==11 || *S==13)
    S++;
  int i = strlen(S);
  while( i>0 && (S[i-1]==32 || S[i-1]==9 || S[i-1]==10
             || S[i-1]==11 || S[i-1]==13))
    i--;
  char *strtmp=BCX_TmpStr(i);
  return (char*)memcpy(strtmp,S,i);
}


char *ltrim (char *S, char c)
{
  if(S[0]==0) return S;
  while((*S==32 || *S==c) && *S !=0) S++;
  char *strtmp = BCX_TmpStr(strlen(S));
  return strcpy(strtmp,S);
}


char *rtrim (char *S,char c)
{
  if(S[0]==0) return S;
  int i = strlen(S);
  while(i>0 && (S[i-1]==c || S[i-1]==32))
    i--;
  char *strtmp = BCX_TmpStr(i);
  return (char*)memcpy(strtmp,S,i);
}


char *strim (char *src)
{
  char *strtmp = BCX_TmpStr(strlen(src));
  char *dst = strtmp;
  while (isspace((unsigned char)*src)) src++;
  do
  {
    while (*src && !isspace((unsigned char)*src)) *dst++ = *src++;
    if (*src)
      {
        *dst++ = *src++;
        while (isspace((unsigned char)*src)) src++;
      }
  } while (*src);
  if (isspace((unsigned char)*(--dst))) *dst = 0;
  return strtmp;
}


char *command (int nArg)
 {
 int i = 0;
 char *retstr=BCX_TmpStr(1);
 if(nArg < i) // return entire commandline
    {
      retstr = BCX_TmpStr(G_argc * 2048);
      for(i=1; i < G_argc; i++)
         {
         strcat(retstr, G_argv[i]);
         strcat(retstr, SPC);
         }
    }
 else if(nArg < G_argc)
    {
      retstr = BCX_TmpStr(strlen(G_argv[nArg]) + 1);
      strcpy(retstr, G_argv[nArg]);
    }
 return retstr;
}


char *extract (char *mane, char *match)
{
  char *a;
  char *strtmp = BCX_TmpStr(strlen(mane));
  if(*match!=0)
    {
      a=_strstr_(mane,match);
      if(a) return (char*)memcpy(strtmp,mane,a-mane);
    }
  return strcpy(strtmp,mane);
}


char *remain (char *mane, char *mat)
{
  char *p = strstr(mane,mat);
  if(p)
  {
    p+=(strlen(mat));
    return p;
  }
  return mane;
}


char *replace (char *src, char *pat, char *rep)
{
  size_t patsz, repsz, tmpsz, delta;
  char *strtmp, *p, *q, *r;
  if (!pat || !*pat)
   {
     strtmp = BCX_TmpStr(strlen(src));
     if (!strtmp) return NULL;
     return strcpy(strtmp, src);
   }
  repsz = strlen(rep);
  patsz = strlen(pat);
  for (tmpsz=0, p=src; (q=_strstr_(p,pat))!=0; p=q+patsz)
   tmpsz += (size_t) (q - p) + repsz;
   tmpsz += strlen(p);
   strtmp = BCX_TmpStr(tmpsz);
   if (!strtmp) return NULL;
    for (r=strtmp,p=src; (q=_strstr_(p,pat))!=0;p=q+patsz)
     {
       delta = (size_t) (q-p);
       memcpy(r,p,delta); r += delta;
       strcpy(r,rep);      r += repsz;
     }
  strcpy(r,p);
  return strtmp;
}


char *ucase (char *S)
{
  char *strtmp = BCX_TmpStr(strlen(S));
  return _strupr_(strcpy(strtmp,S));
}


char *lcase (char *S)
{
  char *strtmp = BCX_TmpStr(strlen(S));
  return _strlwr_(strcpy(strtmp,S));
}


char *RemoveStr (char *a, char *b)
{
  char *strtmp, *p, *d;
  int  tmplen;
  strtmp = d = BCX_TmpStr(strlen(a));
  if(!b || !*b) return strcpy(strtmp,a);
  p=_strstr_(a,b); tmplen = strlen(b);
  while(p)
   {
     memcpy(d,a,p-a);
     d+= (p-a);
     a=p+tmplen;
     p=_strstr_(a,b);
   }
  strcpy(d,a);
  return strtmp;
}


char *IRemoveStr (char *a, char *b)
{
  char *strtmp, *p, *d;
  int  tmplen;
  strtmp = d = BCX_TmpStr(strlen(a));
  if(!b || !*b) return strcpy(strtmp,a);
  p=_stristr_(a,b); tmplen = strlen(b);
  while(p)
   {
     memcpy(d,a,p-a);
     d+= (p-a);
     a=p+tmplen;
     p=_stristr_(a,b);
   }
  strcpy(d,a);
  return strtmp;
}


char *ins (char *S, int i, char *a)
{
  int j = strlen(S);
  if(i<1 || i>j+1) return S;
  char *strtmp = BCX_TmpStr(j + strlen(a));
  memcpy(strtmp,S,--i);
  strcpy(&strtmp[i],a);
  return strcat(strtmp,&S[i]);
}


char *del (char *S, int i, int j)
{
  int ln = strlen(S);
  if(i<1 || i>ln) return S;
  char *strtmp = BCX_TmpStr(ln);
  memcpy(strtmp,S,--i);
  return strcat(strtmp,&S[i+j]);
}


char *str (double d)
{
  char *strtmp = BCX_TmpStr(16);
  sprintf(strtmp,"% .15G",d);
  return strtmp;
}


char *curdir (void)
{
  char *strtmp = BCX_TmpStr(2048);
  char *res=getcwd(strtmp, 1024);
  return strtmp;
}


char *tempdir (void)
{
  char *strtmp = BCX_TmpStr(2048);
  if(!Exist("/tmp/mbc.compiler")) {
    mkdir ("/tmp/mbc.compiler",0755);
  }
  strcpy(strtmp,"/tmp/mbc.compiler");
  return strtmp;
}


char *stringx (int count, int a)
{
  if(count<1) return BCX_TmpStr(1);
  char *strtmp = BCX_TmpStr(count);
  return (char*)memset(strtmp,a,count);
}


void Shell (char *cmd)
{
  int res=system(cmd);
}


char *space (int count)
{
  if(count<1) return BCX_TmpStr(1);
  char *strtmp = BCX_TmpStr(count);
  return (char*)memset(strtmp,32,count);
}


char *enc (char *A, int L, int R)
{
  char *BCX_RetStr = BCX_TmpStr(strlen(A)+3);
  if(L==0) L=34;
  if(R==0) R=L;
  sprintf(BCX_RetStr,"%c%s%c%s",L,A,R,"");
  return BCX_RetStr;
}


char *chr (int a,int b,int c,int d,int e,int f,int g,int h,int i,int j)
{
  char *strtmp = BCX_TmpStr(11);
  strtmp[0]  = a;
  strtmp[1]  = b;
  strtmp[2]  = c;
  strtmp[3]  = d;
  strtmp[4]  = e;
  strtmp[5]  = f;
  strtmp[6]  = g;
  strtmp[7]  = h;
  strtmp[8]  = i;
  strtmp[9]  = j;
  strtmp[10] = 0;
  return strtmp;
}


char *vchr(int charcount, ...)
{
  int c = 0, i = charcount;
  char *s_ = BCX_TmpStr(charcount + 1);
  va_list marker;
  s_[i] = 0;
  va_start(marker, charcount);
  while(i-- > 0) s_[c++] = va_arg(marker,int);
  va_end(marker);
  return s_;
}


char * join(int n, ...)
{
  int i = n, tmplen = 0;
  char *strtmp, *s_;

  va_list marker;
  va_start(marker, n); // Initialize variable arguments
  while(i-- > 0)
  {
    s_ = va_arg(marker, char *);
    if(s_) tmplen += strlen(s_);
  }
  strtmp = BCX_TmpStr(tmplen);
  va_end(marker); // Reset variable arguments
  i = n;
  va_start(marker, n); // Initialize variable arguments
  while(i-- > 0)
  {
    s_ = va_arg(marker, char *);
    if(s_) strcat(strtmp, s_);
  }
  va_end(marker); // Reset variable arguments
  return strtmp;
}


char* Environ(char *S)
{
  char *strtmp, *tmp;

  tmp = getenv(S);
  if(tmp != NULL) {
    strtmp = BCX_TmpStr(strlen(tmp)+1);
    return strcpy(strtmp, tmp);
  }
  return BCX_TmpStr(1);
}


char *AppExePath (void)
{
  char fullpath[MAX_PATH];
  int length;
  length = readlink("/proc/self/exe", fullpath, MAX_PATH);
  if(length < 1) return BCX_TmpStr(1);

  fullpath[length] = 0;
  return BcxSplitPath(fullpath, FDRV|FPATH);
}


char *AppExeName (void)
{
  return BcxSplitPath(G_argv[0], FNAME|FEXT);
}


char * TempFileName (char *dr, char *prefix)
{
  static unsigned int count;
  char *f, *tmpstr = BCX_TmpStr(MAX_PATH);
  int  i, length;

  if(!count) srand(time(0));

  if(dr) strcpy(tmpstr, dr);
  length = strlen(tmpstr);
  if(length && (tmpstr[length-1] != '\\' && tmpstr[length-1] != '/'))
      tmpstr[length++] = '/';
  if(prefix) strcpy(&tmpstr[length], prefix);
  f = &tmpstr[strlen(tmpstr)];

  do {
      count++;
      for(i=0; i<5; i+=1)
        {
          do {
            f[i]=(char)(rnd()*122);
          }while((f[i]<65)||(f[i]>90&&f[i]<97));
        }
        snprintf(&f[5],3,"%x", count);
    } while (Exist(tmpstr));

  return tmpstr;
}


int InstrRev (char *s, char *p, int os, int sens)
{
 int sl, pl, ox;
 int (*cmp)(const char *, const char *, size_t );

 if (!s || !p)  return 0;
 sl  = strlen(s); pl  = strlen(p);
 if (os > sl || sl == 0 || pl == 0 || (ox = sl - pl) < 0)
   return 0;

 if (os <= 0)  
   os = ox ;
 else if(os >= pl)
   os = os - pl ;
 else
   return 0;

 cmp = (sens ? strncasecmp : strncmp);
 do { if (cmp(s + os , p, pl) == 0)
       return os+1;
    } while (os--);
 return 0;
}


int instr_b(char* mane,char* match,int offset,int sensflag)
{
  char *s;
  if (!mane || !match || ! *match || offset>(int)strlen(mane)) return 0;
  if (sensflag)
    s = _stristr_(offset>0 ? mane+offset-1 : mane,match);
  else
    s = _strstr_(offset>0 ? mane+offset-1 : mane,match);
  return s ? (int)(s-mane)+1 : 0;
}


char  *MakeLCaseTbl (void)
{
  static char tbl[256];
  if(!tbl['a'])
    {
      int i; for (i=0; i < 256; i++)
        tbl[i] = (char)(int)tolower(i);
    }
  return tbl;
}


char *_stristr_(char *String, char *Pattern)
{
  int   mi=-1;
  char *LowCase = MakeLCaseTbl();
  while(Pattern[++mi])
   {
     if(String[mi]==0) return 0;
     if(LowCase[(unsigned char)String[mi]]!=LowCase[(unsigned char)Pattern[mi]])
       { String++; mi=-1; }
   }
  return String;
}


char *_strstr_(char *String, char *Pattern)
{
  int   mi=-1;
  while(Pattern[++mi])
   {
     if(String[mi]==0) return 0;
     if(String[mi]!=Pattern[mi])
       { String++; mi=-1; }
   }
  return String;
}


int inchr (char *A, char *B)
{
  char* C=A;
  while(*C)
    {
      if(*C==*B) return C-A+1;
      C++;
    }
  return 0;
}


double Round (double n, int d)
{
  return (floor((n)*pow(10.0,(d))+0.5)/pow(10.0,(d)));
}


bool Exist (char *szFilePath)
{
  int retstat;
  struct stat sb;
  retstat = stat(szFilePath, &sb);
  if(retstat != -1)
    return TRUE;
  return FALSE;
}


int tally (char *szLine, char *szChar, int sensflag)
{
  if(!*szChar) return 0;
  int   mlen = strlen(szChar);
  int  iCount = 0;
  char *p = (sensflag == 0 ? _strstr_(szLine, szChar) : _stristr_(szLine, szChar));
  while (p)
  {
    iCount++;
    p+=mlen;
 p = (sensflag == 0 ? _strstr_(p, szChar) : _stristr_(p, szChar));
  }
  return iCount;
}


float rnd (void)
{
  return (float)rand()/RAND_MAX;
}


double _MAX_ (double a, double b)
{
  if(a>b)
  return a;
  return b;
}


double _MIN_ (double a, double b)
{
  if(a<b)
  return a;
  return b;
}


void locate (int row,int col,int show,int shape)
{
  printf("%c%s%u%s%u%s",27,"[",row,";",col,"H");
  // find cursor size/shape function!
}


void cls (void)
{
  printf("%s%s%s%s",ESC,"[2J",ESC,"[H");
}


void midstr (char *src, int st, int length, char *rep)
{
  int srclen = strlen(src);
  if(st>srclen++ || st<1) return;
  int replen = strlen(rep);
  if(replen < length || length==-1) length=replen;
  if((st+length) > srclen) length=srclen-st;
  memcpy(&src[st-1],rep,length);
}


DWORD lof (char *FileName)
{

  int retstat;
  struct stat sb;
  retstat = stat(FileName, &sb);
  if(retstat != -1)
    return sb.st_size;
  return 0;
}


char * sziif (bool i, char *a, char *b)
{
  if(i) return a;
  return b;
}


char *BcxSplitPath (char *FPath, int mask)
{
  if(!FPath) return BCX_TmpStr(1);
  char *BCX_RetStr=BCX_TmpStr(strlen(FPath));
  char tmp[MAX_PATH*4];
  _splitpath_(FPath,tmp,&tmp[MAX_PATH],&tmp[MAX_PATH*2],&tmp[MAX_PATH*3]);
  if(mask & FDRV) strcat(BCX_RetStr,tmp);
  if(mask & FPATH)strcat(BCX_RetStr,&tmp[MAX_PATH]);
  if(mask & FNAME)strcat(BCX_RetStr,&tmp[MAX_PATH*2]);
  if(mask & FEXT) strcat(BCX_RetStr,&tmp[MAX_PATH*3]);
  return BCX_RetStr;
}


 void _splitpath_(const char* path, char* drv, char* dir, char* name, char* ext)
 {
     const char* pend; /* end of processed string */
     const char* p;   /* search pointer */
     const char* s;   /* copy pointer */
 
     /* extract drive name */
     if (path[0] && path[1]==':') {
         if (drv) {
             *drv++ = *path++;
             *drv++ = *path++;
             *drv = 0;
         }
     } else if (drv)
         *drv = 0;
 
     /* search for end of string or stream separator */
     for(pend=path; *pend && *pend!=':'; )
         pend++;
 
     /* search for begin of file extension */
     for(p=pend; p > path && *--p != '\\' && *p!='/'; )
         if (*p == '.') {
             pend = p;
             break;
         }
 
     if (ext)
     {
         s=pend;
         do{ *ext++ = *s; } while(*s++);
     }
     /* search for end of directory name */
     for(p=pend; p > path; )
         if (*--p == '\\' || *p == '/') {
             p++;
             break;
         }
 
     if (name) {
         for(s=p; s<pend; )
             *name++ = *s++;
 
         *name = 0;
     }
 
     if (dir) {
         for(s=path; s<p; )
             *dir++ = *s++;
 
         *dir = 0;
     }
 }

char *_strupr_(char *string)
{
   char *s;

   if (string)
   {
      for(s = string; *s; ++s)
         *s = toupper(*s);
   }
   return string;
}

char *_strlwr_(char *string)
{
    char *s;

    if (string)
    {
       for (s = string; *s; ++s)
           *s = tolower(*s);
    }
    return string;
}

char * StrToken (char *Source, char *TokenChar, int n)
{
  char *BCX_RetStr={0};
  char *RetVal;
  char *Copy;
  int   Posn=0;
  int   Find=0;
  int   LenSrc=strlen(Source);
  RetVal=(char*)calloc(LenSrc+1,1);
  Copy=Source;
  if(tally(Source,TokenChar)==0)
    {
      BCX_RetStr=BCX_TmpStr(1);
      if(RetVal)free(RetVal);
      return BCX_RetStr;
    }
  if(n==1)
    {
      BCX_RetStr=BCX_TmpStr(LenSrc);
      strcpy(BCX_RetStr,(char*)extract(Source,TokenChar));
      if(RetVal)free(RetVal);
      return BCX_RetStr;
    }
  if(n>tally(Source,TokenChar)+1)
    {
      BCX_RetStr=BCX_TmpStr(1);
      if(RetVal)free(RetVal);
      return BCX_RetStr;
    }
  while(*Copy)
    {
      if(*Copy==TokenChar[0]) Find++;
      if(Find==n) break;
      Copy++;
      Posn++;
    }
  if(n==tally(Source,TokenChar)+1)
    {
      Posn=LenSrc;
      Copy=Source+Posn;
      while(*Copy&&Source[Posn]!=TokenChar[0])
        {
          Posn--;
          Copy--;
        }
    }
  strcpy(RetVal,(char*)mid(Source,1,Posn));
  strcpy(RetVal,(char*)mid(RetVal,InstrRev(RetVal,TokenChar)));
  BCX_RetStr=BCX_TmpStr(LenSrc);
  strcpy(BCX_RetStr,(char*)RemoveStr(RetVal,TokenChar));
  if(RetVal)free(RetVal);
  return BCX_RetStr;
}


char *iReplace (char *src, char *pat, char *rep)
{
  size_t patsz, repsz, tmpsz, delta;
  char *strtmp, *p, *q, *r;
  if (!pat || !*pat)
   {
     strtmp = BCX_TmpStr(strlen(src));
     if (!strtmp) return NULL;
     return strcpy(strtmp, src);
   }
  repsz = strlen(rep);
  patsz = strlen(pat);
  for (tmpsz=0, p=src;(q=_stristr_(p,pat))!=0; p=q+patsz)
    tmpsz += (size_t) (q - p) + repsz;
    tmpsz += strlen(p);
    strtmp = BCX_TmpStr(tmpsz);
    if (!strtmp) return NULL;
    for (r=strtmp,p=src;(q=_stristr_(p,pat))!=0;p=q+patsz)
     {
       delta = (size_t) (q-p);
       memcpy(r,p,delta); r += delta;
       strcpy(r,rep);      r += repsz;
     }
  strcpy(r,p);
  return strtmp;
}


int containedin(char * Token,char **Contain ,int c)
  {
    int i=0;
    while(Contain[i][0])
      {
        if(0 == ((c == 0 || c == 2) ? strcmp(Contain[i],Token) : strcasecmp(Contain[i],Token)))
          {
            return ((c < 2) ? 0 : i);
          }
        i++;
      }
    return -1;
  }



// ************************************
//       User Subs and Functions
// ************************************


int main (int argc, PCHAR* argv)
{
  G_argc=argc;
  G_argv=argv;
  szTmp=(char*)calloc(256+65535,1);
  Src=(char*)calloc(256+65535,1);
  AbortSrc=(char*)calloc(256+65535,1);
  WarnMsg=(char*)calloc(256+65535+1,1);
  RmLibs=(char*)calloc(256+32767,1);
  static   int  bitz;
  memset(&bitz,0,sizeof(bitz));
  ProtoCnt=0;
  TranslateSlash=TRUE;
  OkayToSend=TRUE;
  Use_SingleFile=TRUE;
  Use_StartupCode=FALSE;
  StartNdx=0;
  Use_ExitCode=FALSE;
  ExitNdx=0;
  *HFile=0;
  *CmdLineFileOut=0;
  *RmLibs=0;
  InMain=TRUE;
  TestState=FALSE;
  *CmdLineConst=0;
  bitz=sizeof(long)*8;
  if(command(-1)[0]==0)
    {
 #if defined (__APPLE__)
      printf("%s\n","MBC4:  Ported to Mac OSX by Armando Rivera (c) 2009-2018");
 #else
      printf("%s\n","MBC4: Based on Linux BCX by Mike Henning (c) 2009");
      printf("%s%s\n","(c) 2009-2018 Armando Rivera with additional code (c) 2009 John Jacques",LF);
 #endif
      printf("%s%s%s","Version ",Version,"  Compiled with ");
// FP3
#if defined __BCPLUSPLUS__// OUTFILE
      printf("%s\n","Borland C++");
#elif defined __BORLANDC__
      printf("%s\n","Borland C");
#elif defined __POCC__
      printf("%s\n","Pelles C");
#elif defined __GNUG__
      printf("%s\n","GNU G++");
#else
      printf("%s\n","Unknown");
#endif  // Main
      if(bitz==64)
        {
          printf("\n");
          printf("%s\n","********************");
          printf("%s\n","** 64 BIT VERSION **");
          printf("%s%s\n","********************",LF);
        }
      printf("%s%s%s\n"," Usage: ",AppExeName()," infile [.bas] [options]");
      printf("%s\n"," [-c] Generate C++ Compatible code");
      printf("%s%s%s\n"," [-d] DEFINE a constant ... ex. ",AppExeName()," MyFile -D:MyConst[=SomeValue]");
      printf("%s\n"," [-e] Write ERRORS to BCX.ERR file");
      printf("%s%s%s\n"," [-f] Output FILENAME... ex. ",AppExeName()," MyFile -f:/MyFiles/MyFile.c");
      printf("%s\n"," [-k] KILL the generated BCX generated 'C' file");
      printf("%s\n"," [-o] OUTPUT a copy of the generated C file to STDOUT");
      printf("%s\n"," [-q] QUIET - No output to screen during translation");
      printf("%s\n"," [-s] Show STATUS of translation by line number");
      printf("%s\n"," [-w] Enable WARNINGS during translation");
      printf("%s%s%s\n"," [-t] TURBO Mode ON w/optional size ... ex. ",AppExeName()," MyFile -t[:1024]");
      printf("%s\n"," [-u] Turn UNICODE Support ON");
      FreeGlobals();
      fflush(stdout);
      exit(0);
    }
  Quiet=FALSE;
    {int i;
  for(i=2; i<=argc-1; i+=1)
    {
      if(instr_b(lcase(argv[i]),"-f"))
        {
          strcpy(CmdLineFileOut,mid(argv[i],4));
        }
      if(instr_b(lcase(argv[i]),"-d"))
        {
          strcpy(CmdLineConst, join(3,CmdLineConst,mid(argv[i],4),chr(1)));
        }
      if(str_cmp(lcase(argv[i]),"-c")==0)
        {
          UseCpp=TRUE;
        }
      if(str_cmp(lcase(argv[i]),"-e")==0)
        {
          ErrFile=TRUE;
        }
      if(str_cmp(lcase(argv[i]),"-q")==0)
        {
          Quiet=TRUE;
        }
      if(str_cmp(lcase(argv[i]),"-k")==0)
        {
          KillCFile=TRUE;
        }
      if(str_cmp(lcase(argv[i]),"-o")==0)
        {
          ReDirect=TRUE;
        }
      if(str_cmp(lcase(argv[i]),"-s")==0)
        {
          ShowStatus=TRUE;
        }
      if(str_cmp(lcase(argv[i]),"-w")==0)
        {
          TestState=TRUE;
        }
      if(instr_b(lcase(argv[i]),"-t"))
        {
          Use_Turbo=TRUE;
          TurboSize=VAL(mid(argv[i],4));
          if(TurboSize!=0)
            {
              if((TurboSize&(TurboSize-1))!=0)
                {
                  TurboSize=512;
                  Warning("Invalid $Turbo size - defaulting to 512");
                }
            }
          else
            {
              TurboSize=512;
            }
        }
    }
    }
  if(ShowStatus)
    {
      cls();
    }
  if(!Quiet)
    {
      cls();
      printf("%s%s\n","MBC Version ",Version);
 #if defined (__APPLE__)
      IsApple=TRUE;
      printf("%s%s\n","MBC4:  Ported to Mac OSX by Armando Rivera (c) 2009-2018",LF);
 #else
      printf("%s\n","MBC4: Based on Linux BCX by Mike Henning (c) 2009");
      printf("%s%s\n","(c) 2009-2018 Armando Rivera with additional code (c) 2009 John Jacques",LF);
 #endif
      if(bitz==64)
        {
          printf("\n");
          printf("%s\n","********************");
          printf("%s\n","** 64 BIT VERSION **");
          printf("%s%s\n","********************",LF);
        }
    }
  if(inchr(command(1),"."))
    {
      strcpy(Cmd,command(1));
    }
  else
    {
      if(Exist(join(2,command(1),".bas")))
        {
          strcpy(Cmd, join(2,command(1),".bas"));
        }
      else if(Exist(join(2,command(1),".BAS")))
        {
          strcpy(Cmd, join(2,command(1),".BAS"));
        }
    }
  if(!Exist(Cmd))
    {
      printf("\n");
      printf("%s%s\n","FILE NOT FOUND: ",command(1));
      FreeGlobals();
      fflush(stdout);
      exit(0);
    }
  strcpy(FileIn,Cmd);
  if(CmdLineFileOut[0]==0)
    {
      strcpy(FileOut, join(2,left(Cmd,InstrRev(Cmd,".",0)-1),".cc"));
    }
  else
    {
      strcpy(FileOut,CmdLineFileOut);
    }
  strcpy(FileErr, join(2,left(Cmd,InstrRev(Cmd,".",0)-1),".ERR"));
  if(Exist(FileErr))
    {
      remove (FileErr);
    }
  strcpy(prcFile,TempFileName(tempdir(),"prc"));
  strcpy(udtFile,TempFileName(tempdir(),"udt"));
  strcpy(datFile,TempFileName(tempdir(),"dat"));
  strcpy(cstFile,TempFileName(tempdir(),"cst"));
  strcpy(ovrFile,TempFileName(tempdir(),"ovr"));
  strcpy(hdrFile,TempFileName(tempdir(),"hdr"));
  strcpy(setFile,TempFileName(tempdir(),"set"));
  strcpy(enuFile,TempFileName(tempdir(),"enu"));
  if((SourceFile=fopen(FileIn,"r"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",FileIn);
     exit(1);
   }
  if((FP2=fopen(FileOut,"w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",FileOut);
     exit(1);
   }
  Outfile=FP2;
  if((FP3=fopen(prcFile,"w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",prcFile);
     exit(1);
   }
  if((FP4=fopen(udtFile,"w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",udtFile);
     exit(1);
   }
  if((FP5=fopen(datFile,"w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",datFile);
     exit(1);
   }
  if((FP6=fopen(cstFile,"w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",cstFile);
     exit(1);
   }
  if((FP7=fopen(hdrFile,"w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",hdrFile);
     exit(1);
   }
  if((FP8=fopen(ovrFile,"w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",ovrFile);
     exit(1);
   }
  if((FP9=fopen(setFile,"w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",setFile);
     exit(1);
   }
  if((FP11=fopen(enuFile,"w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",enuFile);
     exit(1);
   }
  ModuleNdx=1;
  strcpy(Modules[ModuleNdx],FileIn);
  ModuleLineNos[ModuleNdx]=0;
  EmitProlog();
  ClearIfThenStacks();
  EmitCmdLineConst();
  AddGlobal("G_argv",vt_PCHAR,0,"",1,0,0,0);
  AddGlobal("G_argc",vt_INTEGER,0,"",0,0,0,0);

READSRCLINE:;
  while(!EoF(SourceFile)||SplitCnt)
    {
      if(SplitCnt==0)
        {
          Src[0]=0;
          AR_fgets_retval=fgets(Src,65535,SourceFile);
          if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
          ModuleLineNos[ModuleNdx]++;
          StripCode(Src);
          if(*Src==0)
            {
              continue;
            }
          if(JoinLines(Src)==1)
            {
              continue;
            }
          if(inchr(Src,"["))
            {
              BracketHandler(Src,0);
            }
          if(SplitLines(Src))
            {
              strcpy(Src,SplitStk[++SplitCur]);
            }
        }
      else
        {
          strcpy(Src,SplitStk[++SplitCur]);
        }
      if(SplitCur==SplitCnt)
        {
          SplitCur=SplitCnt=0;
        }
      if(*Src==0)
        {
          continue;
        }
      strcpy(AbortSrc,Src);
      if(TrcFlag&&InFunc)
        {
          if(!iMatchLft(Src,"$trace"))
            {
              if(!iMatchLft(Src,"end ")&&instr_b(Src,"FUNCTION",0,1)==0)
                {
                  fprintf(Outfile,"%s%s%s%s%s%s\n","// [",trim(Modules[ModuleNdx])," - ",trim(str(ModuleLineNos[ModuleNdx])),"] ",Src);
                  strcpy(Z,trim(Modules[ModuleNdx]));
                  strcpy(Z,replace(Z,"\\","\\\\"));
                  strcpy(Z, join(5," ",Z," - ",str(ModuleLineNos[ModuleNdx])," \\n"));
                  strcpy(Z, join(3,"printf(",enc(Z),");"));
                  fprintf(Outfile,"%s\n",Z);
                }
            }
        }
      if(SrcFlag)
        {
          if(!iMatchLft(Src,"$sourc")&&*Src!=33)
            {
              fprintf(Outfile,"%s%s%s%s%s%s\n","// [",trim(Modules[ModuleNdx])," - ",trim(str(ModuleLineNos[ModuleNdx])),"] ",Src);
            }
        }
      if(ShowStatus)
        {
          locate (2,1,0);
          printf("%s%s%s%d\n","Processing Module: ",trim(Modules[ModuleNdx])," - Line:",(int)ModuleLineNos[ModuleNdx]);
        }
      if(Src[0]==33)
        {
          Src[0]=32;
          fprintf(Outfile,"%s\n",Src);
          *Src=0;
        }
      if(*Src==0)
        {
          continue;
        }
      int     di;
      di=Directives();
      if(di==0)
        {
          goto READNEXTLINE;
        }
      if(di==1)
        {
          goto READSRCLINE;
        }
      if(iMatchLft(Src,"set "))
        {
          ProcessSetCommand(0);
        }
      if(iMatchLft(Src,"sharedset "))
        {
          ProcessSetCommand(1);
        }
      PassOne=TRUE;
      CheckParQuotes();
      if(SpecialCaseHandler(Src))
        {
          continue;
        }
      Parse(Src);
      PassOne=FALSE;
      if(Ndx)
        {
          Emit();
        }

READNEXTLINE:;
    }
  if(CmdLineConst[0]>0)
    {
      strcpy(Src, join(2,"CONST ",CmdLineConst));
      Parse(Src);
      Emit();
      *CmdLineConst=0;
    }
  if(TestForBcxIni==FALSE)
    {
      TestForBcxIni=TRUE;
      strcpy(szFile, join(2,curdir(),"\\bcx.ini"));
      if(!Exist(szFile))
        {
          strcpy(szFile, join(2,AppExePath(),"bcx.ini"));
        }
      if(Exist(szFile))
        {
          PushFileIO();
          if((SourceFile=fopen(szFile,"r"))==0)
           {
             fprintf(stderr,"Can't open file %s\n",szFile);
             exit(1);
           }
          strcpy(Modules[++ModuleNdx],szFile);
          ModuleLineNos[ModuleNdx]=0;
          goto READSRCLINE;
        }
    }
  fflush(Outfile);
  if(FPtrNdx)
    {
      PopFileIO();
      goto READSRCLINE;
    }
  if(Use_GenFree&&GlobalDynaCnt)
    {
      MakeFreeGlobals();
    }
  ExportInternalConst();
  EmitEpilog();
  CloseAll();
  AddProtos();
  DeclareVariables();
  AddFuncs();
  CloseAll();
  if(UseCpp&&str_cmp(CmdLineFileOut,"")==0)
    {
      strcpy(szTmp, join(2,extract(FileOut,"."),".cpp"));
      remove (szTmp);
      rename (FileOut,szTmp);
      strcpy(FileOut,szTmp);
    }
  if(Use_Osx&&str_cmp(CmdLineFileOut,"")==0)
    {
      strcpy(szTmp, join(2,extract(FileOut,"."),".mm"));
      remove (szTmp);
      rename (FileOut,szTmp);
      strcpy(FileOut,szTmp);
    }
  if((FP1=fopen(FileOut,"r"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",FileOut);
     exit(1);
   }
  if((FP2=fopen(hdrFile,"r"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",hdrFile);
     exit(1);
   }
  if((FP3=fopen("$temp$","w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n","$temp$");
     exit(1);
   }
  DoCountLines=TRUE;
  fprintf(FP3,"%s\n","// *********************************************************************");
  fprintf(FP3,"%s%s%s\n","//   Created with MBC (V) ",Version,"Ported to OSX by Armando Rivera");
  fprintf(FP3,"%s\n","//   Ported from BCX32 BASIC To C/C++ Translator (V) 5.12");
  fprintf(FP3,"%s\n","//   BCX (c) 1999 - 2018 by Kevin Diggins");
  fprintf(FP3,"%s\n","//   LinuxBC (c) 2009 by Mike Henning ");
  fprintf(FP3,"%s\n","//   MBC (c) 2009 - 2018 by Armando Rivera");
  fprintf(FP3,"%s\n","// *********************************************************************");
  fprintf(FP3,"%s\n","//   Translated for compiling with the g++ Compiler");
  if(UseCpp)
    {
      fprintf(FP3,"%s\n","//   g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$.cpp -ldl -o $FILE$");
    }
  else
    {
      fprintf(FP3,"%s\n","//   g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$.cc -ldl -o $FILE$");
    }
  fprintf(FP3,"%s\n","// *********************************************************************");
  if(NoRT==FALSE)
    {
      if(Use_Osx)
        {
          fprintf(FP3,"%s\n","#import <Cocoa/Cocoa.h>");
        }
      /*****2010-11-24AddedWxCFORWXCONSOLEApps-AIR*****/;
      if(Use_Wx||Use_WxC)
        {
          fprintf(FP3,"%s\n","// WXWIDGETS HEADER FILES //");
          fprintf(FP3,"%s\n","#include <wx/wx.h>");
          fprintf(FP3,"%s\n","#include <wx/process.h>");
          fprintf(FP3,"%s\n","#include <wx/txtstrm.h>");
          fprintf(FP3,"%s\n","#include <wx/msgdlg.h>");
          fprintf(FP3,"%s\n","#include <wx/stdpaths.h>");
          fprintf(FP3,"%s\n","#include <wx/event.h>");
          fprintf(FP3,"%s\n","// ******************* //");
          fprintf(FP3,"%s\n","");
        }
      if(Use_Gtk)
        {
          fprintf(FP3,"%s\n","#include <gtk/gtk.h>");
        }
      if(Use_Glib)
        {
          fprintf(FP3,"%s\n","#include <glib.h>");
        }
      fprintf(FP3,"%s\n","#include <stdbool.h>");
      fprintf(FP3,"%s\n","#include <ctype.h>");
      fprintf(FP3,"%s\n","#include <math.h>");
      fprintf(FP3,"%s\n","#include <stdio.h>");
      fprintf(FP3,"%s\n","#include <iostream>");
      fprintf(FP3,"%s\n","#include <fstream>");
      fprintf(FP3,"%s\n","#include <string.h>");
      fprintf(FP3,"%s\n","#include <stddef.h>");
      fprintf(FP3,"%s\n","#include <stdlib.h>");
      fprintf(FP3,"%s\n","#include <setjmp.h>");
      fprintf(FP3,"%s\n","#include <time.h>");
      fprintf(FP3,"%s\n","#include <stdarg.h>");
      fprintf(FP3,"%s\n","#include <dirent.h>");
      fprintf(FP3,"%s\n","#include <sys/types.h>");
      fprintf(FP3,"%s\n","#include <sys/stat.h>");
      fprintf(FP3,"%s\n","#include <sys/wait.h>");
      fprintf(FP3,"%s\n","#include <unistd.h>");
      fprintf(FP3,"%s\n","#include <dlfcn.h>");
 #if defined (__APPLE__)
      fprintf(FP3,"%s\n","#include <libproc.h>");
 #endif
      if(UseCpp)
        {
          fprintf(FP3,"%s\n","#include <iostream>");
          fprintf(FP3,"%s\n","#include <fstream>");
        }
      if(Use_Instat)
        {
          Use_Keypress=TRUE;
          fprintf(FP3,"%s\n","#include <fcntl.h>");
        }
      if(Use_Keypress)
        {
          fprintf(FP3,"%s\n","#include <term.h>");
        }
      if(Use_Socket)
        {
          fprintf(FP3,"%s\n","#include <sys/socket.h>");
          fprintf(FP3,"%s\n","#include <netinet/in.h>");
          fprintf(FP3,"%s\n","#include <netdb.h>");
          fprintf(FP3,"%s\n","#include <errno.h>");
          fprintf(FP3,"%s\n","#include <arpa/inet.h>");
        }
      if(Use_RegEx)
        {
          fprintf(FP3,"%s\n","#include <regex.h>");
        }
      fprintf(FP3,"%s\n","");
      EmitCompilerDefines();
    }
  while(!EoF(FP2))
    {
      Z[0]=0;
      AR_fgets_retval=fgets(Z,65535,FP2);
      if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
      fprintf(FP3,"%s\n",Z);
    }
  char Lastlyne[2048];
  *Lastlyne=0;
  while(!EoF(FP1))
    {
      static int     bMainOut=0;
      Z[0]=0;
      AR_fgets_retval=fgets(Z,65535,FP1);
      if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
      if(iMatchLft(Lastlyne,"#if"))
        {
          if(iMatchLft(Z,"#endif"))
            {
              *Lastlyne=0;
              continue;
            }
          else
            {
              fprintf(FP3,"%s\n",Lastlyne);
            }
        }
      strcpy(Lastlyne,Z);
      if(iMatchLft(Lastlyne,"#if"))
        {
          continue;
        }
      fprintf(FP3,"%s\n",Z);
      if(bMainOut)
        {
          continue;
        }
      if(str_cmp(left(ltrim(Z),8),"int main")==0)
        {
          while(str_cmp(trim(Z),"{")!=0)
            {
              Z[0]=0;
              AR_fgets_retval=fgets(Z,65535,FP1);
              if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
              fprintf(FP3,"%s\n",Z);
            }
          if(Use_StartupCode)
            {
              fprintf(FP3,"%s%s\n",Scoot,"int BCX_SUCode = BCX_StartupCode_();  // execute user's startup code");
            }
          if(Use_ExitCode)
            {
              fprintf(FP3,"%s%s\n",Scoot,"int BCX_EXCode = BCX_ExitCode_();     // Prepare for user's exit code");
            }
          bMainOut++;
        }
    }
  DoCountLines=FALSE;
  CloseAll();
  remove (hdrFile);
  remove (FileOut);
  rename ("$temp$",FileOut);
  if(ShowStatus)
    {
      locate (2,1,1);
    }
  if(!Quiet)
    {
      LinesRead+=(ModuleLineNos[1]);
      Elapsed=Round((float)clock()/(float)CLOCKS_PER_SEC,2);
      printf("%s%d%s%d%s","[Lines In:",(int)LinesRead,"] [Lines Out:",(int)gLinesWritten,"] ");
      printf("%s%d%s%.7G%s\n","[Statements:",(int)Statements,"] [Time:",(float)Elapsed," sec's]");
      strcpy(Z, join(4,"BCX translated ",RemoveStr(FileIn," ")," to ",RemoveStr(FileOut," ")));
      printf("%s\n",Z);
    }
  PostProcess();
  if(WarnMsg[0]>0)
    {
      printf("%s%s%s\n","Warnings! :",CRLF,WarnMsg);
    }
  if(KillCFile)
    {
      remove (FileOut);
    }
  FreeGlobals();
  return 0;
}


void EmitCmdLineConst (void)
{
  if(CmdLineConst[0]>0)
    {
      static   FILE*   Ftmp;
      fprintf(FP7,"%s\n","");
      fprintf(FP7,"%s\n","// ***************************************************");
      fprintf(FP7,"%s\n","// Commandline Defines");
      fprintf(FP7,"%s\n","// ***************************************************");
      fprintf(FP7,"%s\n","");
      Ftmp=FP6;
      FP6=FP7;
        {int i;
      for(i=1; i<=tally(CmdLineConst,chr(1)); i+=1)
        {
          strcpy(Src,StrToken(CmdLineConst,chr(1),i));
          if(Src[0]==0)
            {
              break;
            }
          strcpy(Src, join(2,"CONST ",Src));
          Parse(Src);
          Emit();
        }
        }
      *CmdLineConst=0;
      FP6=Ftmp;
      fprintf(FP7,"%s\n","");
    }
}


void EmitCompilerDefines (void)
{
  fprintf(FP3,"%s\n","");
  fprintf(FP3,"%s\n","// ***************************************************");
  fprintf(FP3,"%s\n","// Compiler Defines");
  fprintf(FP3,"%s\n","// ***************************************************");
  fprintf(FP3,"%s%s\n","  #define C_EXPORT extern ",enc("C"));
  fprintf(FP3,"%s%s\n","  #define C_IMPORT extern ",enc("C"));
  fprintf(FP3,"%s\n","");
  fprintf(FP3,"%s\n","#ifndef stat");
  fprintf(FP3,"%s\n","  #define lstat stat");
  fprintf(FP3,"%s\n","#endif");
  fprintf(FP3,"%s\n","#ifndef _fcloseall");
  fprintf(FP3,"%s\n","  #define _fcloseall _fcloseall");
  fprintf(FP3,"%s\n","#endif");
  fprintf(FP3,"%s\n","#ifndef HWND");
  fprintf(FP3,"%s\n","  #define HWND GHWND");
  fprintf(FP3,"%s\n","#endif");
  fprintf(FP3,"%s\n","#ifndef MAX_PATH");
  fprintf(FP3,"%s\n","  #define MAX_PATH 2048");
  fprintf(FP3,"%s\n","#endif");
  fprintf(FP3,"%s\n","#ifndef CALLBACK");
  fprintf(FP3,"%s\n","  #define CALLBACK");
  fprintf(FP3,"%s\n","#endif");
  fprintf(FP3,"%s\n","typedef unsigned int HINSTANCE;");
  fprintf(FP3,"%s\n","typedef void* LPVOID;");
  fprintf(FP3,"%s\n","typedef char* PCHAR;");
  fprintf(FP3,"%s\n","typedef unsigned char BYTE;");
  fprintf(FP3,"%s\n","typedef unsigned int  UINT;");
  fprintf(FP3,"%s\n","typedef unsigned char UCHAR;");
  fprintf(FP3,"%s\n","typedef unsigned char* PUCHAR;");
  fprintf(FP3,"%s\n","typedef unsigned long ULONG;");
  fprintf(FP3,"%s\n","typedef unsigned long* ULONG_PTR;");
  fprintf(FP3,"%s\n","typedef unsigned long DWORD;");
  fprintf(FP3,"%s\n","");
  fprintf(FP3,"%s\n","#ifndef TRUE");
  fprintf(FP3,"%s\n","  #define TRUE 1");
  fprintf(FP3,"%s\n","#endif");
  fprintf(FP3,"%s\n","");
  fprintf(FP3,"%s\n","#ifndef FALSE");
  fprintf(FP3,"%s\n","  #define FALSE 0");
  fprintf(FP3,"%s\n","#endif");
  if(!Use_Osx)
    {
      fprintf(FP3,"%s\n","#define BOOL bool");
    }
  fprintf(FP3,"%s\n","");
  if(UseCpp)
    {
      fprintf(FP3,"%s\n","#define println(a)  (std::cout << a << std::endl)");
      fprintf(FP3,"%s\n","  typedef std::string CSTRING;");
      fprintf(FP3,"%s\n","  typedef std::fstream CFILE;");
    }
}


void MakeFreeGlobals (void)
{
  strcpy(Src,"SUB FreeGlobals");
  PassOne=1;
  Parse(Src);
  Emit();
  while(GlobalDynaCnt)
    {
      fprintf(Outfile,"%s%s\n","  ",GlobalDynaStr[GlobalDynaCnt]);
      GlobalDynaCnt--;
    }
  strcpy(Src,"END SUB");
  PassOne=1;
  Parse(Src);
  Emit();
}


void ProcessSetCommand (int GS)
{
  int     i;
  int     ii;
  int     j;
  int     SetString=0;
  char CVar[2048];
  int     vt;
  static  FILE   *SaveFP;
  memset(&SaveFP,0,sizeof(SaveFP));
  SaveFP=Outfile;
  if(!InFunc)
    {
      Outfile=FP9;
    }
  if(inchr(Src,"$")&&tally(Src,"[")>1)
    {
      strcpy(Src,strim(Src));
      strcpy(Src,IRemoveStr(Src,"as string"));
      strcpy(Src,IRemoveStr(Src,"as char"));
      strcat(Src," AS char");
    }
  strcat(Src,"=");
  PassOne=1;
  Parse(Src);
  *Tipe=0;
  for(i=1; i<=Ndx; i+=1)
    {
      if(iMatchWrd(Stk[i],"as"))
        {
          strcpy(Tipe,Stk[i+1]);
          *Stk[i]=0;
          *Stk[i+1]=0;
          break;
        }
    }
  if(Tipe[0]==0)
    {
      strcpy(szTmp,Stk[2]);
      SetString=DataType(Stk[2]);
      j=SetString;
      VarCode.Method=mt_ProcessSetCommand;
      strcpy(VarCode.Token,szTmp);
      VarCode.VarNo=j;
      GetVarCode( &VarCode);
      if(GS)
        {
          fprintf(Outfile,"%s%s",Scoot,RemoveStr(VarCode.StaticOut,"static "));
        }
      else
        {
          fprintf(Outfile,"%s%s",Scoot,VarCode.StaticOut);
        }
       char  lszTmp[65535];
      *lszTmp=0;
      strcpy(CVar,Clean(Stk[2]));
      ValidVar(CVar);
      vt=DataType(Stk[2]);
      for(i=3; i<=Ndx; i+=1)
        {
          strcat(lszTmp,Stk[i]);
        }
      if(vt==vt_STRVAR&&str_cmp(lszTmp,"")!=0)
        {
          strcat(lszTmp,"[65535]");
        }
      if(!InFunc)
        {
          AddGlobal(CVar,vt,0,lszTmp,0,0,0,1);
        }
      else
        {
          AddLocal(CVar,vt,0,lszTmp,0,0,1);
        }
    }
  else
    {
      strcpy(CVar,Clean(Stk[2]));
      if(GS)
        {
          fprintf(Outfile,"%s%s%s%s",Scoot,Tipe," ",CVar);
        }
      else
        {
          fprintf(Outfile,"%s%s%s%s%s",Scoot,"static ",Tipe," ",CVar);
        }
      char DimType[2048];
      int     IsPointer;
      int     id;
      strcpy(DimType,RemoveStr(Tipe,"*"));
      GetTypeInfo(Tipe, &IsPointer, &id, &vt);
      if(vt==vt_STRVAR)
        {
          strcat(DimType,"[65535]");
        }
      if(!InFunc)
        {
          AddGlobal(CVar,vt,id,DimType,IsPointer,0,0,1);
        }
      else
        {
          AddLocal(CVar,vt,id,DimType,IsPointer,0,1);
        }
    }
  i=2;
  j=0;
  for(;;)
    {
      i++;
      if(str_cmp(Stk[i],"=")==0)
        {
          j=1;
        }
      if(SetString==vt_STRVAR&&j==1)
        {
          fprintf(Outfile,"%s","[65535]=");
        }
      else
        {
          fprintf(Outfile,"%s",Stk[i]);
        }
      if(str_cmp(Stk[i],"=")==0)
        {
          break;
        }
      if(i==Ndx)
        {
          break;
        }
    }
  fprintf(Outfile,"%s\n","");
  fprintf(Outfile,"%s\n","{");
  while(!EoF(SourceFile))
    {
      Src[0]=0;
      AR_fgets_retval=fgets(Src,65535,SourceFile);
      if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
      ModuleLineNos[ModuleNdx]++;
      StripCode(Src);
      if(JoinLines(Src)==1)
        {
          continue;
        }
      PassOne=TRUE;
      XParse(Src);
      PassOne=FALSE;
      TokenSubstitutions();
      if(iMatchLft(Src,"end "))
        {
          break;
        }
      if(strlen(Src))
        {
          fprintf(Outfile,"%s","  ");
          for(ii=1; ii<=Ndx; ii+=1)
            {
              fprintf(Outfile,"%s",Clean(Stk[ii]));
            }
          fprintf(Outfile,"%s\n","");
        }
    }
  fprintf(Outfile,"%s\n","};\n");
  *Src=0;
  Outfile=SaveFP;
}


int Directives (void)
{
  char lszTmp[2048];
  int     i;
  char COutputFile[2048];
  if(*Src==35||*Src==36)
    {
      strcpy(Z,rtrim(lcase(left(Src,6))));
      for(;;)
      {
        if(str_cmp(Z,"$proje")==0)
          {
            NoRT=TRUE;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$accel")==0)
          {
            XParse(Src);
            strcpy(Accelerator,RemoveStr(Stk[2],DQ));
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$bcxve")==0)
          {
            strcpy(Src,trim(mid(Src,12)));
            strcpy(Src,RemoveStr(Src,DQ));
            if(str_cmp(lcase(Version),lcase(Src))==-1)
              {
                Abort(join(10,CRLF,"Your Translator needs updating.",CRLF,"This program ",enc(Modules[ModuleNdx])," requires BCX Version: ",Src," or later.",CRLF,CRLF));
              }
            else
              {
                printf("%s\n","");
                printf("%s%s\n","Program written for BCX Version ",Src);
                printf("%s\n","");
              }
            return 0;
          }
        if(str_cmp(Z,"$compi")==0)
          {
            PassOne=1;
            XParse(Src);
            PassOne=0;
            strcpy(Compiler,Stk[2]);
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$execo")==0)
          {
            static char SrcExt[2048];
            memset(&SrcExt,0,sizeof(SrcExt));
            PassOne=1;
            XParse(Src);
            PassOne=0;
            XitCount++;
            if(UseCpp)
              {
                strcpy(SrcExt,".cpp");
              }
            else if(Use_Osx)
              {
                strcpy(SrcExt,".mm");
              }
            else
              {
                strcpy(SrcExt,".cc");
              }
            if(MakeDLL)
              {
                strcpy(Xit[XitCount], join(7,"g++  -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$",SrcExt," -ldl ",LD_FLAGS,SPC,Stk[2]," -o lib$FILE$.so"));
                *SrcExt=0;
                *Src=0;
                return 0;
              }
            if(Use_IOS)
              {
                static char IOS_COMPILER[2048];
                memset(&IOS_COMPILER,0,sizeof(IOS_COMPILER));
                strcpy(IOS_COMPILER,"/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/g++");
                if(strlen(Stk[2])>0)
                  {
                    strcpy(Xit[XitCount], join(8,IOS_COMPILER,"  -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$",SrcExt," -ldl ",LD_FLAGS,SPC,Stk[2]," -o $FILE$"));
                  }
                else
                  {
                    strcpy(Xit[XitCount], join(6,IOS_COMPILER,"  -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$",SrcExt," -ldl ",LD_FLAGS," -o $FILE$"));
                  }
                *SrcExt=0;
                *Src=0;
                return 0;
              }
            if(strlen(Stk[2])>0)
              {
                strcpy(Xit[XitCount], join(7,"g++  -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$",SrcExt," -ldl ",LD_FLAGS,SPC,Stk[2]," -o $FILE$"));
              }
            else
              {
                strcpy(Xit[XitCount], join(5,"g++  -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$",SrcExt," -ldl ",LD_FLAGS," -o $FILE$"));
              }
            *SrcExt=0;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$exest")==0)
          {
            PassOne=1;
            XParse(Src);
            PassOne=0;
            XitCount++;
            if(IsApple)
              {
                strcpy(Xit[XitCount],"strip $FILE$");
              }
            else
              {
                strcpy(Xit[XitCount],"strip -s -R .comment -R .note -R .note.ABI-tag $FILE$");
              }
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$genfr")==0)
          {
            Use_GenFree=TRUE;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$osx")==0)
          {
            Use_Osx=TRUE;
            strcpy(LD_FLAGS,join(2,LD_FLAGS," -fobjc-arc -framework Cocoa"));
            return 0;
          }
        if(str_cmp(Z,"$ios")==0)
          {
 #if !defined __APPLE__
            Abort(join(3,CRLF,"The $IOS Directive REQUIRES an Apple OSX Operating System",CRLF));
 #endif
            Use_IOS=TRUE;
            PassOne=1;
            XParse(Src);
            PassOne=0;
            strcpy(LD_FLAGS,join(2,LD_FLAGS," -arch armv6 -arch armv7 -mthumb -isysroot /Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS4.2.sdk -framework Foundation -framework CoreFoundation"));
            return 0;
          }
        if(str_cmp(Z,"$gtk")==0)
          {
            Use_Gtk=TRUE;
            strcpy(LD_FLAGS,join(2,LD_FLAGS," $(pkg-config --libs --cflags gtk+-2.0)"));
            return 0;
          }
        if(str_cmp(Z,"$ldfla")==0)
          {
            strcpy(LD_FLAGS,join(2,LD_FLAGS,remain(Src," ")));
            return 0;
            /*****2010-11-24AddedWxCFORWXCONSOLEApps-AIR*****/;
            break;
          }
        if(str_cmp(Z,"$wxc")==0)
          {
            Use_WxC=UseCpp=NoMain=TRUE;
            strcpy(LD_FLAGS,join(2,LD_FLAGS," $(wx-config --libs --cppflags)"));
            return 0;
          }
        if(str_cmp(Z,"$wx")==0)
          {
            Use_Wx=UseCpp=NoMain=TRUE;
            strcpy(LD_FLAGS,join(2,LD_FLAGS," $(wx-config --libs --cppflags)"));
            return 0;
          }
        if(str_cmp(Z,"$glib")==0)
          {
            Use_Glib=TRUE;
            strcpy(LD_FLAGS,join(2,LD_FLAGS," $(pkg-config --libs --cflags glib-2.0)"));
            return 0;
          }
        if(str_cmp(Z,"$noini")==0)
          {
            *Src=0;
            TestForBcxIni=TRUE;
            return 0;
          }
        if(str_cmp(Z,"$linke")==0)
          {
            PassOne=1;
            XParse(Src);
            PassOne=0;
            strcpy(Linker,Stk[2]);
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$onexi")==0)
          {
            PassOne=1;
            XParse(Src);
            PassOne=0;
            XitCount++;
            strcpy(Xit[XitCount],Stk[2]);
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$onent")==0)
          {
            PassOne=1;
            XParse(Src);
            PassOne=0;
            EntryCnt++;
            strcpy(Entry[EntryCnt],Stk[2]);
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$pack")==0 ||  str_cmp(Z,"$pack(")==0)
          {
            strcpy(Src,mid(Src,6));
            fprintf(FP4,"%s%s\n","#pragma pack ",ltrim(Src));
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$nodll")==0)
          {
            NoDllMain=TRUE;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$pelle")==0)
          {
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$stdca")==0)
          {
            UseStdCall=TRUE;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$iprin")==0)
          {
            if(instr_b(lcase(Src),"_on"))
              {
                TranslateSlash=TRUE;
              }
            else
              {
                TranslateSlash=FALSE;
              }
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$nomai")==0)
          {
            NoMain=TRUE;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$test")==0)
          {
            TestState=!TestState;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$typed")==0)
          {
            fprintf(FP7,"%s%s%s\n","typedef ",remain(Src," "),";");
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$resou")==0)
          {
            static char resAlias[2048];
            memset(&resAlias,0,sizeof(resAlias));
            static char resFile[2048];
            memset(&resFile,0,sizeof(resFile));
            Use_Embed=TRUE;
            PassOne=1;
            XParse(Src);
            PassOne=0;
            EntryCnt++;
            strcpy(Entry[EntryCnt], join(5,"ld -r -b binary ",Stk[2]," -o ",Stk[2],".o"));
            strcpy(Stk[2],replace(Stk[2],".","_"));
            strcpy(resFile,RemoveStr(Stk[2],DQ));
            strcpy(resAlias,RemoveStr(Stk[3],DQ));
            AddGlobal(join(3,"_binary_",resFile,"_start"),vt_INTEGER,0,"",0,0,1,0);
            AddGlobal(join(3,"_binary_",resFile,"_size"),vt_INTEGER,0,"",0,0,1,0);
            strcpy(Src, join(5,"CONST ",resAlias,"= &_binary_",resFile,"_start"));
            Parse(Src);
            Emit();
            strcpy(Src, join(5,"CONST ",resAlias,"_SIZE = (int)&_binary_",resFile,"_size"));
            Parse(Src);
            Emit();
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$turbo")==0)
          {
            strcpy(Src,ltrim(mid(Src,7)));
            if(*Src!=0)
              {
                TurboSize=VAL(Src);
                if((TurboSize&(TurboSize-1))!=0)
                  {
                    TurboSize=512;
                    Warning("Invalid $Turbo size - defaulting to 512");
                  }
              }
            else
              {
                TurboSize=512;
              }
            Use_Turbo=TRUE;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$sourc")==0)
          {
            SrcFlag=!SrcFlag;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$fssta")==0)
          {
            Use_Static=!Use_Static;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$trace")==0)
          {
            TrcFlag=!TrcFlag;
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$inclu")==0 ||  str_cmp(Z,"$modul")==0)
          {
            char orgfileName[2048];
            strcpy(szFile,trim(RemoveStr(mid(Src,9),DQ)));
            strcpy(orgfileName,szFile);
            if(str_cmp(left(szFile,1),"<")==0)
              {
                strcpy(szFile,mid(szFile,2,strlen(szFile)-2));
                strcpy(szFile, join(2,Environ("BCXLIB"),szFile));
              }
            if(!Exist(szFile))
              {
                strcpy(szFile,BcxSplitPath(szFile,FNAME|FEXT));
                strcpy(szFile, join(2,BcxSplitPath(FileIn,FDRV|FPATH),szFile));
              }
            if(!Exist(szFile))
              {
                Abort(join(2,"Unable to locate ",orgfileName));
              }
            PushFileIO();
            if((SourceFile=fopen(szFile,"r"))==0)
             {
               fprintf(stderr,"Can't open file %s\n",szFile);
               exit(1);
             }
            strcpy(Modules[++ModuleNdx],szFile);
            ModuleLineNos[ModuleNdx]=0;
            return 1;
          }
        if(str_cmp(Z,"$try")==0)
          {
            fprintf(Outfile,"%s\n","try {");
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$throw")==0)
          {
            strcpy(szTmp,mid(Src,8));
            if(szTmp[0]==0)
              {
                strcpy(szTmp,enc("An Exception has occured!"));
              }
            fprintf(Outfile,"%s%s%s%s\n",Scoot,"throw ",szTmp,";");
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$catch")==0)
          {
            strcpy(szTmp,mid(Src,8));
            if(szTmp[0]==0)
              {
                strcpy(szTmp,"char *str");
              }
            fprintf(Outfile,"%s\n","}");
            fprintf(Outfile,"%s%s%s\n","catch (",szTmp,")");
            fprintf(Outfile,"%s\n","{");
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$endtr")==0)
          {
            fprintf(Outfile,"%s\n","}");
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$endna")==0)
          {
            InNameSpace--;
            BumpDown();
            fprintf(Outfile,"%s%s\n",Scoot,"}");
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$names")==0)
          {
            Abort("$NAMESPACE/$ENDNAMESPACE have been removed from this version.  Use NAMESPACE / END NAMESPACE instead.");
            break;
          }
        if(str_cmp(Z,"$usena")==0)
          {
            UseCpp=TRUE;
            strcpy(szTmp,mid(Src,inchr(Src," ")+1));
            if(str_cmp(right(trim(szTmp),1),";")!=0)
              {
                fprintf(Outfile,"%s%s%s\n","using namespace ",szTmp,";");
              }
            else
              {
                fprintf(Outfile,"%s%s\n","using namespace ",szTmp);
              }
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$class")==0)
          {
            Abort("$CLASS has been removed from this version.  Use CLASS instead.");
            return 0;
          }
        if(str_cmp(Z,"$inter")==0)
          {
            static int     BeenHere;
            UseCpp=TRUE;
            strcpy(szTmp,remain(Src,SPC));
            if(!BeenHere)
              {
                BeenHere++;
                fprintf(FP4,"%s\n","#ifndef __cplusplus");
                fprintf(FP4,"%s\n","  #error A C++ compiler is required");
                fprintf(FP4,"%s\n","#endif");
              }
            fprintf(FP4,"%s%s%s\n","interface ",szTmp," {");
            for(;;)
              {
                if(EoF(SourceFile))
                  {
                    Abort("$Interface Without $EndInterface");
                  }
                Src[0]=0;
                AR_fgets_retval=fgets(Src,65535,SourceFile);
                if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
                ModuleLineNos[ModuleNdx]++;
                if(iMatchLft(ltrim(Src),"$endinterface"))
                  {
                    break;
                  }
                fprintf(FP4,"%s\n",Src);
              }
            fprintf(FP4,"%s%s%s\n","}",trim(join(2,Src,13)),";");
            return 0;
          }
        if(str_cmp(Z,"$comme")==0)
          {
            *Src=0;
            for(;;)
              {
                if(EoF(SourceFile))
                  {
                    Abort("Unbalanced $Comment");
                  }
                Src[0]=0;
                AR_fgets_retval=fgets(Src,65535,SourceFile);
                if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
                ModuleLineNos[ModuleNdx]++;
                StripTabs();
                if(iMatchLft(ltrim(Src),"$comment"))
                  {
                    break;
                  }
                fprintf(Outfile,"%s%s\n","// ",Src);
              }
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$ccode")==0)
          {
            *Src=0;
            for(;;)
              {
                if(EoF(SourceFile))
                  {
                    Abort("Unbalanced $Ccode");
                  }
                Src[0]=0;
                AR_fgets_retval=fgets(Src,65535,SourceFile);
                if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
                ModuleLineNos[ModuleNdx]++;
                StripTabs();
                if(iMatchLft(ltrim(Src),"$ccode"))
                  {
                    if(SrcFlag)
                      {
                        fprintf(Outfile,"%s%s%s%s%s\n","// [",trim(Modules[ModuleNdx])," - ",trim(str(ModuleLineNos[ModuleNdx])),"] End of $CCODE Block");
                      }
                    break;
                  }
                fprintf(Outfile,"%s\n",rtrim(Src));
              }
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$cprot")==0)
          {
            FastLexer(Src,SPC,"!");
            if(iMatchWrd(Stk[2],"!"))
              {
                ProtoCnt++;
                strcpy(ProtoType[ProtoCnt].Prototype,remain(Src,"!"));
                *ProtoType[ProtoCnt].Condition=0;
                ProtoType[ProtoCnt].CondLevel=0;
              }
            else
              {
                i=iMatchNQ(Src,"function");
                if(i==0)
                  {
                    i=iMatchNQ(Src,"sub");
                  }
                if(i)
                  {
                    strcpy(Src, join(2,"c_declare ",mid(Src,i)));
                  }
                else
                  {
                    i=iMatchNQ(Src,"$cproto");
                    strcpy(Src, join(2,"c_declare function ",mid(Src,i+7)));
                  }
                UseCProto=TRUE;
                return 2;
              }
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$heade")==0)
          {
            *Src=0;
            fprintf(FP7,"%s\n","// ***************************************************");
            fprintf(FP7,"%s\n","");
            for(;;)
              {
                if(EoF(SourceFile))
                  {
                    Abort("Unbalanced $Header");
                  }
                Src[0]=0;
                AR_fgets_retval=fgets(Src,65535,SourceFile);
                if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
                ModuleLineNos[ModuleNdx]++;
                StripTabs();
                strcpy(Src,trim(Src));
                if(iMatchLft(Src,"$heade"))
                  {
                    break;
                  }
                fprintf(FP7,"%s\n",Src);
              }
            *Src=0;
            fprintf(FP7,"%s\n","");
            return 0;
          }
        if(str_cmp(Z,"$asm")==0)
          {
            if(!iMatchLft(Src,"$asm"))
              {
                Abort(join(2,"Unknown metastatement: ",Src));
              }
            *Src=0;
            for(;;)
              {
                if(EoF(SourceFile))
                  {
                    Abort("Unbalanced $Asm");
                  }
                Src[0]=0;
                AR_fgets_retval=fgets(Src,65535,SourceFile);
                if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
                ModuleLineNos[ModuleNdx]++;
                if(SrcFlag)
                  {
                    fprintf(Outfile,"%s%s\n","// ",Src);
                  }
                StripTabs();
                strcpy(Src,trim(Src));
                static int     meta_asm_loop;
                memset(&meta_asm_loop,0,sizeof(meta_asm_loop));
                static   bool  meta_asm_comment_present;
                memset(&meta_asm_comment_present,0,sizeof(meta_asm_comment_present));
                static int     Src_Len;
                memset(&Src_Len,0,sizeof(Src_Len));
                Src_Len=strlen(Src);
                meta_asm_comment_present=FALSE;
                for(meta_asm_loop=0; meta_asm_loop<=Src_Len; meta_asm_loop+=1)
                  {
                    if(Src[meta_asm_loop]==39||Src[meta_asm_loop]==59)
                      {
                        strcpy(lszTmp,right(Src,Src_Len-meta_asm_loop-1));
                        Src[meta_asm_loop]=0;
                        meta_asm_comment_present=TRUE;
                        break;
                      }
                  }
                strcpy(Src,trim(Src));
                if(iMatchLft(Src,"$asm"))
                  {
                    break;
                  }
                strcpy(Src,replace(Src,"$","0x"));
                strcpy(Src,iReplace(Src,"&h","0x"));
                if(Src[0]!=0)
                  {
                    strcpy(Src, join(3,"_asm(",enc(Src),chr(1)));
                    if(meta_asm_comment_present)
                      {
                        strcpy(Src, join(4,Src,TAB,"//",lszTmp));
                      }
                    strcpy(SrcTmp,Src);
                    fprintf(Outfile,"%s\n","#if !defined( __POCC__ ) && !defined (__cplusplus )");
                    strcpy(Src,replace(Src,chr(1),")"));
                    fprintf(Outfile,"%s\n",Src);
                    fprintf(Outfile,"%s\n","#else");
                    strcpy(SrcTmp,replace(SrcTmp,"_asm(","__asm{"));
                    strcpy(SrcTmp,replace(SrcTmp,chr(1),"}"));
                    fprintf(Outfile,"%s\n",RemoveStr(SrcTmp,DQ));
                    fprintf(Outfile,"%s\n","#endif");
                  }
              }
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"#inclu")==0)
          {
            strcpy(Src,RemoveStr(lcase(Src),"#include"));
            strcpy(Src,trim(Src));
            fprintf(FP7,"%s%s\n","#include ",Src);
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$libra")==0)
          {
            strcpy(Src,replace(Src,"\\","\\\\"));
            strcpy(Src,RemoveStr(lcase(Src),"$library"));
            strcpy(Src,trim(Src));
            AddLibrary(Src);
            *Src=0;
            return 0;
          }
        if(str_cmp(Z,"$nolib")==0)
          {
            strcpy(Src,replace(Src,"\\","\\\\"));
            strcpy(Src,RemoveStr(lcase(Src),"$nolibrary"));
            RemoveLibrary(Src);
            *Src=0;
            return 0;
          }
        break;
      }
    }
  return 2;
}


int SubVarType (int TokenNum)
{
  int     k;
  int     j=0;
  k=CheckLocal(Stk[TokenNum], &j);
  if(k==vt_CHAR)
    {
      if(*LocalVars[j].VarDim!=91&&LocalVars[j].VarPntr==0)
        {
          k=vt_INTEGER;
        }
    }
  else if(k==vt_UNKNOWN)
    {
      k=CheckGlobal(Stk[TokenNum], &j);
      if(k==vt_CHAR)
        {
          if(*GlobalVars[j].VarDim!=91&&GlobalVars[j].VarPntr==0)
            {
              k=vt_INTEGER;
            }
        }
    }
  j=(UCHAR)*(right(Stk[TokenNum],1));
  for(;;)
  {
    if(k==vt_STRVAR||k==vt_CHAR)
      {
        if(j!=36)
          {
            strcat(Stk[TokenNum],"$");
          }
        break;
      }
    if(k==vt_INTEGER)
      {
        if(j!=37)
          {
            strcat(Stk[TokenNum],"%");
          }
        break;
      }
    if(k==vt_SINGLE)
      {
        if(j!=33)
          {
            strcat(Stk[TokenNum],"!");
          }
        break;
      }
    if(k==vt_DOUBLE)
      {
        if(j!=35)
          {
            strcat(Stk[TokenNum],"#");
          }
        break;
      }
    if(k==vt_LDOUBLE)
      {
        if(j!=166)
          {
            strcat(Stk[TokenNum],"¦");
          }
      }
    break;
  }
  return k;
}


char * PrintWriteFormat (int DoWrite)
{
  char *BCX_RetStr={0};
   ARGTYPE  Stak[128];
  char Frmat[2048];
  char Arg[2048];
  char *ZZ;
  ZZ=(char*)calloc(256+65535,1);
  char Cast[2048];
  int     NewLineFlag=0;
  int     Argcount=0;
  int     i=0;
  int     j=0;
  int     k=0;
  *Frmat=0;
  *Arg=0;
  *ZZ=0;
  if(str_cmp(Stk[Ndx],";")==0)
    {
      NewLineFlag=TRUE;
      Ndx--;
    }
  if(Ndx==1)
    {
      goto PRINTWRITELABEL;
    }
  Stak[1].ArgType=-1;
  j=2;
  while(j<=Ndx)
    {
      if(str_cmp(Clean(Stk[j]),"BCX_DynaCall")!=0)
        {
          i=SubVarType(j);
          if(Stak[Argcount+1].ArgType==-1)
            {
              if(i==vt_CHAR||i==vt_STRVAR||i==vt_INTEGER||i==vt_SINGLE||i==vt_DOUBLE||i==vt_LDOUBLE)
                {
                  Stak[Argcount+1].ArgType=i;
                }
            }
          if(str_cmp(Stk[j],"(")==0)
            {
              i=0;
              for(;;)
                {
                  if(str_cmp(Stk[j],"(")==0)
                    {
                      i++;
                    }
                  if(str_cmp(Stk[j],")")==0)
                    {
                      i--;
                    }
                  strcat(Arg,Stk[j]);
                  j++;
                  if(i<=0||j>=Ndx)
                    {
                      break;
                    }
                }
            }
          if(str_cmp(Stk[j],"[")==0)
            {
              i=0;
              for(;;)
                {
                  if(str_cmp(Stk[j],"[")==0)
                    {
                      i++;
                    }
                  if(str_cmp(Stk[j],"]")==0)
                    {
                      i--;
                    }
                  strcat(Arg,Stk[j]);
                  j++;
                  if(str_cmp(Stk[j],"[")==0 && i==0)
                    {
                      continue;
                    }
                  if(i<=0||j>=Ndx)
                    {
                      break;
                    }
                }
            }
          if(str_cmp(Stk[j],";")==0 ||  str_cmp(Stk[j],",")==0 ||  str_cmp(Stk[j],"&")==0)
            {
              Argcount++;
              strcpy(Stak[Argcount].Arg,Arg);
              Stak[Argcount+1].ArgType=-1;
              *Arg=0;
              j++;
            }
          else
            {
              strcat(Arg,Stk[j]);
              j++;
            }
        }
      else
        {
          strcat(Arg,Stk[j]);
          j++;
        }
    }
  Argcount++;
  strcpy(Stak[Argcount].Arg,Arg);
  *Arg=0;
  for(i=1; i<=Argcount; i+=1)
    {
      j=Stak[i].ArgType;
      if(j==-1)
        {
          strcpy(ZZ,extract(Stak[i].Arg,"("));
          j=DataType(ZZ);
        }
      for(;;)
      {
        if(j==vt_STRLIT||j==vt_STRVAR||j==vt_CHAR)
          {
            if(DoWrite)
              {
                strcpy(Frmat, join(7,Frmat,"\\",DQ,"%s","\\",DQ,","));
              }
            else
              {
                strcat(Frmat,"%s");
              }
            if(str_cmp(left(ZZ,12),"BCX_DynaCall")==0)
              {
                strcpy(Arg, join(3,Arg,",(char*)",Stak[i].Arg));
              }
            else
              {
                strcpy(Arg, join(3,Arg,",",Stak[i].Arg));
              }
            break;
          }
        if(j==vt_INTEGER||j==vt_DECFUNC)
          {
            if(DoWrite)
              {
                strcpy(Frmat, join(3,Frmat,"%d",","));
              }
            else
              {
                strcat(Frmat,"%d");
              }
            strcpy(Arg, join(3,Arg,",(int)",Stak[i].Arg));
            break;
          }
        if(j==vt_SINGLE)
          {
            if(DoWrite)
              {
                strcpy(Frmat, join(3,Frmat,"%.7G",","));
              }
            else
              {
                strcat(Frmat,"%.7G");
              }
            strcpy(Arg, join(3,Arg,",(float)",Stak[i].Arg));
            break;
          }
        if(j==vt_DOUBLE||j==vt_NUMBER)
          {
            if(DoWrite)
              {
                strcpy(Frmat, join(3,Frmat,"%.15G",","));
              }
            else
              {
                strcat(Frmat,"%.15G");
              }
            strcpy(Arg, join(3,Arg,",(double)",Stak[i].Arg));
            break;
          }
        if(j==vt_LDOUBLE)
          {
            if(DoWrite)
              {
                strcpy(Frmat, join(3,Frmat,"%.19LG",","));
              }
            else
              {
                strcat(Frmat,"%.19LG");
              }
            strcpy(Arg, join(3,Arg,",(LDOUBLE)",Stak[i].Arg));
            break;
          }
          // case else
          {
            if((UCHAR)*(Stak[i].Arg)==40)
              {
                *ZZ=0;
                strcat(Arg,",");
                for(;;)
                  {
                    k=instr_b(Stak[i].Arg,")");
                    strcpy(Cast,mid(Stak[i].Arg,1,k));
                    strcpy(Stak[i].Arg,trim(mid(Stak[i].Arg,k+1)));
                    strcpy(Cast,iReplace(Cast,"char*","char *"));
                    strcpy(Cast,iReplace(Cast,"integer","int"));
                    strcpy(Cast,iReplace(Cast,"single","float"));
                    strcpy(Cast,iReplace(Cast,"ldouble","LDOUBLE"));
                    if(ZZ[0]==0)
                      {
                        if(str_cmp(Cast,"(char *)")==0 ||  str_cmp(Cast,"(int)")==0 ||  str_cmp(Cast,"(float)")==0 ||  str_cmp(Cast,"(double)")==0 ||  str_cmp(Cast,"(LDOUBLE)")==0)
                          {
                            strcpy(ZZ,Cast);
                          }
                        else
                          {
                            strcpy(ZZ,"(double)");
                            strcpy(Cast, join(2,ZZ,Cast));
                          }
                        RemoveAll(ZZ,"()");
                        strcpy(ZZ,iReplace(ZZ,"char *","%s"));
                        strcpy(ZZ,iReplace(ZZ,"int","%d"));
                        strcpy(ZZ,iReplace(ZZ,"float","%.7G"));
                        strcpy(ZZ,iReplace(ZZ,"ldouble","%.19LG"));
                        strcpy(ZZ,iReplace(ZZ,"double","%.15G"));
                      }
                    strcat(Arg,Cast);
                    if(!((UCHAR)*(Stak[i].Arg)==40))
                      {
                        break;
                      }
                  }
                strcat(Arg,Stak[i].Arg);
                strcat(Frmat,ZZ);
                if(DoWrite)
                  {
                    strcat(Frmat,",");
                  }
              }
            else
              {
                if(DoWrite)
                  {
                    strcpy(Frmat, join(3,Frmat,"%G",","));
                  }
                else
                  {
                    strcat(Frmat,"%G");
                    strcpy(Arg, join(3,Arg,",(float)",Stak[i].Arg));
                  }
              }
          }
        break;
      }
    }
  if(DoWrite)
    {
      strcpy(Frmat,left(Frmat,strlen(Frmat)-1));
    }

PRINTWRITELABEL:;
  if(NewLineFlag==0)
    {
      strcat(Frmat,"\\n");
    }
  BCX_RetStr=join(4,"printf(",enc(Frmat),Clean(Arg),");");
  if(ZZ)free(ZZ);
  return BCX_RetStr;
}


void EmitInputCode (void)
{
  int     Argcount=0;
  int     VarCnt=0;
  int     i=0;
  int     j=0;
  int     l=0;
  char Arg[2048];
  char Tmp[2048];
  char Frmat[2048];
  static char Stak[128][2048];
  memset(&Stak,0,sizeof(Stak));
  char Y[2048];
  char *ZZ;
  ZZ=(char*)calloc(256+65535,1);
  Use_Inputbuffer=TRUE;
  Use_Scan=TRUE;
  Use_Split=TRUE;
  Use_Remove=TRUE;
  Use_StrStr=TRUE;
  Use_Mid=TRUE;
  Use_Left=TRUE;
  Use_Instr=TRUE;
  Use_Stristr=TRUE;
  UseLCaseTbl=TRUE;
  UseFlag=TRUE;
  Use_Lineinput=TRUE;
  *Arg=0;
  *ZZ=0;
  *Frmat=0;
  strcpy(Tmp, join(7,DQ,",",DQ,",",DQ," ",DQ));
  if(DataType(Stk[2])==vt_STRLIT)
    {
      fprintf(Outfile,"%s%s%s%s\n",Scoot,"printf(",Clean(Stk[2]),");");
    }
  if(DataType(Stk[2])==vt_STRLIT)
    {
      j=4;
    }
  else
    {
      j=2;
    }
  l=j;
  while(j<=Ndx)
    {
      if(j==l)
        {
          i=SubVarType(j);
        }
      if(str_cmp(Stk[j],",")==0)
        {
          l=j+1;
        }
      strcat(ZZ,Stk[j]);
      j++;
    }
  FastLexer(ZZ,"",",");
  j=1;
  while(j<=Ndx)
    {
      if(str_cmp(Stk[j],",")==0)
        {
          Argcount++;
          strcpy(Stak[Argcount],Arg);
          *Arg=0;
          j++;
        }
      else
        {
          strcat(Arg,Stk[j]);
          j++;
          if(j<Ndx)
            {
              if(str_cmp(Stk[j],"[")==0)
                {
                  i=0;
                  for(;;)
                    {

DOAGAIN:;
                      if(str_cmp(Stk[j],"[")==0)
                        {
                          i++;
                        }
                      if(str_cmp(Stk[j],"]")==0)
                        {
                          i--;
                        }
                      strcat(Arg,Stk[j]);
                      j++;
                      if(str_cmp(Stk[j],"[")==0 && i==0)
                        {
                          goto DOAGAIN;
                        }
                      if(i<=0||j>=Ndx)
                        {
                          break;
                        }
                    }
                }
            }
        }
    }
  Argcount++;
  strcpy(Stak[Argcount],Arg);
  *Arg=0;
  for(i=1; i<=Argcount; i+=1)
    {
      strcpy(Y,Stak[i]);
      j=DataType(Y);
      for(;;)
      {
        if(j==vt_STRVAR)
          {
            strcat(Frmat,"%s");
            strcpy(Arg, join(3,Arg,",",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s%s\n",Scoot,"*",trim(Clean(Stak[i])),"=0;");
            VarCnt++;
            break;
          }
        if(j==vt_INTEGER)
          {
            strcat(Frmat,"%d");
            strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
            VarCnt++;
            break;
          }
        if(j==vt_SINGLE)
          {
            strcat(Frmat,"%g");
            strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
            VarCnt++;
            break;
          }
        if(j==vt_DOUBLE)
          {
            strcat(Frmat,"%lG");
            strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
            VarCnt++;
            break;
          }
        if(j==vt_LDOUBLE)
          {
            strcat(Frmat,"%lG");
            strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
            VarCnt++;
            break;
          }
          // case else
          {
            strcat(Frmat,"%d");
            strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
            VarCnt++;
          }
        break;
      }
    }
  fprintf(Outfile,"%s%s\n",Scoot,"AR_fgets_retval=fgets(InputBuffer,sizeof(InputBuffer),stdin);");
  fprintf(Outfile,"%s%s\n",Scoot,"InputBuffer[strlen(InputBuffer)-1]=0;");
  fprintf(Outfile,"%s%s%s%s%s\n",Scoot,"ScanError = scan(InputBuffer,",enc(Frmat),Arg,");\n");
  fprintf(Outfile,"%s%s\n",Scoot,"*InputBuffer=0;");
  if(ZZ)free(ZZ);
}


void EmitFileInputCode (void)
{
  int     Argcount=0;
  int     VarCnt=0;
  int     i;
  int     j;
  char Arg[2048];
  char Frmat[2048];
  char FHandle[2048];
  char Y[2048];
  char *ZZ;
  ZZ=(char*)calloc(256+65535,1);
  static char Stak[128][2048];
  memset(&Stak,0,sizeof(Stak));
  *Arg=0;
  *Frmat=0;
  *ZZ=0;
  *FHandle=0;
  Use_Inputbuffer=TRUE;
  Use_Scan=TRUE;
  Use_Split=TRUE;
  Use_Remove=TRUE;
  Use_StrStr=TRUE;
  Use_Mid=TRUE;
  Use_Left=TRUE;
  Use_Instr=TRUE;
  Use_Stristr=TRUE;
  UseLCaseTbl=TRUE;
  i=4;
  for(j=2; j<=Ndx; j+=1)
    {
      if(*Stk[j]==44)
        {
          i=j+1;
          break;
        }
      strcat(FHandle,Stk[j]);
    }
  for(j=i; j<=Ndx; j+=1)
    {
      if(j==i)
        {
          SubVarType(j);
        }
      if(str_cmp(Stk[j],",")==0)
        {
          SubVarType(j+1);
        }
      strcat(ZZ,Stk[j]);
    }
  FastLexer(ZZ,"",",");
  j=1;
  while(j<=Ndx)
    {
      if(str_cmp(Stk[j],",")==0)
        {
          Argcount++;
          strcpy(Stak[Argcount],Arg);
          *Arg=0;
          j++;
        }
      else
        {
          strcat(Arg,Stk[j]);
          j++;
          if(j<Ndx)
            {
              if(str_cmp(Stk[j],"[")==0)
                {
                  i=0;
                  for(;;)
                    {

DOAGAIN:;
                      if(str_cmp(Stk[j],"[")==0)
                        {
                          i++;
                        }
                      if(str_cmp(Stk[j],"]")==0)
                        {
                          i--;
                        }
                      strcat(Arg,Stk[j]);
                      j++;
                      if(str_cmp(Stk[j],"[")==0 && i==0)
                        {
                          goto DOAGAIN;
                        }
                      if(i<=0||j>=Ndx)
                        {
                          break;
                        }
                    }
                }
            }
        }
    }
  Argcount++;
  strcpy(Stak[Argcount],Arg);
  *Arg=0;
  for(i=1; i<=Argcount; i+=1)
    {
      strcpy(Y,Stak[i]);
      j=DataType(Y);
      for(;;)
      {
        if(j==vt_STRVAR)
          {
            strcat(Frmat,"%s");
            strcpy(Arg, join(3,Arg,",",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s%s\n",Scoot,"*",trim(Clean(Stak[i])),"=0;");
            VarCnt++;
            break;
          }
        if(j==vt_INTEGER)
          {
            strcat(Frmat,"%d");
            strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
            VarCnt++;
            break;
          }
        if(j==vt_SINGLE)
          {
            strcat(Frmat,"%g");
            strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
            VarCnt++;
            break;
          }
        if(j==vt_DOUBLE)
          {
            strcat(Frmat,"%lG");
            strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
            VarCnt++;
            break;
          }
        if(j==vt_LDOUBLE)
          {
            strcat(Frmat,"%lG");
            strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
            VarCnt++;
            break;
          }
          // case else
          {
            strcat(Frmat,"%d");
            strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
            fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
            VarCnt++;
          }
        break;
      }
    }
  fprintf(Outfile,"%s%s%s%s\n",Scoot,"AR_fgets_retval=fgets(InputBuffer,65535,",FHandle,");");
  fprintf(Outfile,"%s%s\n",Scoot,"if(InputBuffer[strlen(InputBuffer)-1]== 10)");
  fprintf(Outfile,"%s%s\n",Scoot,"   InputBuffer[strlen(InputBuffer)-1]=0;");
  fprintf(Outfile,"%s%s%s%s%s\n",Scoot,"ScanError = scan(InputBuffer,",enc(Frmat),Arg,");\n");
  fprintf(Outfile,"%s%s\n",Scoot,"*InputBuffer=0;");
  if(ZZ)free(ZZ);
}


void AddFuncs (void)
{
  char *ZZ;
  ZZ=(char*)calloc(256+65535,1);
  char Last[2048];
  *Last=0;
  CloseAll();
  if((FP1=fopen(prcFile,"r"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",prcFile);
     exit(1);
   }
  if((Outfile=fopen(FileOut,"a"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",FileOut);
     exit(1);
   }
  if(ProtoType[1].Prototype[0]>0)
    {
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// ************************************");
      fprintf(Outfile,"%s%s\n","//       ",BCX_STR_USR_PROCS);
      fprintf(Outfile,"%s\n","// ************************************");
      fprintf(Outfile,"%s\n","\n");
    }
  while(!EoF(FP1))
    {
      ZZ[0]=0;
      AR_fgets_retval=fgets(ZZ,65535,FP1);
      if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
      if(instr_b(ZZ,"DefWindowProc"))
        {
          if(instr_b(Last,"return ")||instr_b(Last,"CallWindowProc")||instr_b(Last,"DefWindowProc")||instr_b(Last,"DefMDIChildProc")||instr_b(Last,"DefFrameProc"))
            {
              *Last=0;
              continue;
            }
        }
      fprintf(Outfile,"%s\n",ZZ);
      if(str_cmp(left(ZZ,2),"//")!=0)
        {
          strcpy(Last,ZZ);
        }
    }
  CloseAll();
  remove (prcFile);
  remove (udtFile);
  remove (datFile);
  remove (cstFile);
  remove (ovrFile);
  remove (setFile);
  remove (enuFile);
  if(ZZ)free(ZZ);
}


int CheckLocal (char *ZZ, int* varidx)
{
  char TT[2048];
  if(LocalVarCnt)
    {
      strcpy(TT,Clean(ZZ));
      RemoveAll(TT," &*()",1);
      if(instr_b(TT,"["))
        {
          strcpy(TT,left(TT,instr_b(TT,"[")-1));
        }
        {int i;
      for(i=1; i<=LocalVarCnt; i+=1)
        {
          if(str_cmp(TT,LocalVars[i].VarName)==0)
            {
              (*varidx)=i;
              return LocalVars[i].VarType;
            }
        }
        }
    }
  return vt_UNKNOWN;
}


int CheckGlobal (char *ZZ, int* varidx)
{
  int     hn;
  int     s;
  char TT[2048];
  strcpy(TT,Clean(ZZ));
  RemoveAll(TT," &*()",1);
  if(instr_b(TT,"["))
    {
      strcpy(TT,left(TT,instr_b(TT,"[")-1));
    }
  hn=HashNumber(TT);
  while(GlobalVarHash[hn])
    {
      s=GlobalVarHash[hn];
      if(str_cmp(TT,GlobalVars[s].VarName)==0)
        {
          (*varidx)=s;
          return GlobalVars[s].VarType;
        }
      hn=imod(hn+1,MaxGlobalVars);
    }
  return vt_UNKNOWN;
}


int CheckType (char *ZZ)
{
  char Keyword[2048];
  int     varid=0;
  int     i;
  strcpy(Keyword,lcase(ZZ));
  for(;;)
  {
    if(str_cmp(Keyword,"int")==0)
      {
        return vt_INTEGER;
      }
    if(str_cmp(Keyword,"string")==0)
      {
        return vt_STRVAR;
      }
    if(str_cmp(Keyword,"char")==0)
      {
        return vt_CHAR;
      }
    if(str_cmp(Keyword,"pchar")==0)
      {
        return vt_PCHAR;
      }
    if(str_cmp(Keyword,"byte")==0)
      {
        return vt_BYTE;
      }
    if(str_cmp(Keyword,"double")==0)
      {
        return vt_DOUBLE;
      }
    if(str_cmp(Keyword,"ldouble")==0)
      {
        return vt_LDOUBLE;
      }
    if(str_cmp(Keyword,"file")==0)
      {
        return vt_FILEPTR;
      }
    if(str_cmp(Keyword,"float")==0)
      {
        return vt_SINGLE;
      }
    if(str_cmp(Keyword,"bool")==0 ||  str_cmp(Keyword,"boolean")==0)
      {
        return vt_BOOL;
      }
    if(str_cmp(Keyword,"long")==0)
      {
        return vt_LONG;
      }
    if(str_cmp(Keyword,"dword")==0)
      {
        return vt_DWORD;
      }
    if(str_cmp(Keyword,"farproc")==0)
      {
        return vt_FARPROC;
      }
    if(str_cmp(Keyword,"void")==0)
      {
        return vt_VOID;
      }
    if(str_cmp(Keyword,"lpbyte")==0)
      {
        return vt_LPBYTE;
      }
    if(str_cmp(Keyword,"lresult")==0)
      {
        return vt_LRESULT;
      }
    if(str_cmp(Keyword,"short")==0)
      {
        return vt_SHORT;
      }
    if(str_cmp(Keyword,"ushort")==0)
      {
        return vt_USHORT;
      }
    if(str_cmp(Keyword,"uint")==0)
      {
        return vt_UINT;
      }
    if(str_cmp(Keyword,"ulong")==0)
      {
        return vt_ULONG;
      }
    if(str_cmp(Keyword,"colorref")==0)
      {
        return vt_COLORREF;
      }
    if(str_cmp(Keyword,"handle")==0)
      {
        return vt_HANDLE;
      }
    if(str_cmp(Keyword,"hdc")==0)
      {
        return vt_HDC;
      }
    if(str_cmp(Keyword,"variant")==0)
      {
        return vt_VARIANT;
      }
    break;
  }
  i=CheckLocal(ZZ, &varid);
  if(i==vt_UNKNOWN)
    {
      i=DefsID(ZZ);
      if(i)
        {
          return TypeDefs[i].TypeofDef;
        }
    }
  else
    {
      return i;
    }
  return CheckGlobal(ZZ, &varid);
}


void ExportInternalConst (void)
{
  if(Use_FillArray)
    {
      strcpy(Src,"CONST vt_INTEGER =  2");
      PassOne=1;
      Parse(Src);
      Emit();
      strcpy(Src,"CONST vt_SINGLE  =  3");
      PassOne=1;
      Parse(Src);
      Emit();
      strcpy(Src,"CONST vt_DOUBLE  =  4");
      PassOne=1;
      Parse(Src);
      Emit();
      strcpy(Src,"CONST vt_LDOUBLE  =  5");
      PassOne=1;
      Parse(Src);
      Emit();
    }
}


int RestrictedWords (char *ZZ)
{
  if(str_cmp(ZZ,"CmdLine")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"CmdShow")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"hInst")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"hPrev")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"hWnd")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"lParam")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"Msg")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"wParam")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"vt_INTEGER")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"vt_SINGLE")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"vt_DOUBLE")==0)
    {
      return 1;
    }
  if(str_cmp(ZZ,"vt_LDOUBLE")==0)
    {
      return 1;
    }
  return 0;
}


int DataType (char *ZZ)
{
  char Keyword[2048];
  int     i;
  if(ZZ[0]==34)
    {
      return vt_STRLIT;
    }
  if(inchr(ZZ,"$"))
    {
      return vt_STRVAR;
    }
  if(IsNumber(ZZ))
    {
      return vt_NUMBER;
    }
  i=DefsID(ZZ);
  if(i)
    {
      return TypeDefs[i].TypeofDef;
    }
  strcpy(Keyword,lcase(ZZ));
  if(str_cmp(Keyword,"strlen")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"instr")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"inchr")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"sizeof")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"tally")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"band")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"bor")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"lof")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"pos")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"qbcolor")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"split")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"dsplit")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"sgn")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"timer")==0)
    {
      return vt_SINGLE;
    }
  if(str_cmp(Keyword,"keypress()")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"getattr")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"fix")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"instrrev")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"kbhit")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"exp")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"expl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"sinh")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"cosh")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"tanh")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"asinh")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"acosh")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"atanh")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"round")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"val")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"vall")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"iif")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"bin2dec")==0)
    {
      return vt_INTEGER;
    }
  if(str_cmp(Keyword,"hex2dec")==0)
    {
      return vt_INTEGER;
    }
  if(str_cmp(Keyword,"rnd")==0)
    {
      return vt_SINGLE;
    }
  if(str_cmp(Keyword,"frac")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"fracl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"asin")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"asinl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"hypot")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"hypotl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"log")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"logl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"log10")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"log10l")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"acos")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"acosl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"atan")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"atanl")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"sin")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"sinl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"cos")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"cosl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"tan")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"tanl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"pow")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"powl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"sqrt")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"sqrtl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"min")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"max")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"exist")==0)
    {
      return vt_DECFUNC;
    }
  if(str_cmp(Keyword,"abs")==0)
    {
      return vt_DOUBLE;
    }
  if(str_cmp(Keyword,"absl")==0)
    {
      return vt_LDOUBLE;
    }
  if(str_cmp(Keyword,"freefile")==0)
    {
      return vt_FILEPTR;
    }
  if(str_cmp(Keyword,"fint")==0)
    {
      return vt_INTEGER;
    }
  if(inchr(ZZ,"%"))
    {
      return vt_INTEGER;
    }
  if(inchr(ZZ,"!"))
    {
      return vt_SINGLE;
    }
  if(inchr(ZZ,"#"))
    {
      return vt_DOUBLE;
    }
  if(inchr(ZZ,"^"))
    {
      return vt_DOUBLE;
    }
  if(inchr(ZZ,"¦"))
    {
      return vt_LDOUBLE;
    }
  if(iMatchRgt(ZZ,"@"))
    {
      return vt_FILEPTR;
    }
  if(inchr(ZZ," "))
    {
      return vt_UDT;
    }
  if(isalpha(*ZZ))
    {
      return vt_INTEGER;
    }
  return vt_UNKNOWN;
}


void CloseAll (void)
{
 #if defined (__APPLE__)
  if(SourceFile)
   {
     fclose(SourceFile);
     SourceFile=NULL;
   }
  if(FP2)
   {
     fclose(FP2);
     FP2=NULL;
   }
  if(FP3)
   {
     fclose(FP3);
     FP3=NULL;
   }
  if(FP4)
   {
     fclose(FP4);
     FP4=NULL;
   }
  if(FP5)
   {
     fclose(FP5);
     FP5=NULL;
   }
  if(FP6)
   {
     fclose(FP6);
     FP6=NULL;
   }
  if(FP7)
   {
     fclose(FP7);
     FP7=NULL;
   }
  if(FP8)
   {
     fclose(FP8);
     FP8=NULL;
   }
  if(FP9)
   {
     fclose(FP9);
     FP9=NULL;
   }
  if(FP10)
   {
     fclose(FP10);
     FP10=NULL;
   }
  if(FP11)
   {
     fclose(FP11);
     FP11=NULL;
   }
  if(Outfile)
   {
     fclose(Outfile);
     Outfile=NULL;
   }
  if(FP1)
   {
     fclose(FP1);
     FP1=NULL;
   }
  if(ResIn)
   {
     fclose(ResIn);
     ResIn=NULL;
   }
  if(ResOut)
   {
     fclose(ResOut);
     ResOut=NULL;
   }
  if(UserResIn)
   {
     fclose(UserResIn);
     UserResIn=NULL;
   }
  if(fpErr)
   {
     fclose(fpErr);
     fpErr=NULL;
   }
  if(fpHFile)
   {
     fclose(fpHFile);
     fpHFile=NULL;
   }
  if(FP68)
   {
     fclose(FP68);
     FP68=NULL;
   }
  if(fpdef)
   {
     fclose(fpdef);
     fpdef=NULL;
   }
  if(SaveOutfileNum)
   {
     fclose(SaveOutfileNum);
     SaveOutfileNum=NULL;
   }
 #else
  fcloseall();
 #endif
}


char * Clean (char *ZZ)
{
  char *BCX_RetStr={0};
  char Tmp[2048];
  if(inchr(ZZ,"%"))
    {
      if(str_cmp(trim(ZZ),"%")==0)
        {
          BCX_RetStr=BCX_TmpStr(strlen(" % "));
          strcpy(BCX_RetStr," % ");
          return BCX_RetStr;
        }
    }
  if(iMatchNQ(ZZ,"!="))
    {
      BCX_RetStr=BCX_TmpStr(strlen(ZZ));
      strcpy(BCX_RetStr,ZZ);
      return BCX_RetStr;
    }
  strcpy(Tmp,ZZ);
  RemoveAll(Tmp,"%$#!@¦",1);
  BCX_RetStr=BCX_TmpStr(strlen(Tmp));
  strcpy(BCX_RetStr,Tmp);
  return BCX_RetStr;
}


void RemoveAll (char * Arg,char * MatchChars,int qtflag)
{
   PCHAR  C=Arg;
   PCHAR  pmc;
  while(*Arg)
    {
      if(qtflag)
        {
          if(*Arg==34)
            {
              *(C++)=*Arg;
              while(*(++Arg)!=34)
                {
                  *(C++)=*Arg;
                  if(*Arg==0)
                    {
                      return;
                    }
                }
              *(C++)=*(Arg++);
              continue;
            }
        }
      pmc=MatchChars;
      while(*pmc)
        {
          if(*(pmc++)==*Arg)
            {
              goto SKIP;
            }
        }
      *(C++)=*Arg;

SKIP:;
      Arg++;
    }
  *C=0;
}


void Warning (char * ZZ,int WarnLvl)
{
  static  FILE   *fErr;
  memset(&fErr,0,sizeof(fErr));
  if(WarnLvl)
    {
      strcpy(WarnMsg, join(7,WarnMsg," Line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," - ",ZZ));
    }
  else
    {
      strcat(WarnMsg,ZZ);
    }
  strcat(WarnMsg,CRLF);
  if(ErrFile)
    {
      if((fErr=fopen(FileErr,"a"))==0)
       {
         fprintf(stderr,"Can't open file %s\n",FileErr);
         exit(1);
       }
      fprintf(fErr,"%s%s\n","WARNING ",ZZ);
      if(fErr)
       {
         fclose(fErr);
         fErr=NULL;
       }
    }
}


PCHAR GetVarTypeName (int i)
{
  static char A[2048];
  for(;;)
  {
    if(i==vt_INTEGER)
      {
        strcpy(A,"int");
        break;
      }
    if(i==vt_STRVAR)
      {
        strcpy(A,"char *");
        break;
      }
    if(i==vt_STRLIT)
      {
        strcpy(A,"STRLIT");
        break;
      }
    if(i==vt_UNKNOWN)
      {
        strcpy(A,"UNKNOWN");
        break;
      }
    if(i==vt_SINGLE)
      {
        strcpy(A,"float");
        break;
      }
    if(i==vt_DOUBLE)
      {
        strcpy(A,"double");
        break;
      }
    if(i==vt_LDOUBLE)
      {
        strcpy(A,"LDOUBLE");
        break;
      }
    if(i==vt_DECFUNC)
      {
        strcpy(A,"DECFUNC");
        break;
      }
    if(i==vt_NUMBER)
      {
        strcpy(A,"NUMBER");
        break;
      }
    if(i==vt_FILEPTR)
      {
        strcpy(A,"FILE*");
        break;
      }
    if(i==vt_UDT)
      {
        strcpy(A,"struct");
        break;
      }
    if(i==vt_STRUCT)
      {
        strcpy(A,"struct");
        break;
      }
    if(i==vt_UNION)
      {
        strcpy(A,"union");
        break;
      }
    if(i==vt_BOOL)
      {
        strcpy(A,"bool");
        break;
      }
    if(i==vt_CHAR)
      {
        strcpy(A,"char");
        break;
      }
    if(i==vt_CHARPTR)
      {
        strcpy(A,"char");
        break;
      }
    if(i==vt_PCHAR)
      {
        strcpy(A,"PCHAR");
        break;
      }
    if(i==vt_VOID)
      {
        strcpy(A,"void");
        break;
      }
    if(i==vt_LONG)
      {
        strcpy(A,"long");
        break;
      }
    if(i==vt_DWORD)
      {
        strcpy(A,"DWORD");
        break;
      }
    if(i==vt_FARPROC)
      {
        strcpy(A,"FARPROC");
        break;
      }
    if(i==vt_LPBYTE)
      {
        strcpy(A,"LPBYTE");
        break;
      }
    if(i==vt_LRESULT)
      {
        strcpy(A,"LRESULT");
        break;
      }
    if(i==vt_BYTE)
      {
        strcpy(A,"BYTE");
        break;
      }
    if(i==vt_SHORT)
      {
        strcpy(A,"short");
        break;
      }
    if(i==vt_USHORT)
      {
        strcpy(A,"USHORT");
        break;
      }
    if(i==vt_COLORREF)
      {
        strcpy(A,"COLORREF");
        break;
      }
    if(i==vt_UINT)
      {
        strcpy(A,"UINT");
        break;
      }
    if(i==vt_ULONG)
      {
        strcpy(A,"ULONG");
        break;
      }
    if(i==vt_HANDLE)
      {
        strcpy(A,"HANDLE");
        break;
      }
    if(i==vt_HINSTANCE)
      {
        strcpy(A,"HINSTANCE");
        break;
      }
    if(i==vt_HDC)
      {
        strcpy(A,"HDC");
        break;
      }
    if(i==vt_VARIANT)
      {
        strcpy(A,"VARIANT");
        break;
      }
      // case else
      {
        *A=0;
      }
    break;
  }
  return A;
}


int HashNumber (char *HT)
{
   char*  TT;
   ULONG  i=0;
  TT=HT;
  while(*TT)
    {
      i<<=1;
  i ^= *TT;
      TT++;
    }
  return imod(i,MaxGlobalVars);
}


void AddLibrary (char *LibName)
{
  static int     nTimes;
  static int     nLibNdx;
  memset(&nLibNdx,0,sizeof(nLibNdx));
  char TempLibName[2048];
  strcpy(TempLibName,lcase(LibName));
  if(!inchr(TempLibName,DQ)&&!inchr(TempLibName,"<"))
    {
      strcpy(TempLibName,enc(TempLibName,60,62));
    }
  if(nTimes==0)
    {
        {int i;
      for(i=0; i<=MaxLib-1; i+=1)
        {
          *Library[i]=0;
        }
        }
      nTimes++;
      strcpy(Library[0],TempLibName);
      return;
    }
  nLibNdx=0;
  while(Library[nLibNdx][0]!=0)
    {
      if(str_cmp(Library[nLibNdx],TempLibName)==0)
        {
          return;
        }
      nLibNdx++;
    }
  if(nLibNdx<MaxLib-1)
    {
      strcpy(Library[nLibNdx],TempLibName);
    }
}


void RemoveLibrary (char *LibName)
{
  if(!instr_b(RmLibs,LibName,1,1))
    {
      strcpy(RmLibs, join(3,RmLibs,",",lcase(LibName)));
    }
}


void EmitLibs (void)
{
  static int     nTimes;
  static int     nCount;
  char ltmp[2048];
  if(nTimes>0)
    {
      return;
    }
  nTimes++;
  if(Library[0][0]==0)
    {
      return;
    }
  fprintf(FP7,"%s\n","");
  fprintf(FP7,"%s\n","#ifndef LINUXBCX");
  fprintf(FP7,"%s\n","#if !defined( __LCC__ )");
    {int i;
  for(i=0; i<=MaxLib-1; i+=1)
    {
      if(Library[i][0]==0&&nCount>0)
        {
          goto NEXTLIB;
        }
      else if(Library[i][0]==0)
        {
          goto NEXTLIB;
        }
      strcpy(ltmp,Library[i]);
      RemoveAll(ltmp,join(2,"<>",DQ));
      if(instr_b(RmLibs,ltmp))
        {
          continue;
        }
      if(nCount==0)
        {
          nCount++;
          fprintf(FP7,"%s\n","// *************************************************");
          fprintf(FP7,"%s\n","// Instruct Linker to Search Object/Import Libraries");
          fprintf(FP7,"%s\n","// *************************************************");
        }
      fprintf(FP7,"%s%s%s\n","#pragma comment(lib,",enc(ltmp),")");
    }
    }

NEXTLIB:;
  fprintf(FP7,"%s\n","#else");
  strcat(RmLibs,",<libc.lib>,<kernel32.lib>,<comdlg32.lib>,<user32.lib>,<gdi32.lib>,<advapi32.lib>,<comctl32.lib>,<crtdll.lib>");
    {int i;
  for(i=0; i<=MaxLib-1; i+=1)
    {
      if(Library[i][0]==0&&nCount>0)
        {
          fprintf(FP7,"%s\n","// *************************************************");
          fprintf(FP7,"%s\n","// End of Object/Import Libraries To Search");
          fprintf(FP7,"%s\n","// *************************************************");
          goto LIBEND;
        }
      else if(Library[i][0]==0)
        {
          goto LIBEND;
        }
      if(instr_b(RmLibs,Library[i]))
        {
          continue;
        }
      if(nCount==0)
        {
          nCount++;
          fprintf(FP7,"%s\n","");
          fprintf(FP7,"%s\n","// *************************************************");
          fprintf(FP7,"%s\n","// Instruct Linker to Search Object/Import Libraries");
          fprintf(FP7,"%s\n","// *************************************************");
        }
      fprintf(FP7,"%s%s\n","#pragma lib ",Library[i]);
    }
    }

LIBEND:;
  fprintf(FP7,"%s\n","#endif");
  fprintf(FP7,"%s\n","#endif     // LINUXBCX not defined");
}


void AddGlobal (char * GlobalName,int GlobalType,int GlobalDef,char * GlobalDim,int GlobalPtr,int GlobalFS,int GlobalExtn,int iEmitted,int iConst)
{
  char FirstVar[2048];
  char SecondVar[2048];
  char Warn[2048];
  int     ss;
  int     s;
  if(RestrictedWords(GlobalName)&&TestState)
    {
      strcpy(Warn, join(3,"Restricted Word ",GlobalName," on Line"));
      strcpy(Warn, join(4,Warn,str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])));
      Warning(Warn);
    }
  ss=HashNumber(GlobalName);
  while(GlobalVarHash[ss])
    {
      s=GlobalVarHash[ss];
      if(str_cmp(GlobalName,GlobalVars[s].VarName)==0)
        {
          if(InConditional==0||(InConditional>0&&str_cmp(InIfDef,GlobalVars[s].VarCondDef)==0))
            {
              if(GlobalVars[s].VarType!=GlobalType||str_cmp(GlobalDim,GlobalVars[s].VarDim)!=0 || GlobalVars[s].VarDef!=GlobalDef)
                {
                  strcpy(FirstVar, join(11,"Line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," : ",GlobalName,GlobalDim," as ",GetVarTypeName(GlobalType)," ",TypeDefs[GlobalDef].VarName));
                  strcpy(SecondVar, join(11,"Line",str(GlobalVars[s].VarLine)," in Module: ",GlobalVars[s].VarModule," : ",GlobalName,GlobalVars[s].VarDim," as ",GetVarTypeName(GlobalVars[s].VarType)," ",TypeDefs[GlobalVars[s].VarDef].VarName));
                  strcpy(Warn, join(4,"Two Variables ",FirstVar," previously defined at ",SecondVar));
                  Warning(Warn);
                }
              return;
            }
        }
      ss=imod(ss+1,MaxGlobalVars);
    }
  GlobalVarCnt++;
  if(GlobalVarCnt==MaxGlobalVars)
    {
      Abort("Maximum Global Variables reached.");
    }
  strcpy(GlobalVars[GlobalVarCnt].VarName,GlobalName);
  GlobalVars[GlobalVarCnt].VarType=GlobalType;
  GlobalVars[GlobalVarCnt].VarDef=GlobalDef;
  strcpy(GlobalVars[GlobalVarCnt].VarDim,GlobalDim);
  GlobalVars[GlobalVarCnt].VarLine=ModuleLineNos[ModuleNdx];
  GlobalVars[GlobalVarCnt].VarPntr=GlobalPtr;
  GlobalVars[GlobalVarCnt].VarSF=GlobalFS;
  GlobalVars[GlobalVarCnt].VarEmitFlag=iEmitted;
  strcpy(GlobalVars[GlobalVarCnt].VarModule,trim(Modules[ModuleNdx]));
  GlobalVars[GlobalVarCnt].VarExtn=GlobalExtn;
  GlobalVars[GlobalVarCnt].VarCondLevel=InConditional;
  GlobalVars[GlobalVarCnt].VarConstant=iConst;
  strcpy(GlobalVars[GlobalVarCnt].VarCondDef,InIfDef);
  GlobalVarHash[ss]=GlobalVarCnt;
}


void AddLocal (char * LocalName,int LocalType,int LocalDef,char * LocalDim,int LocalPtr,int LocalFS,int iEmitted,int iConst)
{
  int     varid=0;
  char FirstVar[2048];
  char SecondVar[2048];
  char Warn[2048];
  int     s;
  if(LocalVarCnt&&TestState)
    {
      if(CheckGlobal(LocalName, &varid)!=vt_UNKNOWN)
        {
          if(LocalDef)
            {
              strcpy(FirstVar, join(9,"Line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," : ",LocalName,LocalDim," as ",TypeDefs[LocalDef].VarName));
            }
          else
            {
              strcpy(FirstVar, join(9,"Line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," : ",LocalName,LocalDim," as ",GetVarTypeName(LocalType)));
            }
          if(GlobalVars[varid].VarDef)
            {
              strcpy(SecondVar, join(9,"Line",str(GlobalVars[varid].VarLine)," in Module: ",GlobalVars[varid].VarModule," : ",LocalName,GlobalVars[varid].VarDim," as ",TypeDefs[GlobalVars[varid].VarDef].VarName));
            }
          else
            {
              strcpy(SecondVar, join(9,"Line",str(GlobalVars[varid].VarLine)," in Module: ",GlobalVars[varid].VarModule," : ",LocalName,GlobalVars[varid].VarDim," as ",GetVarTypeName(GlobalVars[varid].VarType)));
            }
          strcpy(Warn, join(5,"Local Variable ",FirstVar,CRLF,"Has Same Name as Global ",SecondVar));
          Warning(Warn);
        }
      for(s=1; s<=LocalVarCnt; s+=1)
        {
          if(str_cmp(LocalName,LocalVars[s].VarName)==0)
            {
              if(LocalVars[s].VarType!=LocalType||str_cmp(LocalDim,LocalVars[s].VarDim)!=0 || LocalVars[s].VarDef!=LocalDef)
                {
                  strcpy(FirstVar, join(11,"Line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," : ",LocalName,LocalDim," as ",GetVarTypeName(LocalType)," ",TypeDefs[LocalDef].VarName));
                  strcpy(SecondVar, join(11,"Line",str(LocalVars[s].VarLine)," in Module: ",LocalVars[s].VarModule," : ",LocalName,LocalVars[s].VarDim," as ",GetVarTypeName(LocalVars[s].VarType)," ",TypeDefs[LocalVars[s].VarDef].VarName));
                  strcpy(Warn, join(4,"Two Variables ",FirstVar," previously defined at ",SecondVar));
                  Warning(Warn);
                }
              return;
            }
        }
    }
  LocalVarCnt++;
  if(LocalVarCnt==MaxLocalVars)
    {
      strcpy(Warn,"Maximum Local Variables reached.");
      Abort(Warn);
    }
  strcpy(LocalVars[LocalVarCnt].VarName,LocalName);
  LocalVars[LocalVarCnt].VarType=LocalType;
  LocalVars[LocalVarCnt].VarDef=LocalDef;
  strcpy(LocalVars[LocalVarCnt].VarDim,LocalDim);
  LocalVars[LocalVarCnt].VarLine=ModuleLineNos[ModuleNdx];
  LocalVars[LocalVarCnt].VarPntr=LocalPtr;
  LocalVars[LocalVarCnt].VarSF=LocalFS;
  LocalVars[LocalVarCnt].VarEmitFlag=iEmitted;
  LocalVars[LocalVarCnt].VarConstant=iConst;
  strcpy(LocalVars[LocalVarCnt].VarModule,trim(Modules[ModuleNdx]));
}


int IsNumber (char *a)
{
  int     i=0;
  if(!*a)
    {
      return FALSE;
    }
  while(a[i])
    {
      if(a[i]>47&&a[i]<58)
        {
          i++;
        }
      else
        {
          return FALSE;
        }
    }
  return TRUE;
}


int IsNumberEx (char *a)
{
  int     i=0;
  if(!*a)
    {
      return FALSE;
    }
  while(a[i])
    {
      if(a[i]>44&&a[i]<58)
        {
          i++;
        }
      else
        {
          return FALSE;
        }
    }
  return TRUE;
}


void StripTabs (void)
{
  int     i=0;
  while(Src[i])
    {
      if(Src[i]==9)
        {
          Src[i]=32;
        }
      i++;
    }
}


void PushFileIO (void)
{
  FPtr[++FPtrNdx]=SourceFile;
}


void PopFileIO (void)
{
  if(FPtrNdx==0)
    {
      return;
    }
  if(SourceFile)
   {
     fclose(SourceFile);
     SourceFile=NULL;
   }
  LinesRead+=(ModuleLineNos[ModuleNdx--]);
  SourceFile=FPtr[FPtrNdx--];
}


int Inset (char *Mane, char *Match)
{
  int     i=-1;
  int     j=-1;
  while(Match[++i])
    {
      while(Mane[++j])
        {
          if(Match[i]==Mane[j])
            {
              return TRUE;
            }
        }
      j=-1;
    }
  return FALSE;
}


void CheckParQuotes (void)
{
  int     CountR=0;
  int     CountS=0;
  int     i=0;
   bool  DoCount=TRUE;
  while(Src[i])
    {
      if(Src[i]==34)
        {
          DoCount=!DoCount;
        }
      if(DoCount)
        {
          if(Src[i]==40)
            {
              CountR++;
            }
          else if(Src[i]==41)
            {
              CountR--;
            }
          else if(Src[i]==91)
            {
              CountS++;
            }
          else if(Src[i]==93)
            {
              CountS--;
            }
        }
      i++;
    }
  if(!DoCount)
    {
      Abort("Unmatched Quotes");
    }
  else if(CountS)
    {
      Abort("Unmatched []");
    }
  else if(CountR)
    {
      Abort("Unmatched ()");
    }
}


void ClearIfThenStacks (void)
{
    {int i;
  for(i=0; i<=127; i+=1)
    {
      *SrcStk[i]=0;
    }
    }
  SrcCnt=0;
}


int IsQuoted (char *ZZ)
{
  if(!iMatchLft(ltrim(ZZ),DQ))
    {
      return 0;
    }
  if(!iMatchRgt(rtrim(ZZ),DQ))
    {
      return 0;
    }
  return TRUE;
}


void PostProcess (void)
{
  int     A;
  if(ReDirect==TRUE)
    {
      if((FP1=fopen(FileOut,"r"))==0)
       {
         fprintf(stderr,"Can't open file %s\n",FileOut);
         exit(1);
       }
      while(!EoF(FP1))
        {
          Z[0]=0;
          AR_fgets_retval=fgets(Z,65535,FP1);
          if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
          printf("%s\n",Z);
        }
      CloseAll();
    }
  strcpy(OutfileClone,FileOut);
  for(A=1; A<=EntryCnt; A+=1)
    {
      strcpy(OutfileClone,extract(OutfileClone,"."));
      strcpy(Cmd,RemoveStr(Entry[A],DQ));
      strcpy(Cmd,replace(Cmd,"\\\\","\\"));
      strcpy(Cmd,iReplace(Cmd,"$file$",extract(OutfileClone,".")));
      printf("%s%s\n","Shelling Out To: ",Cmd);
      Shell(Cmd);
    }
  if(Compiler[0]>0)
    {
      strcpy(Compiler,trim(RemoveStr(Compiler,DQ)));
      if(inchr(Compiler," "))
        {
          strcpy(Compiler, join(3,enc(extract(Compiler," "))," ",remain(Compiler," ")));
        }
      else
        {
          strcpy(Compiler,enc(Compiler));
        }
      strcpy(FileOut, join(2,extract(FileOut,"."),".cc"));
      strcpy(Compiler, join(3,Compiler," ",FileOut));
      strcpy(Compiler,iReplace(Compiler,"$FILE$",extract(OutfileClone,".")));
      strcpy(Compiler,replace(Compiler,"\\\\","\\"));
      strcpy(Compiler,replace(Compiler,DDQ,DQ));
      printf("%s%s\n","Shelling Out To: ",Compiler);
      Shell(Compiler);
    }
  if(Linker[0]>0)
    {
      strcpy(Linker,trim(RemoveStr(Linker,DQ)));
      if(inchr(Linker," "))
        {
          strcpy(Linker, join(5,DQ,extract(Linker," "),DQ," ",remain(Linker," ")));
        }
      else
        {
          strcpy(Linker,enc(Linker));
        }
      strcpy(FileOut, join(2,extract(FileOut,"."),".obj"));
      strcpy(Linker, join(3,Linker," ",FileOut));
      strcpy(Linker,iReplace(Linker,"$FILE$",extract(OutfileClone,".")));
      strcpy(Linker,replace(Linker,"\\\\","\\"));
      strcpy(Linker,replace(Linker,DDQ,DQ));
      printf("%s%s\n","Shelling Out To:",Linker);
      Shell(Linker);
    }
  for(A=1; A<=XitCount; A+=1)
    {
      strcpy(FileOut,extract(FileOut,"."));
      strcpy(Cmd,RemoveStr(Xit[A],DQ));
      strcpy(Cmd,iReplace(Cmd,"$FILE$",extract(OutfileClone,".")));
      strcpy(Cmd,replace(Cmd,"\\\\","\\"));
      strcpy(Cmd,replace(Cmd,DDQ,DQ));
      printf("%s%s\n","Shelling Out To: ",Cmd);
      Shell(Cmd);
    }
}


void XParse (char *Arg)
{
  char lszTmp[2048];
  int     j;
  int     i=0;
  int     Gapflag=0;
  int     InIF=0;
  if(str_cmp(trim(Arg),"")==0)
    {
      Ndx=0;
      return;
    }
  i=iMatchNQ(Arg,"&&");
  while(i)
    {
      strcpy(Arg,del(Arg,i,2));
      strcpy(Arg,ins(Arg,i," and "));
      i=iMatchNQ(Arg,"&&");
    }
  FastLexer(Arg,SPC,"=&()[]{}',+-*/<>?;.|:^");
  while(++i<17)
    {
      *Stk[i+Ndx]=0;
    }
  for(i=1; i<=Ndx; i+=1)
    {
      strcpy(Keyword1,lcase(Stk[i]));
      if(Keyword1[1]!=0)
        {
          for(;;)
          {
            if(str_cmp(Keyword1,"and")==0)
              {
                strcpy(Stk[i],"&&");
                break;
              }
            if(str_cmp(Keyword1,"or")==0)
              {
                strcpy(Stk[i],"||");
                break;
              }
            if(str_cmp(Keyword1,"not")==0)
              {
                strcpy(Stk[i],"!");
                break;
              }
            if(str_cmp(Keyword1,"is")==0)
              {
                strcpy(Stk[i],"=");
                break;
              }
            if(str_cmp(Keyword1,"xor")==0)
              {
                strcpy(Stk[i],"xor");
                break;
              }
            if(str_cmp(Keyword1,"if")==0 ||  str_cmp(Keyword1,"iif")==0 ||  str_cmp(Keyword1,"iif$")==0 ||  str_cmp(Keyword1,"case")==0 ||  str_cmp(Keyword1,"elseif")==0 ||  str_cmp(Keyword1,"while")==0)
              {
                InIF=1;
                break;
              }
            if(str_cmp(Keyword1,"then")==0)
              {
                InIF=0;
                break;
              }
            if(str_cmp(Keyword1,"byval")==0)
              {
                *Stk[i]=0;
                Gapflag=TRUE;
                break;
              }
            if(str_cmp(Keyword1,"byref")==0)
              {
                if(!iMatchWrd(Stk[1],"declare")&&!iMatchWrd(Stk[1],"c_declare"))
                  {
                    strcpy(ByrefVars[++ByrefCnt],Stk[i+1]);
                  }
                for(j=i; j<=Ndx; j+=1)
                  {
                    if(str_cmp(Stk[j+1],",")==0 ||  str_cmp(Stk[j+1],")")==0)
                      {
                        strcpy(Stk[j],"PTR");
                        break;
                      }
                    strcpy(Stk[j],Stk[j+1]);
                  }
                break;
              }
              // case else
              {
                if(PassOne)
                  {
                    if(str_cmp(Keyword1,enc(chr(92)))==0)
                      {
                        strcpy(Stk[i],"chr$");
                        InsertTokens(i,3,"(","92",")");
                        i+=(3);
                      }
                    else if(TranslateSlash)
                      {
                        strcpy(Stk[i],replace(Stk[i],"\\","\\\\"));
                      }
                  }
              }
            break;
          }
          if(!InIF)
            {
              if(str_cmp(Stk[i],"&&")==0)
                {
                  strcpy(Stk[i],"BAND");
                }
              else if(str_cmp(Stk[i],"||")==0)
                {
                  strcpy(Stk[i],"BOR");
                }
            }
        }
      else
        {
          for(;;)
          {
            if((UCHAR)*(Keyword1)==38)
              {
                if(i<3||inchr("+&,(=",Stk[i-1]))
                  {
                    strcpy(Stk[i+1], join(2," &",Stk[i+1]));
                    *Stk[i]=0;
                    Gapflag=TRUE;
                  }
                break;
              }
            if((UCHAR)*(Keyword1)==63)
              {
                strcpy(Stk[i],"print");
                break;
              }
            if((UCHAR)*(Keyword1)==45)
              {
                if((UCHAR)*(Stk[i+1])==62)
                  {
                    strcpy(Stk[i], join(2,"->",Stk[i+2]));
                    *Stk[++i]=0;
                    *Stk[++i]=0;
                    Gapflag=TRUE;
                  }
                break;
              }
            if((UCHAR)*(Keyword1)==46)
              {
                if(IsNumber(Stk[i-1]))
                  {
                    strcpy(Stk[i], join(2,Stk[i-1],"."));
                    *Stk[i-1]=0;
                    Gapflag=TRUE;
                  }
                if(!inchr(",)=<>*/+-^",Stk[i+1]))
                  {
                    strcpy(Stk[i], join(2,Stk[i],Stk[i+1]));
                    *Stk[++i]=0;
                    Gapflag=TRUE;
                  }
              }
            break;
          }
        }
    }
  if(Gapflag)
    {
      for(i=1; i<=Ndx; i+=1)
        {
          if(!*Stk[i])
            {
              j=i+1;
              while(!*Stk[j]&&(j<Ndx))
                {
                  j++;
                }
              if(!*Stk[j])
                {
                  break;
                }
              strcpy(Stk[i],Stk[j]);
              *Stk[j]=0;
            }
        }
      Ndx=i-1;
    }
  if(PassOne==1)
    {
      if(InFunc)
        {
          for(i=1; i<=Ndx; i+=1)
            {
              for(j=1; j<=ByrefCnt; j+=1)
                {
                  if(iMatchLft(Stk[i]," &"))
                    {
                      strcpy(lszTmp,Stk[i]+2);
                    }
                  else
                    {
                      strcpy(lszTmp,Stk[i]);
                    }
                  if(str_cmp(Clean(lszTmp),Clean(ByrefVars[j]))==0)
                    {
                      if(i>2)
                        {
                          if(inchr("+-^%*/|&<=>,",Stk[i-2])&&str_cmp(Stk[i-1],"*")==0)
                            {
                              *Stk[i-1]=0;
                            }
                          if(iMatchLft(Stk[i]," &"))
                            {
                              strcpy(Stk[i],Stk[i]+2);
                              break;
                            }
                        }
                      else if(i==2)
                        {
                          if(str_cmp(Stk[i-1],"*")==0)
                            {
                              *Stk[i-1]=0;
                            }
                        }
                      strcpy(Stk[i], join(2,"*",Stk[i]));
                      if(str_cmp(Stk[i-1],"(")!=0 ||  str_cmp(Stk[i+1],")")!=0)
                        {
                          strcpy(Stk[i],enc(Stk[i],40,41));
                        }
                      break;
                    }
                }
            }
        }
    }
  if(iMatchWrd(Stk[1],"dim"))
    {
      if(iMatchWrd(Stk[Ndx-1],"static"))
        {
          strcpy(Stk[1],"static");
          strcpy(Stk[Ndx-1],Stk[Ndx]);
          Ndx--;
        }
    }
  strcpy(Keyword1,lcase(Stk[1]));
  if(InTypeDef)
    {
      if(str_cmp(Keyword1,"end")!=0 &&  str_cmp(Keyword1,"dim")!=0 &&  str_cmp(Keyword1,"declare")!=0 &&  str_cmp(Keyword1,"type")!=0 &&  str_cmp(Keyword1,"union")!=0)
        {
          InsertTokens(0,1,"dim");
        }
    }
  if(!InTypeDef)
    {
      char lsz[2048];
      int     Res=1;
      strcpy(lsz, join(3,SPC,Keyword1,SPC));
      if(iMatchNQ(" dim , local , global , raw , static , shared , dynamic , auto , register , extern ",lsz))
        {
          Res=1;
        }
      strcpy(lsz, join(3,SPC,lcase(Stk[2]),SPC));
      if(iMatchNQ(" dim , local , global , raw , static , shared , dynamic , auto , register , extern ",lsz))
        {
          Res=2;
        }
      if(Res>0)
        {
          i=Ndx;
          while(i>1&&str_cmp(Stk[i],")")!=0)
            {
              if(iMatchWrd(Stk[i],"as"))
                {
                  if(iMatchWrd(Stk[i+1],"function"))
                    {
                      if(i+1==Ndx)
                        {
                          *Stk[i]=0;
                        }
                      *Stk[i+1]=0;
                      InsertTokens(Res,1,"function");
                    }
                  else if(iMatchWrd(Stk[i+1],"sub"))
                    {
                      if(i+1==Ndx)
                        {
                          *Stk[i]=0;
                        }
                      *Stk[i+1]=0;
                      InsertTokens(Res,1,"sub");
                    }
                  RemEmptyTokens();
                  break;
                }
              i--;
            }
        }
    }
  if(InTypeDef||iMatchWrd(Stk[1],"declare")||iMatchWrd(Stk[1],"c_declare"))
    {
      if(iMatchWrd(Stk[2],"sub")||iMatchWrd(Stk[2],"function"))
        {
            {int i;
          for(i=2; i<=Ndx; i+=1)
            {
              if(iMatchLft(Stk[i],"as")&&iMatchWrd(Stk[i+1],"string"))
                {
                  if(*Stk[i+2]!=42)
                    {
                      strcpy(Stk[i+1],"char *");
                    }
                }
            }
            }
        }
    }
}


void TokenSubstitutions (void)
{
  int     A;
  int     CompPtr;
  int     CompToken;
  char Keyword[2048];
  int     a;
  int     i;
  int     j;
  int     Tmp;
  for(i=1; i<=Ndx; i+=1)
    {
      if(iMatchWrd(Stk[i],"as"))
        {
          if(iMatchWrd(Stk[i+1],"string"))
            {
              if(str_cmp(Stk[i+2],"*")==0)
                {
                  strcpy(Stk[i],"[");
                  strcpy(Stk[i+1],Stk[i+3]);
                  strcpy(Stk[i+2],"]");
                  strcpy(Stk[i+3],"as");
                  Ndx++;
                  strcpy(Stk[Ndx],"char");
                  break;
                }
            }
        }
    }
  for(i=1; i<=Ndx; i+=1)
    {
      if(!InFunc)
        {
          if(iMatchWrd(Stk[i],"global"))
            {
              strcpy(Stk[i],"dim");
            }
        }
    }
  A=FALSE;
  for(Tmp=1; Tmp<=Ndx; Tmp+=1)
    {
      if(*Stk[Tmp]==48&&Stk[Tmp][1]!=120&&Stk[Tmp][1]!=108)
        {
          strcpy(Stk[Tmp],ltrim(Stk[Tmp],48));
          if(Stk[Tmp][0]==0)
            {
              strcpy(Stk[Tmp],"0");
            }
        }
      if(iMatchWrd(Stk[Tmp],"xor"))
        {
          strcpy(Stk[Tmp],"^");
        }
      else if(str_cmp(Stk[Tmp],"=")==0 &&  str_cmp(Stk[Tmp+1],">")==0)
        {
          strcpy(Stk[Tmp],">");
          strcpy(Stk[Tmp+1],"=");
        }
      else if(str_cmp(Stk[Tmp],"=")==0 &&  str_cmp(Stk[Tmp+1],"<")==0)
        {
          strcpy(Stk[Tmp],"<");
          strcpy(Stk[Tmp+1],"=");
        }
      else if(str_cmp(Stk[Tmp],"<")==0 &&  str_cmp(Stk[Tmp+1],">")==0)
        {
          strcpy(Stk[Tmp],"!=");
          *Stk[Tmp+1]=0;
          A=TRUE;
        }
      else if(str_cmp(Stk[Tmp],">")==0 &&  str_cmp(Stk[Tmp+1],"<")==0)
        {
          strcpy(Stk[Tmp],"!=");
          *Stk[Tmp+1]=0;
          A=TRUE;
        }
      else if(str_cmp(Stk[Tmp],"!")==0 &&  str_cmp(Stk[Tmp+1],"=")==0)
        {
          strcpy(Stk[Tmp],"!=");
          *Stk[Tmp+1]=0;
          A=TRUE;
        }
    }
  if(A==TRUE)
    {
      RemEmptyTokens();
    }
  CompToken=0;
  for(Tmp=1; Tmp<=Ndx; Tmp+=1)
    {
      A=CheckLocal(Stk[Tmp], &i);
      if(A==vt_UNKNOWN)
        {
          A=CheckGlobal(Stk[Tmp], &i);
        }
      if(A==vt_STRUCT||A==vt_UDT||A==vt_UNION)
        {
          CompToken=1;
        }
      if(iMatchWrd(Stk[Tmp],"int")&&str_cmp(Stk[Tmp+1],"(")==0)
        {
          strcpy(Stk[Tmp],"fint");
        }
      else if(iMatchWrd(Stk[Tmp],"integer"))
        {
          strcpy(Stk[Tmp],"int");
        }
      else if(iMatchWrd(Stk[Tmp],"fint")&&str_cmp(Stk[Tmp+1],")")==0)
        {
          strcpy(Stk[Tmp],"int");
        }
    }
  CompPtr=0;
  for(Tmp=1; Tmp<=Ndx; Tmp+=1)
    {
      strcpy(Keyword,lcase(Stk[Tmp]));
      a=inchr("abcdefghijklmnopqrstuvwxyz",Keyword);
      for(;;)
      {
        if(a==1)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"abs")==0)
                {
                  strcpy(Stk[Tmp],"abs");
                  break;
                }
              if(str_cmp(Keyword,"acos")==0)
                {
                  strcpy(Stk[Tmp],"acos");
                  break;
                }
              if(str_cmp(Keyword,"acosl")==0)
                {
                  strcpy(Stk[Tmp],"acosl");
                  break;
                }
              if(str_cmp(Keyword,"acosh")==0)
                {
                  strcpy(Stk[Tmp],"acosh");
                  break;
                }
              if(str_cmp(Keyword,"appexename$")==0)
                {
                  strcpy(Stk[Tmp],"AppExeName$()");
                  Use_AppExeName=Use_BcxSplitPath=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"appexepath$")==0)
                {
                  strcpy(Stk[Tmp],"AppExePath$()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  Use_AppExePath=Use_BcxSplitPath=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"ansitowide")==0)
                {
                  strcpy(Stk[Tmp],"AnsiToWide");
                  Use_AnsiToWide=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"argc")==0)
                {
                  strcpy(Stk[Tmp],"argc");
                  break;
                }
              if(str_cmp(Keyword,"argv")==0)
                {
                  strcpy(Stk[Tmp],"argv");
                  break;
                }
              if(str_cmp(Keyword,"argv$")==0)
                {
                  strcpy(Stk[Tmp],"argv$");
                  break;
                }
              if(str_cmp(Keyword,"asc")==0)
                {
                  i=0;
                  j=GetNumArgs(Tmp+2, &i);
                  if(*Stk[Tmp+2]==*DQ)
                    {
                      if(j>0||*Stk[Tmp+3]!=41)
                        {
                          strcpy(Stk[Tmp],"asc");
                          Use_Asc=TRUE;
                        }
                      else
                        {
                          if(str_cmp(Stk[Tmp+2],DDQ)==0)
                            {
                              strcpy(Stk[Tmp],"0");
                            }
                          else
                            {
                              strcpy(Stk[Tmp],ltrim(str((UCHAR)*(Stk[Tmp+2]+1))));
                            }
                          *Stk[Tmp+1]=0;
                          *Stk[Tmp+2]=0;
                          *Stk[Tmp+3]=0;
                        }
                    }
                  else
                    {
                      if(j>0)
                        {
                          strcpy(Stk[i],"+");
                        }
                      strcpy(Stk[Tmp],"(UCHAR)*");
                    }
                  break;
                }
              if(str_cmp(Keyword,"asin")==0)
                {
                  strcpy(Stk[Tmp],"asin");
                  break;
                }
              if(str_cmp(Keyword,"asinl")==0)
                {
                  strcpy(Stk[Tmp],"asinl");
                  break;
                }
              if(str_cmp(Keyword,"asinh")==0)
                {
                  strcpy(Stk[Tmp],"asinh");
                  break;
                }
              if(str_cmp(Keyword,"atanh")==0)
                {
                  strcpy(Stk[Tmp],"atanh");
                  break;
                }
              if(str_cmp(Keyword,"atn")==0 ||  str_cmp(Keyword,"atan")==0)
                {
                  strcpy(Stk[Tmp],"atan");
                  break;
                }
              if(str_cmp(Keyword,"atnl")==0 ||  str_cmp(Keyword,"atanl")==0)
                {
                  strcpy(Stk[Tmp],"atanl");
                  break;
                }
              if(str_cmp(Keyword,"auto")==0)
                {
                  if(iMatchWrd(Stk[Tmp+1],"local"))
                    {
                      strcpy(Stk[Tmp],"dim");
                      strcpy(Stk[Tmp+1],"raw");
                    }
                  else
                    {
                      strcpy(Stk[Tmp],"auto");
                    }
                }
              break;
            }
            break;
          }
        if(a==2)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"bcopy")==0)
                {
                  *Stk[1]=0;
                  for(i=Tmp+1; i<=Ndx; i+=1)
                    {
                      if(iMatchWrd(Stk[i],"to"))
                        {
                          break;
                        }
                      strcat(Stk[1],Stk[i]);
                    }
                  *Stk[2]=0;
                  for(i=i+1; i<=Ndx; i+=1)
                    {
                      strcat(Stk[2],Stk[i]);
                    }
                  strcpy(Src, join(7,"memmove(&",Stk[2],",&",Stk[1],",sizeof(",Stk[2],"))"));
                  strcpy(Src,RemoveStr(Src,"&*"));
                  Ndx=0;
                  XParse(Src);
                  break;
                }
              if(str_cmp(Keyword,"bel$")==0)
                {
                  strcpy(Stk[Tmp],"BEL$");
                  Use_BEL=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"bs$")==0)
                {
                  strcpy(Stk[Tmp],"BS$");
                  Use_BS=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"bool")==0 ||  str_cmp(Keyword,"boolean")==0)
                {
                  strcpy(Stk[Tmp],"bool");
                  break;
                }
              if(str_cmp(Keyword,"band")==0)
                {
                  strcpy(Stk[Tmp]," BAND ");
                  Use_Band=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"bnot")==0)
                {
                  strcpy(Stk[Tmp]," BNOT ");
                  Use_Bnot=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"bcx_font")==0)
                {
                  strcpy(Stk[Tmp],ucase(Stk[Tmp]));
                  char tmp[2048];
                  strcpy(tmp,Clean(ucase(Stk[Tmp+1])));
                  for(;;)
                  {
                    if(str_cmp(tmp,".NAME")==0)
                      {
                        strcpy(Stk[Tmp+1],".lf.lfFaceName$");
                        break;
                      }
                    if(str_cmp(tmp,".BOLD")==0)
                      {
                        strcpy(Stk[Tmp+1],".lf.lfWeight");
                        break;
                      }
                    if(str_cmp(tmp,".UNDERLINE")==0)
                      {
                        strcpy(Stk[Tmp+1],".lf.lfUnderline");
                        break;
                      }
                    if(str_cmp(tmp,".STRIKEOUT")==0)
                      {
                        strcpy(Stk[Tmp+1],".lf.lfStrikeOut");
                        break;
                      }
                    if(str_cmp(tmp,".ITALIC")==0)
                      {
                        strcpy(Stk[Tmp+1],".lf.lfItalic");
                        break;
                      }
                    if(str_cmp(tmp,".CHARSET")==0)
                      {
                        strcpy(Stk[Tmp+1],".lf.lfCharSet");
                        break;
                      }
                    if(str_cmp(tmp,".SIZE")==0 ||  str_cmp(tmp,".RGB")==0)
                      {
                        strcpy(Stk[Tmp+1],tmp);
                        break;
                      }
                      // case else
                      {
                        strcpy(Stk[Tmp+1],Clean(Stk[Tmp+1]));
                      }
                    break;
                  }
                  break;
                }
              if(str_cmp(Keyword,"bcxsplitpath$")==0)
                {
                  strcpy(Stk[Tmp],"$$BcxSplitPath$");
                  Use_BcxSplitPath=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"bcxpath$")==0)
                {
                  UseFlag=TRUE;
                  strcpy(Stk[Tmp],"BcxPath$()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  break;
                }
              if(str_cmp(Keyword,"bcxfont")==0)
                {
                  strcpy(Stk[Tmp],"BcxFont");
                  break;
                }
              if(str_cmp(Keyword,"bcxsocket")==0)
                {
                  strcpy(Stk[Tmp],"BcxSocket");
                  Use_Socket=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"bcxsocketsend")==0)
                {
                  strcpy(Stk[Tmp],"BcxSocketSend");
                  break;
                }
              if(str_cmp(Keyword,"bcxsocketread")==0)
                {
                  strcpy(Stk[Tmp],"BcxSocketRead");
                  break;
                }
              if(str_cmp(Keyword,"bcxsocketclose")==0)
                {
                  strcpy(Stk[Tmp],"BcxSocketClose");
                  break;
                }
              if(str_cmp(Keyword,"bcx_thread")==0 ||  str_cmp(Keyword,"bcx_threadwait")==0 ||  str_cmp(Keyword,"bcx_threadsuspend")==0 ||  str_cmp(Keyword,"bcx_threadresume")==0 ||  str_cmp(Keyword,"bcx_threadkill")==0 ||  str_cmp(Keyword,"bcx_threadend")==0)
                {
                  strcpy(Stk[Tmp],ucase(Stk[Tmp]));
                  Use_Threads=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"bin$")==0)
                {
                  strcpy(Stk[Tmp],"$$Bin$");
                  Use_Bin=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"bool$")==0)
                {
                  strcpy(Stk[Tmp],"$$BoolStr$");
                  Use_Boolstr=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"bin2dec")==0)
                {
                  strcpy(Stk[Tmp],"Bin2Dec");
                  Use_Bin2dec=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"boolean")==0)
                {
                  strcpy(Stk[Tmp],"BOOLEAN");
                  break;
                }
              if(str_cmp(Keyword,"bor")==0)
                {
                  strcpy(Stk[Tmp]," BOR ");
                  Use_Bor=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"byte")==0)
                {
                  strcpy(Stk[Tmp],"BYTE");
                }
              break;
            }
            break;
          }
        if(a==3)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"containedin")==0)
                {
                  strcpy(Stk[Tmp],"containedin");
                  Use_ContainedIn=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"copyfile")==0)
                {
                  Use_CopyFile=TRUE;
                  Use_Exist=Use_Lof=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"cr$")==0)
                {
                  strcpy(Stk[Tmp],"CR$");
                  Use_CR=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"close#")==0)
                {
                  strcpy(Stk[Tmp],"close");
                  break;
                }
              if(str_cmp(Keyword,"close")==0)
                {
                  if(str_cmp(left(Stk[Tmp+1],1),"#")==0)
                    {
                      strcpy(Stk[Tmp+1],mid(Stk[Tmp+1],2));
                    }
                  break;
                }
              if(str_cmp(Keyword,"cvd")==0)
                {
                  strcpy(Stk[Tmp],"CVD");
                  Use_Cvd=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"cvi")==0)
                {
                  strcpy(Stk[Tmp],"CVI");
                  Use_Cvi=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"cvl")==0)
                {
                  strcpy(Stk[Tmp],"CVL");
                  Use_Cvl=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"cvld")==0)
                {
                  strcpy(Stk[Tmp],"CVLD");
                  Use_Cvld=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"cvs")==0)
                {
                  strcpy(Stk[Tmp],"CVS");
                  Use_Cvs=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"concat")==0)
                {
                  strcpy(Stk[Tmp],"strcat");
                  break;
                }
              if(str_cmp(Keyword,"chr$")==0)
                {
                  strcpy(Stk[Tmp],"$$chr$");
                  Use_Chr=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"char")==0)
                {
                  strcpy(Stk[Tmp],"char");
                  break;
                }
              if(str_cmp(Keyword,"crlf$")==0)
                {
                  strcpy(Stk[Tmp],"CRLF$");
                  Use_Crlf=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"cbctl")==0)
                {
                  strcpy(Stk[Tmp],"LOWORD(wParam)");
                  break;
                }
              if(str_cmp(Keyword,"cbctlmsg")==0)
                {
                  strcpy(Stk[Tmp],"HIWORD(wParam)");
                  break;
                }
              if(str_cmp(Keyword,"cblparam")==0)
                {
                  strcpy(Stk[Tmp],"lParam");
                  break;
                }
              if(str_cmp(Keyword,"cbmsg")==0)
                {
                  strcpy(Stk[Tmp],"Msg");
                  break;
                }
              if(str_cmp(Keyword,"cbwparam")==0)
                {
                  strcpy(Stk[Tmp],"wParam");
                  break;
                }
              if(str_cmp(Keyword,"cdbl")==0)
                {
                  strcpy(Stk[Tmp],"CDBL");
                  Use_Cdbl=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"chdrive")==0 ||  str_cmp(Keyword,"chdir")==0)
                {
                  strcpy(Stk[Tmp],"chdir");
                  break;
                }
              if(str_cmp(Keyword,"cint")==0)
                {
                  strcpy(Stk[Tmp],"Cint");
                  Use_Cint=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"cldbl")==0)
                {
                  strcpy(Stk[Tmp],"CLDBL");
                  Use_Cldbl=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"clng")==0)
                {
                  strcpy(Stk[Tmp],"CLNG");
                  Use_Clng=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"cls")==0)
                {
                  strcpy(Stk[Tmp],"cls");
                  Use_Cls=Use_ESC=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"color")==0 ||  str_cmp(Keyword,"color_fg")==0 ||  str_cmp(Keyword,"color_bg")==0)
                {
                  strcpy(Stk[Tmp],lcase(Stk[Tmp]));
                  Use_Color=Use_Console=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"command$")==0)
                {
                  Use_Command=Use_SPC=UseFlag=TRUE;
                  strcpy(Stk[Tmp],"command$(-1)");
                  if(str_cmp(Stk[Tmp+1],"(")==0)
                    {
                      strcpy(Stk[Tmp],"command$");
                    }
                  break;
                }
              if(str_cmp(Keyword,"colorref")==0)
                {
                  strcpy(Stk[Tmp],"COLORREF");
                  break;
                }
              if(str_cmp(Keyword,"cos")==0)
                {
                  strcpy(Stk[Tmp],"cos");
                  break;
                }
              if(str_cmp(Keyword,"cosl")==0)
                {
                  strcpy(Stk[Tmp],"cosl");
                  break;
                }
              if(str_cmp(Keyword,"cosh")==0)
                {
                  strcpy(Stk[Tmp],"cosh");
                  break;
                }
              if(str_cmp(Keyword,"cbool")==0)
                {
                  strcpy(Stk[Tmp],"CBOOL");
                  static   struct _functionParse  fp;
                  memset(&fp,0,sizeof(fp));
                  static int     i;
                  memset(&i,0,sizeof(i));
                  static int     t;
                  memset(&t,0,sizeof(t));
                  static int     expos=0;
                  memset(&expos,0,sizeof(expos));
                  if(SepFuncArgs(Tmp+1, &fp,TRUE)==0)
                    {
                      Abort("No argument specified in CBOOL");
                    }
                  for(i=fp.CommaPos[0]; i<=fp.CommaPos[1]; i+=1)
                    {
                      t=inchr("!<>=",Stk[i]);
                      if(t)
                        {
                          if(t<4)
                            {
                              if(str_cmp(Stk[i+1],"=")==0)
                                {
                                  strcpy(Stk[i], join(2,Stk[i],Stk[i+1]));
                                  *Stk[i+1]=0;
                                }
                              else if(t==1&&str_cmp(Stk[i],"!=")!=0)
                                {
                                  continue;
                                }
                            }
                          else
                            {
                              if(str_cmp(Stk[i+1],"=")!=0)
                                {
                                  strcpy(Stk[i],"==");
                                }
                            }
                          expos=i;
                          break;
                        }
                    }
                  t=DataType(Stk[expos-1]);
                  if(t==vt_STRLIT||t==vt_STRVAR)
                    {
                      if(expos)
                        {
                          strcpy(Stk[Tmp+1], join(2,Stk[Tmp+1],"strcmp("));
                          strcpy(Stk[fp.CommaPos[1]], join(3,")",Stk[expos],"0)"));
                          strcpy(Stk[expos],",");
                          *Src=0;
                          for(i=1; i<=Ndx; i+=1)
                            {
                              strcpy(Src, join(3,Src,Stk[i],SPC));
                            }
                          FastLexer(Src," ","(),");
                        }
                    }
                  break;
                }
              if(str_cmp(Keyword,"csng")==0)
                {
                  strcpy(Stk[Tmp],"CSNG");
                  Use_Csng=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"curdir$")==0)
                {
                  strcpy(Stk[Tmp],"curdir$()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  Use_Curdir=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"currency")==0)
                {
                  strcpy(Stk[Tmp],"CURRENCY");
                  break;
                }
              if(str_cmp(Keyword,"c_declare")==0)
                {
                  strcpy(CallType,"__attribute__((cdecl)) ");
                  strcpy(Stk[Tmp],"declare");
                  if(iMatchWrd(Stk[4],"lib"))
                    {
                      NoTypeDeclare=FALSE;
                    }
                  else
                    {
                      NoTypeDeclare=TRUE;
                    }
                }
              break;
            }
            break;
          }
        if(a==4)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"declare")==0)
                {
                  strcpy(CallType,"__attribute__((stdcall)) ");
                  strcpy(Stk[Tmp],"declare");
                  if(!iMatchWrd(Stk[4],"lib"))
                    {
                      NoTypeDeclare=TRUE;
                    }
                  else
                    {
                      NoTypeDeclare=FALSE;
                    }
                  break;
                }
              if(str_cmp(Keyword,"dq$")==0)
                {
                  strcpy(Stk[Tmp],"DQ$");
                  Use_DQ=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"ddq$")==0)
                {
                  strcpy(Stk[Tmp],"DDQ$");
                  Use_DDQ=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"data$")==0)
                {
                  strcpy(Stk[Tmp],"DATA$");
                  break;
                }
              if(str_cmp(Keyword,"date$")==0)
                {
                  strcpy(Stk[Tmp],"$$timef$(12)");
                  Use_Time=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"delete")==0)
                {
                  if(UseCpp==FALSE)
                    {
                      Abort("'DELETE' can only be used with C++");
                    }
                  strcpy(Stk[Tmp],"delete ");
                  break;
                }
              if(str_cmp(Keyword,"del$")==0)
                {
                  strcpy(Stk[Tmp],"del$");
                  Use_Del=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"double")==0)
                {
                  strcpy(Stk[Tmp],"double");
                  break;
                }
              if(str_cmp(Keyword,"download")==0)
                {
                  strcpy(Stk[Tmp],"Download");
                  Use_Download=Use_Dynacall=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"dsplit")==0)
                {
                  strcpy(Stk[Tmp],"DSplit");
                  Use_DSplit=TRUE;
                  Use_Remove=TRUE;
                  Use_StrStr=TRUE;
                  Use_Mid=TRUE;
                  Use_Left=TRUE;
                  Use_Instr=TRUE;
                  Use_Stristr=TRUE;
                  UseLCaseTbl=TRUE;
                  UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"dword")==0)
                {
                  strcpy(Stk[Tmp],"DWORD");
                }
              break;
            }
            break;
          }
        if(a==5)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"extern")==0)
                {
                  strcpy(Stk[Tmp],"extern");
                  break;
                }
              if(str_cmp(Keyword,"enc$")==0)
                {
                  strcpy(Stk[Tmp],"$$enc$");
                  Use_Enclose=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"extract$")==0)
                {
                  strcpy(Stk[Tmp],"$$extract$");
                  Use_Extract=Use_StrStr=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"eof$")==0)
                {
                  strcpy(Stk[Tmp],"EF$");
                  Use_EOF=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"eof")==0)
                {
                  strcpy(Stk[Tmp],"EoF");
                  Use_Eof=UseFlag=TRUE;
                  if(DataType(Stk[Tmp+2])==vt_NUMBER)
                    {
                      strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
                    }
                  break;
                }
              if(str_cmp(Keyword,"esc$")==0)
                {
                  strcpy(Stk[Tmp],"ESC$");
                  Use_ESC=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"enum")==0)
                {
                  if(Ndx==1||iMatchWrd(Stk[3],"enum"))
                    {
                      Use_EnumFile=TRUE;
                      int     EnumFlag=FALSE;
                      fprintf(FP11,"%s\n","");
                      if(Ndx==1)
                        {
                          fprintf(FP11,"%s\n","enum");
                        }
                      else
                        {
                          fprintf(FP11,"%s%s\n","enum ",Stk[1]);
                        }
                      fprintf(FP11,"%s\n","  {");
                      *Src=0;
                      while(!iMatchLft(Src,"end "))
                        {
                          if(EoF(SourceFile))
                            {
                              Abort("Unbalanced ENUM");
                            }
                          Src[0]=0;
                          AR_fgets_retval=fgets(Src,65535,SourceFile);
                          if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
                          ModuleLineNos[ModuleNdx]++;
                          StripCode(Src);
                          if(iMatchLft(Src,"$comme"))
                            {
                              Directives();
                              continue;
                            }
                          strcpy(Src,trim(Src));
                          if(Src[0]==0)
                            {
                              continue;
                            }
                          if(str_cmp(lcase(left(join(2,Src," "),4)),"end ")==0)
                            {
                              break;
                            }
                          else
                            {
                              if(EnumFlag==FALSE)
                                {
                                  EnumFlag=TRUE;
                                }
                              else
                                {
                                  fprintf(FP11,"%s\n",",");
                                }
                            }
                          fprintf(FP11,"%s%s","    ",rtrim(Src));
                        }
                      *Src=0;
                      Ndx=0;
                      fprintf(FP11,"%s\n","");
                      fprintf(FP11,"%s\n","  };\n");
                      return;
                    }
                  strcpy(Stk[1],"enum {");
                  for(j=2; j<=Ndx; j+=1)
                    {
                      strcat(Stk[1],Stk[j]);
                    }
                  strcat(Stk[1],"}");
                  Ndx=1;
                  break;
                }
              if(str_cmp(Keyword,"environ$")==0)
                {
                  strcpy(Stk[Tmp],"Environ$");
                  Use_Environ=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"exist")==0)
                {
                  strcpy(Stk[Tmp],"Exist");
                  Use_Exist=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"exp")==0)
                {
                  strcpy(Stk[Tmp],"Exp");
                  Use_Exp=TRUE;
                }
              break;
            }
            break;
          }
        if(a==6)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"freeglobals")==0)
                {
                  strcpy(Stk[Tmp],"FreeGlobals");
                  break;
                }
              if(str_cmp(Keyword,"ff$")==0)
                {
                  strcpy(Stk[Tmp],"FF$");
                  Use_FF=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"function")==0)
                {
                  if(str_cmp(Stk[Tmp+1],"=")==0)
                    {
                      if(str_cmp(Stk[Tmp+2],DDQ)==0)
                        {
                          strcpy(Stk[Tmp+2],"NUL$");
                        }
                      strcpy(Stk[Tmp],"functionreturn");
                    }
                  break;
                }
              if(str_cmp(Keyword,"false")==0)
                {
                  strcpy(Stk[Tmp],"FALSE");
                  break;
                }
              if(str_cmp(Keyword,"file")==0)
                {
                  strcpy(Stk[Tmp],"FILE");
                  break;
                }
              if(str_cmp(Keyword,"findintype")==0)
                {
                  strcpy(Stk[Tmp],"FindInType");
                  Use_FindInType=TRUE;
                  char StMem[2048];
                  char StName[2048];
                  char VarName[2048];
                  static   struct _functionParse  fp;
                  memset(&fp,0,sizeof(fp));
                  SepFuncArgs(Tmp, &fp,TRUE);
                  strcpy(StMem,remain(Clean(GetArg(2, &fp)),"."));
                  strcpy(VarName,extract(Clean(GetArg(2, &fp)),"."));
                  for(j=fp.CommaPos[1]+1; j<=fp.CommaPos[2]-1; j+=1)
                    {
                      *Stk[j]=0;
                    }
                  if(CheckLocal(VarName, &i)!=vt_UNKNOWN)
                    {
                      strcpy(StName,TypeDefs[LocalVars[i].VarDef].VarName);
                    }
                  else if(CheckGlobal(VarName, &i)!=vt_UNKNOWN)
                    {
                      strcpy(StName,TypeDefs[GlobalVars[i].VarDef].VarName);
                    }
                  j=fp.CommaPos[1]+1;
                  strcpy(Stk[j], join(9,"(char*)",VarName," + offsetof(",StName,",",StMem,"), sizeof(",StName,")"));
                  break;
                }
              if(str_cmp(Keyword,"farproc")==0)
                {
                  strcpy(Stk[Tmp],"FARPROC");
                  break;
                }
              if(str_cmp(Keyword,"fillarray")==0)
                {
                  strcpy(Stk[Tmp],"fillarray");
                  Use_FillArray=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"findfirst$")==0)
                {
                  strcpy(Stk[Tmp],"findfirst$");
                  j=GetNumArgs(Tmp+2);
                  if(j==0)
                    {
                      strcpy(Stk[Ndx],", &FindData)");
                    }
                  Use_Findfirst=Use_Like=TRUE;
                  Use_BcxSplitPath=TRUE;
                  Use_Join=TRUE;
                  UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"findnext$")==0)
                {
                  strcpy(Stk[Tmp],"findnext$");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      strcpy(Stk[Tmp+1],"(&FindData");
                    }
                  else if(Tmp==Ndx)
                    {
                      Ndx++;
                      strcpy(Stk[Ndx],"(&FindData)");
                    }
                  Use_Findnext=Use_Like=UseFlag=TRUE;
                  Use_Join=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"fint")==0)
                {
                  strcpy(Stk[Tmp],"FINT");
                  Use_Fint=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"fix")==0)
                {
                  strcpy(Stk[Tmp],"FIX");
                  Use_Fix=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"filelocked")==0)
                {
                  strcpy(Stk[Tmp],"FileLocked");
                  Use_FileLocked=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"flush")==0)
                {
                  strcpy(Stk[Tmp],"fflush");
                  break;
                }
              if(str_cmp(Keyword,"frac")==0)
                {
                  strcpy(Stk[Tmp],"FRAC");
                  Use_Frac=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"fracl")==0)
                {
                  strcpy(Stk[Tmp],"FRACL");
                  Use_Fracl=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"freefile")==0)
                {
                  strcpy(Stk[Tmp],"FreeFile()");
                  Use_Freefile=TRUE;
                }
              break;
            }
            break;
          }
        if(a==7)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"getprocaddress")==0)
                {
                  static char GlobalName[2048];
                  memset(&GlobalName,0,sizeof(GlobalName));
                  static int     s;
                  memset(&s,0,sizeof(s));
                  static int     ss;
                  memset(&ss,0,sizeof(ss));
                  static char tempA[2048];
                  memset(&tempA,0,sizeof(tempA));
                  strcpy(GlobalName,Stk[Tmp-2]);
                  ss=HashNumber(GlobalName);
                  while(GlobalVarHash[ss])
                    {
                      s=GlobalVarHash[ss];
                      if(str_cmp(GlobalName,GlobalVars[s].VarName)==0)
                        {
                          strcpy(tempA,TypeDefs[GlobalVars[s].VarDef].VarName);
                          if(GlobalVars[s].VarPntr)
                            {
                              strcat(tempA," *");
                            }
                        }
                      ss=imod(ss+1,MaxGlobalVars);
                    }
                  if(tempA[0]==0)
                    {
                      static char LocalName[2048];
                      memset(&LocalName,0,sizeof(LocalName));
                      strcpy(LocalName,Stk[Tmp-2]);
                      if(LocalVarCnt)
                        {
                            {int i;
                          for(i=1; i<=LocalVarCnt; i+=1)
                            {
                              if(str_cmp(LocalName,LocalVars[i].VarName)==0)
                                {
                                  strcpy(tempA,TypeDefs[LocalVars[i].VarDef].VarName);
                                  if(LocalVars[i].VarPntr)
                                    {
                                      strcat(tempA," *");
                                    }
                                  break;
                                }
                            }
                            }
                        }
                    }
                  if(tempA[0]!=0)
                    {
                      strcpy(Stk[Tmp], join(3,"(",tempA,")dlsym"));
                    }
                  else
                    {
                      strcpy(Stk[Tmp],"dlsym");
                    }
                  break;
                }
              if(str_cmp(Keyword,"getattr")==0)
                {
                  strcpy(Stk[Tmp],"GETATTR");
                  break;
                }
              if(str_cmp(Keyword,"getbvalue")==0)
                {
                  strcpy(Stk[Tmp],"GetBValue");
                  break;
                }
              if(str_cmp(Keyword,"getc")==0)
                {
                  strcpy(Stk[Tmp],"getc");
                  break;
                }
              if(str_cmp(Keyword,"getgvalue")==0)
                {
                  strcpy(Stk[Tmp],"GetGValue");
                  break;
                }
              if(str_cmp(Keyword,"getrvalue")==0)
                {
                  strcpy(Stk[Tmp],"GetRValue");
                  break;
                }
              if(str_cmp(Keyword,"getresource")==0)
                {
                  strcpy(Stk[Tmp],"GetResource");
                  Use_Embed=TRUE;
                }
              break;
            }
            break;
          }
        if(a==8)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"hiword")==0)
                {
                  strcpy(Stk[Tmp],"HIWORD");
                  break;
                }
              if(str_cmp(Keyword,"hex$")==0)
                {
                  strcpy(Stk[Tmp],"hex$");
                  Use_Hex=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"hex2dec")==0)
                {
                  strcpy(Stk[Tmp],"Hex2Dec");
                  Use_Hex2Dec=UseLCaseTbl=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"hibyte")==0)
                {
                  strcpy(Stk[Tmp],"HIBYTE");
                  break;
                }
              if(str_cmp(Keyword,"hide")==0)
                {
                  strcpy(Stk[Tmp],"Hide");
                  break;
                }
              if(str_cmp(Keyword,"hypot")==0)
                {
                  strcpy(Stk[Tmp],"hypot");
                }
              break;
            }
            break;
          }
        if(a==9)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"inherits")==0)
                {
                  strcpy(Stk[Tmp],"inherits");
                  break;
                }
              if(str_cmp(Keyword,"instr")==0)
                {
                  strcpy(Stk[Tmp],"instr_b");
                  Use_Instr=Use_StrStr=TRUE;
                  Use_Stristr=UseLCaseTbl=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"inchr")==0)
                {
                  strcpy(Stk[Tmp],"inchr");
                  Use_Inchr=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"imod")==0)
                {
                  strcpy(Stk[Tmp],"imod");
                  Use_Imod=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"iif")==0)
                {
                  strcpy(Stk[Tmp],"iif");
                  Use_Iif=TRUE;
                  for(i=Tmp+1; i<=Ndx; i+=1)
                    {
                      if(str_cmp(Stk[i],"=")==0)
                        {
                          if(str_cmp(Stk[i-1],"<")!=0 &&  str_cmp(Stk[i-1],">")!=0)
                            {
                              strcpy(Stk[i],"==");
                            }
                        }
                    }
                  break;
                }
              if(str_cmp(Keyword,"iif$")==0)
                {
                  strcpy(Stk[Tmp],"sziif$");
                  Use_sziif=TRUE;
                  for(i=Tmp+1; i<=Ndx; i+=1)
                    {
                      if(str_cmp(Stk[i],"=")==0)
                        {
                          if(str_cmp(Stk[i-1],"<")!=0 &&  str_cmp(Stk[i-1],">")!=0)
                            {
                              strcpy(Stk[i],"==");
                            }
                        }
                    }
                  break;
                }
              if(str_cmp(Keyword,"inkey")==0)
                {
                  Use_InkeyD=TRUE;
                  Use_GetCh=TRUE;
                  UseFlag=TRUE;
                  strcpy(Stk[Tmp],"inkeyd()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  break;
                }
              if(str_cmp(Keyword,"inkey$")==0)
                {
                  Use_Inkey=TRUE;
                  Use_GetCh=TRUE;
                  UseFlag=TRUE;
                  strcpy(Stk[Tmp],"inkey$()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  break;
                }
              if(str_cmp(Keyword,"ins$")==0)
                {
                  strcpy(Stk[Tmp],"ins$");
                  Use_Ins=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"instat")==0)
                {
                  Use_Instat=TRUE;
                  strcpy(Stk[Tmp],"kbhit()");
                  break;
                }
              if(str_cmp(Keyword,"instrrev")==0)
                {
                  strcpy(Stk[Tmp],"InstrRev");
                  Use_Instrrev=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"isptr")==0)
                {
                  strcpy(Stk[Tmp],"IsPtr");
                  Use_Isptr=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"ireplace$")==0)
                {
                  strcpy(Stk[Tmp],"iReplace$");
                  Use_iReplace=Use_Stristr=UseFlag=TRUE;
                  UseLCaseTbl=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"iremove$")==0)
                {
                  strcpy(Stk[Tmp],"IRemoveStr$");
                  Use_IRemove=UseFlag=TRUE;
                  Use_Stristr=UseLCaseTbl=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"iterate")==0)
                {
                  strcpy(Stk[Tmp],"continue");
                }
              break;
            }
            break;
          }
        if(a==10)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"join$")==0)
                {
                  strcpy(Stk[Tmp],"$$join$");
                  Use_Join=UseFlag=TRUE;
                }
              break;
            }
            break;
          }
        if(a==11)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"keypress")==0)
                {
                  strcpy(Stk[Tmp],"keypress()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  Use_Keypress=TRUE;
                  Use_GetCh=TRUE;
                }
              break;
            }
            break;
          }
        if(a==12)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"loadfile$")==0)
                {
                  strcpy(Stk[Tmp],"$$LoadFile$");
                  Use_LoadFile=Use_Get=UseFlag=TRUE;
                  Use_Exist=Use_Lof=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"lf$")==0)
                {
                  strcpy(Stk[Tmp],"LF$");
                  Use_LF=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"line")==0)
                {
                  if(iMatchWrd(Stk[Tmp+1],"input"))
                    {
                      Use_Lineinput=TRUE;
                      strcpy(Stk[Tmp],"lineinput");
                      j=Tmp+4;
                      *Stk[Tmp+1]=0;
                      for(i=Tmp+2; i<=Ndx; i+=1)
                        {
                          if(*Stk[i]==44)
                            {
                              j=i+1;
                              break;
                            }
                          strcpy(Stk[Tmp+1], join(2,Stk[Tmp+1],Stk[i]));
                          *Stk[i]=0;
                        }
                      for(i=j; i<=Ndx; i+=1)
                        {
                          strcpy(Stk[Tmp+2], join(2,Stk[Tmp+2],Stk[i]));
                        }
                    }
                  break;
                }
              if(str_cmp(Keyword,"lcase$")==0)
                {
                  strcpy(Stk[Tmp],"$$lcase$");
                  Use_Lcase=TRUE;
                  Use_StrUpLow=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"ldouble")==0)
                {
                  strcpy(Stk[Tmp],"LDOUBLE");
                  Use_Ldouble=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"left$")==0)
                {
                  strcpy(Stk[Tmp],"$$left$");
                  Use_Left=TRUE;
                  UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"long")==0)
                {
                  strcpy(Stk[Tmp],"long");
                  break;
                }
              if(str_cmp(Keyword,"longlong")==0)
                {
                  strcpy(Stk[Tmp],"LONGLONG");
                  break;
                }
              if(str_cmp(Keyword,"lpbyte")==0)
                {
                  strcpy(Stk[Tmp],"LPBYTE");
                  break;
                }
              if(str_cmp(Keyword,"len")==0)
                {
                  strcpy(Stk[Tmp],"strlen");
                  break;
                }
              if(str_cmp(Keyword,"lprint")==0)
                {
                  strcpy(Stk[Tmp],"lprint");
                  if(Tmp==Ndx)
                    {
                      Ndx++;
                      strcpy(Stk[Ndx],enc(""));
                    }
                  break;
                }
              if(str_cmp(Keyword,"lpad$")==0)
                {
                  strcpy(Stk[Tmp],"$$lpad$");
                  Use_Lpad=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"ltrim$")==0)
                {
                  strcpy(Stk[Tmp],"$$ltrim$");
                  Use_Ltrim=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"lof")==0)
                {
                  strcpy(Stk[Tmp],"lof");
                  if(DataType(Stk[Tmp+2])==vt_NUMBER)
                    {
                      strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
                    }
                  Use_Lof=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"loadlibrary")==0 ||  str_cmp(Keyword,"load_dll")==0)
                {
                  strcpy(Stk[Tmp],"LoadLibrary");
                  break;
                }
              if(str_cmp(Keyword,"like")==0)
                {
                  strcpy(Stk[Tmp],"like");
                  Use_Like=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"lobyte")==0)
                {
                  strcpy(Stk[Tmp],"LOBYTE");
                  break;
                }
              if(str_cmp(Keyword,"loc")==0)
                {
                  if(DataType(Stk[Tmp+2])==vt_NUMBER)
                    {
                      strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
                    }
                  strcpy(Stk[Tmp], join(5,"loc(",Stk[Tmp+2],",",Stk[Tmp+2],"len)"));
                  *Stk[Tmp+1]=0;
                  *Stk[Tmp+2]=0;
                  *Stk[Tmp+3]=0;
                  Use_Loc=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"locate")==0)
                {
                  Use_Locate=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"log")==0)
                {
                  strcpy(Stk[Tmp],"log");
                  break;
                }
              if(str_cmp(Keyword,"logl")==0)
                {
                  strcpy(Stk[Tmp],"logl");
                  break;
                }
              if(str_cmp(Keyword,"log10")==0)
                {
                  strcpy(Stk[Tmp],"log10");
                  break;
                }
              if(str_cmp(Keyword,"log10l")==0)
                {
                  strcpy(Stk[Tmp],"log10l");
                  break;
                }
              if(str_cmp(Keyword,"loword")==0)
                {
                  strcpy(Stk[Tmp],"LOWORD");
                  break;
                }
              if(str_cmp(Keyword,"lpstr")==0)
                {
                  strcpy(Stk[Tmp],"PCHAR");
                }
              break;
            }
            break;
          }
        if(a==13)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"mkd$")==0)
                {
                  if(Tmp>2)
                    {
                      if(inchr(Stk[Tmp-2],"$")&&*Stk[Tmp-1]==61)
                        {
                          strcpy(Stk[1], join(2,"memcpy(",Stk[1]));
                          strcpy(Stk[Tmp-1],",");
                          strcpy(Stk[++Ndx],",9)");
                        }
                    }
                  strcpy(Stk[Tmp],"MKD");
                  Use_Mkd=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"mki$")==0)
                {
                  if(Tmp>2)
                    {
                      if(inchr(Stk[Tmp-2],"$")&&*Stk[Tmp-1]==61)
                        {
                          strcpy(Stk[1], join(2,"memcpy(",Stk[1]));
                          strcpy(Stk[Tmp-1],",");
                          strcpy(Stk[++Ndx],",3)");
                        }
                    }
                  strcpy(Stk[Tmp],"MKI");
                  Use_Mki=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"mkl$")==0)
                {
                  if(Tmp>2)
                    {
                      if(inchr(Stk[Tmp-2],"$")&&*Stk[Tmp-1]==61)
                        {
                          strcpy(Stk[1], join(2,"memcpy(",Stk[1]));
                          strcpy(Stk[Tmp-1],",");
                          strcpy(Stk[++Ndx],",5)");
                        }
                    }
                  strcpy(Stk[Tmp],"MKL");
                  Use_Mkl=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"mkld$")==0)
                {
                  if(Tmp>2)
                    {
                      if(inchr(Stk[Tmp-2],"$")&&*Stk[Tmp-1]==61)
                        {
                          strcpy(Stk[1], join(2,"memcpy(",Stk[1]));
                          strcpy(Stk[Tmp-1],",");
                          strcpy(Stk[++Ndx],",11)");
                        }
                    }
                  strcpy(Stk[Tmp],"MKLD");
                  Use_Mkld=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"mks$")==0)
                {
                  if(Tmp>2)
                    {
                      if(inchr(Stk[Tmp-2],"$")&&*Stk[Tmp-1]==61)
                        {
                          strcpy(Stk[1], join(2,"memcpy(",Stk[1]));
                          strcpy(Stk[Tmp-1],",");
                          strcpy(Stk[++Ndx],",5)");
                        }
                    }
                  strcpy(Stk[Tmp],"MKS");
                  Use_Mks=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"mid$")==0)
                {
                  if(Tmp>1)
                    {
                      strcpy(Stk[Tmp],"$$mid$");
                      Use_Mid=UseFlag=TRUE;
                    }
                  else
                    {
                      strcpy(Stk[Tmp],"midstr");
                      Use_Midstr=UseFlag=TRUE;
                    }
                  break;
                }
              if(str_cmp(Keyword,"min")==0)
                {
                  strcpy(Stk[Tmp],"_MIN_");
                  Use_Min=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"main")==0)
                {
                  strcpy(Stk[Tmp],"main");
                  break;
                }
              if(str_cmp(Keyword,"makeintresource")==0)
                {
                  strcpy(Stk[Tmp],"MAKEINTRESOURCE");
                  break;
                }
              if(str_cmp(Keyword,"makelong")==0)
                {
                  strcpy(Stk[Tmp],"MAKELONG");
                  break;
                }
              if(str_cmp(Keyword,"makeword")==0)
                {
                  strcpy(Stk[Tmp],"MAKEWORD");
                  break;
                }
              if(str_cmp(Keyword,"max")==0)
                {
                  strcpy(Stk[Tmp],"_MAX_");
                  Use_Max=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"mcase$")==0)
                {
                  strcpy(Stk[Tmp],"$$mcase$");
                  Use_Mcase=UseFlag=TRUE;
                  Use_StrUpLow=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"mkdir")==0)
                {
                  strcpy(Stk[Tmp],"mkdir");
                  break;
                }
              if(str_cmp(Keyword,"mod")==0)
                {
                  strcpy(Stk[Tmp],"fmod");
                }
              break;
            }
            break;
          }
        if(a==14)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"new")==0)
                {
                  if(iMatchWrd(Stk[Tmp-1],"binary"))
                    {
                      break;
                    }
                  if(UseCpp==FALSE)
                    {
                      Abort("'NEW' can only be used with C++");
                    }
                  strcpy(Stk[Tmp],"new ");
                  break;
                }
              if(str_cmp(Keyword,"nul$")==0)
                {
                  strcpy(Stk[Tmp],"NUL$");
                  Use_NUL=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"null")==0)
                {
                  strcpy(Stk[Tmp],"NULL");
                  break;
                }
              if(str_cmp(Keyword,"now$")==0)
                {
                  strcpy(Stk[Tmp],"now$()");
                  Use_Now=UseFlag=TRUE;
                }
              break;
            }
            break;
          }
        if(a==15)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"open")==0)
                {
                  for(A=Tmp+1; A<=Ndx; A+=1)
                    {
                      if(str_cmp(left(Stk[A],1),"#")==0)
                        {
                          strcpy(Stk[A],mid(Stk[A],2));
                          break;
                        }
                    }
                  break;
                }
              if(str_cmp(Keyword,"oct$")==0)
                {
                  strcpy(Stk[Tmp],"oct$");
                  Use_Oct=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"osversion")==0)
                {
                  strcpy(Stk[Tmp],"OSVersion()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  Use_OSVersion=TRUE;
                }
              break;
            }
            break;
          }
        if(a==16)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"pause")==0)
                {
                  strcpy(Stk[Tmp],"Pause()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  Use_Pause=Use_Keypress=TRUE;
                  Use_GetCh=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"preserve")==0)
                {
                  strcpy(Stk[Tmp],"PRESERVE");
                  break;
                }
              if(str_cmp(Keyword,"print#")==0)
                {
                  strcpy(Stk[Tmp],"fprint");
                  break;
                }
              if(str_cmp(Keyword,"print")==0)
                {
                  if(str_cmp(left(Stk[Tmp+1],1),"#")==0)
                    {
                      strcpy(Stk[Tmp],"fprint");
                      strcpy(Stk[Tmp+1],mid(Stk[Tmp+1],2));
                    }
                  break;
                }
              if(str_cmp(Keyword,"ptr")==0)
                {
                  CompPtr=1;
                  strcpy(Stk[Tmp-1], join(2,Stk[Tmp-1],"*"));
                  *Stk[Tmp]=0;
                  if(Tmp==Ndx)
                    {
                      Ndx--;
                      while(tally(Stk[Ndx],"*")==strlen(Stk[Ndx]))
                        {
                          strcpy(Stk[Ndx-1], join(2,Stk[Ndx-1],Stk[Ndx]));
                          *Stk[Ndx]=0;
                          Ndx--;
                        }
                    }
                  else
                    {
                      i=Tmp-1;
                      while(tally(Stk[i],"*")==strlen(Stk[i]))
                        {
                          strcpy(Stk[i-1], join(2,Stk[i-1],Stk[i]));
                          *Stk[i]=0;
                          i--;
                        }
                    }
                  break;
                }
              if(str_cmp(Keyword,"peek$")==0)
                {
                  strcpy(Stk[Tmp],"$$peekstr$");
                  Use_PeekStr=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"poke")==0)
                {
                  strcpy(Stk[Tmp],"memmove");
                  break;
                }
              if(str_cmp(Keyword,"pow")==0)
                {
                  strcpy(Stk[Tmp],"pow");
                  break;
                }
              if(str_cmp(Keyword,"powl")==0)
                {
                  strcpy(Stk[Tmp],"powl");
                  break;
                }
              if(str_cmp(Keyword,"private")==0)
                {
                  if(UseCpp)
                    {
                      strcpy(Stk[Tmp],"private");
                    }
                  if(iMatchWrd(Stk[Tmp+1],"const"))
                    {
                      strcpy(Stk[Tmp],"enum ");
                      strcpy(Stk[Tmp+1], join(2,Stk[Tmp+2],"{"));
                      Ndx++;
                      strcpy(Stk[Ndx],"}");
                    }
                  break;
                }
              if(str_cmp(Keyword,"public")==0)
                {
                  if(UseCpp)
                    {
                      strcpy(Stk[Tmp],"public");
                    }
                }
              break;
            }
            break;
          }
        if(a==17)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"qbcolor")==0)
                {
                  strcpy(Stk[Tmp],"qbcolor");
                  Use_QBColor=TRUE;
                }
              break;
            }
            break;
          }
        if(a==18)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"regmatch")==0)
                {
                  strcpy(Stk[Tmp],"regmatch");
                  Use_PeekStr=Use_RegEx=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"rewind")==0)
                {
                  strcpy(Stk[Tmp],"rewind");
                  if(DataType(Stk[Tmp+2])==vt_NUMBER)
                    {
                      strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
                    }
                  break;
                }
              if(str_cmp(Keyword,"remove$")==0)
                {
                  strcpy(Stk[Tmp],"$$RemoveStr$");
                  Use_Remove=Use_StrStr=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"replace$")==0)
                {
                  strcpy(Stk[Tmp],"$$replace$");
                  Use_Replace=Use_StrStr=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"right$")==0)
                {
                  strcpy(Stk[Tmp],"$$right$");
                  Use_Right=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"rename")==0)
                {
                  strcpy(Stk[Tmp],"rename");
                  break;
                }
              if(str_cmp(Keyword,"register")==0)
                {
                  strcpy(Stk[Tmp],"register");
                  break;
                }
              if(str_cmp(Keyword,"randomize")==0)
                {
                  strcpy(Stk[Tmp],"randomize");
                  Use_Randomize=TRUE;
                  Use_Rnd=TRUE;
                  if(Ndx==1)
                    {
                      Use_Timer=TRUE;
                      strcpy(Stk[1],"randomize(timer())");
                    }
                  break;
                }
              if(str_cmp(Keyword,"rec")==0)
                {
                  if(DataType(Stk[Tmp+2])==vt_NUMBER)
                    {
                      strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
                    }
                  strcpy(Stk[Tmp], join(5,"rec(",Stk[Tmp+2],",",Stk[Tmp+2],"len)"));
                  *Stk[Tmp+1]=0;
                  *Stk[Tmp+2]=0;
                  *Stk[Tmp+3]=0;
                  Use_Rec=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"reccount")==0)
                {
                  char length[2048];
                  if(DataType(Stk[Tmp+2])==vt_NUMBER)
                    {
                      strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
                    }
                  strcpy(Stk[Tmp],"reccount");
                  strcpy(length, join(2,Stk[Tmp+2],"len)"));
                  for(i=Tmp+1; i<=Ndx; i+=1)
                    {
                      if(*Stk[i]==41)
                        {
                          *Stk[i]=0;
                          break;
                        }
                      strcpy(Stk[Tmp], join(2,Stk[Tmp],Stk[i]));
                      *Stk[i]=0;
                    }
                  strcpy(Stk[Tmp], join(3,Stk[Tmp],",",length));
                  Use_RecCount=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"reclen")==0)
                {
                  strcpy(Stk[Tmp],"reclen");
                  break;
                }
              if(str_cmp(Keyword,"record")==0)
                {
                  strcpy(Stk[Tmp],"record");
                  break;
                }
              if(str_cmp(Keyword,"remain$")==0)
                {
                  strcpy(Stk[Tmp],"$$remain$");
                  Use_Remain=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"retain$")==0)
                {
                  strcpy(Stk[Tmp],"$$Retain$");
                  Use_Retain=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"repeat$")==0)
                {
                  strcpy(Stk[Tmp],"$$repeat$");
                  Use_Repeat=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"reverse$")==0)
                {
                  strcpy(Stk[Tmp],"$$reverse$");
                  Use_Reverse=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"rgb")==0)
                {
                  strcpy(Stk[Tmp],"RGB");
                  break;
                }
              if(str_cmp(Keyword,"rmdir")==0)
                {
                  strcpy(Stk[Tmp],"rmdir");
                  break;
                }
              if(str_cmp(Keyword,"rnd")==0)
                {
                  strcpy(Stk[Tmp],"rnd()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  Use_Rnd=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"round")==0)
                {
                  strcpy(Stk[Tmp],"Round");
                  Use_Round=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"rpad$")==0)
                {
                  strcpy(Stk[Tmp],"$$rpad$");
                  Use_Rpad=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"rtrim$")==0)
                {
                  strcpy(Stk[Tmp],"$$rtrim$");
                  Use_Rtrim=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"run")==0)
                {
                  strcpy(Stk[Tmp],"Run");
                  Use_Run=TRUE;
                }
              break;
            }
            break;
          }
        if(a==19)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"scanerror")==0)
                {
                  strcpy(Stk[Tmp],"ScanError");
                  break;
                }
              if(str_cmp(Keyword,"sprint")==0)
                {
                  strcpy(Stk[Tmp],"sprint");
                  break;
                }
              if(str_cmp(Keyword,"spc$")==0)
                {
                  strcpy(Stk[Tmp],"SPC$");
                  Use_SPC=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"str$")==0)
                {
                  strcpy(Stk[Tmp],"$$str$");
                  Use_Str=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"strl$")==0)
                {
                  strcpy(Stk[Tmp],"$$strl$");
                  Use_Strl=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"searchpath$")==0)
                {
                  strcpy(Stk[Tmp],"$$SEARCHPATH$");
                  Use_SearchPath=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"sizeof")==0)
                {
                  strcpy(Stk[Tmp],"sizeof");
                  break;
                }
              if(str_cmp(Keyword,"setattr")==0)
                {
                  strcpy(Stk[Tmp],"SETATTR");
                  break;
                }
              if(str_cmp(Keyword,"setwindowrtftext")==0)
                {
                  strcpy(Stk[Tmp],"SetWindowRTFText");
                  break;
                }
              if(str_cmp(Keyword,"sgn")==0)
                {
                  strcpy(Stk[Tmp],"sgn");
                  Use_Sgn=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"short")==0)
                {
                  strcpy(Stk[Tmp],"short");
                  break;
                }
              if(str_cmp(Keyword,"shell")==0)
                {
                  Use_Shell=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"show")==0)
                {
                  strcpy(Stk[Tmp],"Show");
                  break;
                }
              if(str_cmp(Keyword,"sin")==0)
                {
                  strcpy(Stk[Tmp],"sin");
                  break;
                }
              if(str_cmp(Keyword,"sinl")==0)
                {
                  strcpy(Stk[Tmp],"sinl");
                  break;
                }
              if(str_cmp(Keyword,"single")==0)
                {
                  strcpy(Stk[Tmp],"float");
                  break;
                }
              if(str_cmp(Keyword,"sinh")==0)
                {
                  strcpy(Stk[Tmp],"sinh");
                  break;
                }
              if(str_cmp(Keyword,"sleep")==0)
                {
                  strcpy(Stk[Tmp],"sleep");
                  break;
                }
              if(str_cmp(Keyword,"space$")==0)
                {
                  strcpy(Stk[Tmp],"$$space$");
                  Use_Space=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"split")==0)
                {
                  strcpy(Stk[Tmp],"Split");
                  Use_Split=UseFlag=TRUE;
                  Use_Remove=TRUE;
                  Use_StrStr=TRUE;
                  Use_Mid=TRUE;
                  Use_Left=TRUE;
                  Use_Instr=TRUE;
                  Use_Stristr=TRUE;
                  UseLCaseTbl=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"splitbarfg")==0)
                {
                  strcpy(Stk[Tmp],"SplitBarFG");
                  break;
                }
              if(str_cmp(Keyword,"splitbarbg")==0)
                {
                  strcpy(Stk[Tmp],"SplitBarBG");
                  break;
                }
              if(str_cmp(Keyword,"sqr")==0 ||  str_cmp(Keyword,"sqrt")==0)
                {
                  strcpy(Stk[Tmp],"sqrt");
                  break;
                }
              if(str_cmp(Keyword,"sqrl")==0 ||  str_cmp(Keyword,"sqrtl")==0)
                {
                  strcpy(Stk[Tmp],"sqrtl");
                  break;
                }
              if(str_cmp(Keyword,"strarray")==0)
                {
                  strcpy(Stk[Tmp],"PCHAR*");
                  break;
                }
              if(str_cmp(Keyword,"strim$")==0)
                {
                  strcpy(Stk[Tmp],"$$strim$");
                  Use_Strim=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"string")==0)
                {
                  strcpy(Stk[Tmp],"string");
                  break;
                }
              if(str_cmp(Keyword,"string$")==0)
                {
                  strcpy(Stk[Tmp],"$$stringx$");
                  Use_String=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"strptr")==0)
                {
                  strcpy(Stk[Tmp],"STRPTR");
                  Use_Strptr=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"strtoken$")==0)
                {
                  strcpy(Stk[Tmp],"StrToken$");
                  Use_Strtoken=Use_Mid=Use_Left=Use_Extract=TRUE;
                  Use_Instr=Use_Instrrev=Use_Stristr=Use_Tally=Use_Remove=TRUE;
                  Use_StrStr=UseLCaseTbl=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"swap")==0)
                {
                  strcpy(Stk[Tmp],"swap");
                  Use_Swap=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"sysdir$")==0)
                {
                  strcpy(Stk[Tmp],"$$sysdir$()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  Use_Sysdir=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"sysstr")==0)
                {
                  strcpy(Stk[Tmp],"SysStr");
                  Use_SysStr=TRUE;
                }
              break;
            }
            break;
          }
        if(a==20)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"tab$")==0)
                {
                  strcpy(Stk[Tmp],"TAB$");
                  Use_TAB=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"true")==0)
                {
                  strcpy(Stk[Tmp],"TRUE");
                  break;
                }
              if(str_cmp(Keyword,"trim$")==0)
                {
                  strcpy(Stk[Tmp],"$$trim$");
                  Use_Trim=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"tally")==0)
                {
                  strcpy(Stk[Tmp],"tally");
                  Use_Tally=UseLCaseTbl=Use_Stristr=Use_StrStr=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"tan")==0)
                {
                  strcpy(Stk[Tmp],"tan");
                  break;
                }
              if(str_cmp(Keyword,"tanh")==0)
                {
                  strcpy(Stk[Tmp],"tanh");
                  break;
                }
              if(str_cmp(Keyword,"tanl")==0)
                {
                  strcpy(Stk[Tmp],"tanl");
                  break;
                }
              if(str_cmp(Keyword,"tempdir$")==0)
                {
                  strcpy(Stk[Tmp],"$$tempdir$()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  Use_Tempdir=UseFlag=Use_Exist=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"tempfilename$")==0)
                {
                  strcpy(Stk[Tmp],"$$TempFileName$");
                  Use_TempFileName=UseFlag=TRUE;
                  Use_Exist=Use_Rnd=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"this")==0)
                {
                  strcpy(Stk[Tmp],"this");
                  if(*Stk[Tmp+1]==46)
                    {
                      strcpy(Stk[Tmp+1], join(2,"->",mid(Stk[Tmp+1],2)));
                    }
                  break;
                }
              if(str_cmp(Keyword,"time$")==0)
                {
                  if(str_cmp(Stk[Tmp+1],"(")!=0)
                    {
                      strcpy(Stk[Tmp],"$$timef$()");
                    }
                  else
                    {
                      strcpy(Stk[Tmp],"$$timef$");
                    }
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  Use_Time=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"timer")==0)
                {
                  strcpy(Stk[Tmp],"timer()");
                  if(str_cmp(Stk[Tmp+1],"(")==0 &&  str_cmp(Stk[Tmp+2],")")==0)
                    {
                      *Stk[Tmp+1]=0;
                      *Stk[Tmp+2]=0;
                    }
                  Use_Timer=TRUE;
                }
              break;
            }
            break;
          }
        if(a==21)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"uint")==0)
                {
                  strcpy(Stk[Tmp],"UINT");
                  break;
                }
              if(str_cmp(Keyword,"ushort")==0)
                {
                  strcpy(Stk[Tmp],"USHORT");
                  break;
                }
              if(str_cmp(Keyword,"ulong")==0)
                {
                  strcpy(Stk[Tmp],"ULONG");
                  break;
                }
              if(str_cmp(Keyword,"ulonglong")==0)
                {
                  strcpy(Stk[Tmp],"ULONGLONG");
                  break;
                }
              if(str_cmp(Keyword,"ucase$")==0)
                {
                  strcpy(Stk[Tmp],"$$ucase$");
                  Use_Ucase=UseFlag=TRUE;
                  Use_StrUpLow=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"ubound")==0)
                {
                  strcpy(Stk[Tmp],"ubound");
                  Use_Ubound=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"using$")==0)
                {
                  strcpy(Stk[Tmp],"$$Using$");
                  Use_Using=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"using")==0)
                {
                  strcpy(Stk[Tmp],"using");
                }
              break;
            }
            break;
          }
        if(a==22)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"val")==0)
                {
                  strcpy(Stk[Tmp],"VAL");
                  Use_Val=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"vall")==0)
                {
                  strcpy(Stk[Tmp],"VALL");
                  Use_Vall=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"variant")==0)
                {
                  strcpy(Stk[Tmp],"VARIANT");
                  break;
                }
              if(str_cmp(Keyword,"varptr")==0)
                {
                  *Stk[Tmp]=0;
                  break;
                }
              if(str_cmp(Keyword,"vchr$")==0)
                {
                  strcpy(Stk[Tmp],"$$vchr$");
                  Use_VChr=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"virtual")==0)
                {
                  strcpy(Stk[Tmp],"virtual");
                  Use_Virtual=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"vt$")==0)
                {
                  strcpy(Stk[Tmp],"VT$");
                  Use_VT=UseFlag=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"verify")==0)
                {
                  strcpy(Stk[Tmp],"Verify");
                  Use_Verify=Use_Mid=UseFlag=TRUE;
                }
              break;
            }
            break;
          }
        if(a==23)
          {
            for(;;)
            {
              if(str_cmp(Keyword,"widetoansi$")==0)
                {
                  strcpy(Stk[Tmp],"$$WideToAnsi$");
                  Use_WideToAnsi=UseFlag=TRUE;
                }
              break;
            }
          }
        break;
      }
    }
  if(CompPtr==1)
    {
      RemEmptyTokens();
    }
  if(WithCnt)
    {
      for(i=1; i<=Ndx; i+=1)
        {
          if(str_cmp(left(Stk[i],2),"->")==0 || ( str_cmp(left(Stk[i],1),".")==0 && !IsNumber(mid(Stk[i],2,1))))
            {
              if(str_cmp(WithVar[WithCnt],"this")==0)
                {
                  strcpy(Stk[i], join(2,"->",mid(Stk[i],2)));
                }
              if(i==1)
                {
                  strcpy(Stk[i], join(2,WithVar[WithCnt],Stk[i]));
                }
              else
                {
                  if(!IsReservedWord(Stk[i-1]))
                    {
                      if(!(isalpha(Stk[i-1][strlen(Stk[i-1]-1)])||IsNumber(right(Stk[i-1],strlen(Stk[i-1]-1)))))
                        {
                          strcpy(Stk[i], join(2,WithVar[WithCnt],Stk[i]));
                        }
                    }
                  else
                    {
                      strcpy(Stk[i], join(2,WithVar[WithCnt],Stk[i]));
                    }
                }
              while((isalpha(*Stk[i+1])||*Stk[i+1]==46)&&(i<Ndx))
                {
                  i++;
                }
            }
        }
    }
  if(CompToken==1)
    {
      strcpy(Keyword,lcase(Stk[1]));
      for(;;)
      {
        if(str_cmp(Keyword,"dim")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"local")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"global")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"static")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"shared")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"raw")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"dynamic")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"free")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"redim")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"sub")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"function")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"overloaded")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"public")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"declare")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"c_declare")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"auto")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"register")==0)
          {
            CompToken=0;
            break;
          }
        if(str_cmp(Keyword,"extern")==0)
          {
            CompToken=0;
            break;
          }
          // case else
          {
            AsmUnknownStructs(1);
          }
        break;
      }
    }
}


void JoinStrings (int i, int inif)
{
  int     DoJoin=0;
  int     InBrace=0;
  int     OnlyPara=0;
  int     j=0;
  int     l=0;
  int     sj=i;
  char t[2048];
  int     vt;
  while(i<=Ndx)
    {
      strcpy(t,lcase(Stk[i]));
      if(!j&&!OnlyPara&&!InBrace)
        {
          vt=DataType(t);
          if(vt==vt_STRVAR||vt==vt_STRLIT)
            {
              sj=i;
              i++;
              continue;
            }
        }
      for(;;)
      {
        if(str_cmp(t,"&")==0)
          {
            if(OnlyPara)
              {
                break;
              }
            vt=DataType(Stk[i+1]);
            if(vt!=vt_STRVAR&&vt!=vt_STRLIT)
              {
                vt=DataType(Stk[i-1]);
              }
            if(vt==vt_STRVAR||vt==vt_STRLIT)
              {
                j++;
                strcpy(Stk[i],",");
                *t=0;
              }
            break;
          }
        if(str_cmp(t,"[")==0)
          {
            InBrace++;
            break;
          }
        if(str_cmp(t,"]")==0)
          {
            InBrace--;
            break;
          }
        if(str_cmp(t,"(")==0)
          {
            if(str_cmp(Stk[i+1],"*")!=0)
              {
                JoinStrings(i+1,inif);
                l=i-1;
                while(str_cmp(Stk[i],")")!=0)
                  {
                    strcpy(Stk[l], join(3,Stk[l],Stk[i]," "));
                    *Stk[i]=0;
                    i++;
                  }
                strcat(Stk[l],Stk[i]);
                *Stk[i]=0;
              }
            break;
          }
        if(str_cmp(t,")")==0)
          {
            if(j)
              {
                strcpy(Stk[sj], join(4,"join$(",str(j+1),",",Stk[sj]));
                j=sj+1;
                while(j<i)
                  {
                    strcat(Stk[sj],Stk[j]);
                    *Stk[j]=0;
                    j++;
                  }
                strcat(Stk[sj],")");
              }
            return;
          }
        if(str_cmp(t,"||")==0)
          {
            strcpy(Stk[i]," or ");
            DoJoin=TRUE;
            break;
          }
        if(str_cmp(t,"&&")==0)
          {
            strcpy(Stk[i]," and ");
            DoJoin=TRUE;
            break;
          }
        if(str_cmp(t,"then")==0 ||  str_cmp(t,"for")==0)
          {
            DoJoin=TRUE;
            break;
          }
        if(str_cmp(t,"=")==0)
          {
            if(!inif)
              {
                OnlyPara=TRUE;
              }
            else
              {
                DoJoin=TRUE;
              }
            break;
          }
        if(str_cmp(t,"if")==0 ||  str_cmp(t,"elseif")==0 ||  str_cmp(t,"while")==0)
          {
            inif=TRUE;
            sj=i+1;
            break;
          }
        if(str_cmp(t,"sprint")==0 ||  str_cmp(t,"lprint")==0 ||  str_cmp(t,"fprint")==0 ||  str_cmp(t,"fprintf")==0 ||  str_cmp(t,"print")==0 ||  str_cmp(t,"print#")==0)
          {
            OnlyPara=TRUE;
            break;
          }
          // case else
          {
            if(str_cmp(left(Stk[i],2),"].")==0 ||  str_cmp(left(Stk[i],3),"]->")==0)
              {
                InBrace--;
              }
          }
        break;
      }
      if((DoJoin||inchr(",+-*/^;:<>~|&",t))&&!OnlyPara&&!InBrace)
        {
          DoJoin=0;
          if(j)
            {
              strcpy(Stk[sj], join(4,"join$(",str(j+1),",",Stk[sj]));
              j=sj;
              j++;
              while(j<i)
                {
                  strcat(Stk[sj],Stk[j]);
                  *Stk[j]=0;
                  j++;
                }
              strcat(Stk[sj],")");
            }
          j=0;
          sj=i+1;
        }
      i++;
    }
  if(j)
    {
      strcpy(Stk[sj], join(4,"join$(",str(j+1),",",Stk[sj]));
      j=sj;
      j++;
      while(j<=i)
        {
          strcat(Stk[sj],Stk[j]);
          *Stk[j]=0;
          j++;
        }
      strcat(Stk[sj],")");
    }
}


void Transforms (void)
{
  int     nBrace;
  int     CntMarker;
  int     IFCond;
  int     a;
  int     i;
  int     j;
  char Keyword[2048];
  char lszTmp[2048];
  *Keyword=0;
  *lszTmp=0;
  if(Ndx==3&&!WithCnt)
    {
      if(str_cmp(Stk[2],"+")==0 &&  str_cmp(Stk[3],"+")==0)
        {
          fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stk[1]),"++;");
          Ndx=0;
          Statements++;
          return;
        }
      if(str_cmp(Stk[2],"-")==0 &&  str_cmp(Stk[3],"-")==0)
        {
          fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stk[1]),"--;");
          Ndx=0;
          Statements++;
          return;
        }
      if(str_cmp(Stk[1],"+")==0 &&  str_cmp(Stk[2],"+")==0)
        {
          fprintf(Outfile,"%s%s%s%s\n",Scoot,"++",Clean(Stk[3]),";");
          Ndx=0;
          Statements++;
          return;
        }
      if(str_cmp(Stk[1],"-")==0 &&  str_cmp(Stk[2],"-")==0)
        {
          fprintf(Outfile,"%s%s%s%s\n",Scoot,"--",Clean(Stk[3]),";");
          Ndx=0;
          Statements++;
          return;
        }
    }
  strcpy(Keyword,lcase(Stk[1]));
  a=inchr("abcdefghijklmnopqrstuvwxyz$",Keyword);
  for(;;)
  {
    if(a==3)
      {
        if(str_cmp(Keyword,"case")==0)
          {
            nBrace=0;
            CntMarker=2;
            j=0;
            for(i=2; i<=Ndx; i+=1)
              {
                if(inchr("([",Stk[i]))
                  {
                    nBrace++;
                  }
                if(inchr(")]",Stk[i]))
                  {
                    nBrace--;
                  }
                if(str_cmp(Stk[i],",")==0)
                  {
                    if(nBrace==0)
                      {
                        CntMarker=i+1;
                      }
                  }
                if(iMatchWrd(Stk[i],"to"))
                  {
                    j=1;
                    strcpy(Stk[i]," and <=");
                    strcpy(Stk[CntMarker], join(2,">=",Stk[CntMarker]));
                  }
              }
            if(j==1)
              {
                *Src=0;
                for(i=1; i<=Ndx; i+=1)
                  {
                    strcpy(Src, join(3,Src,Stk[i]," "));
                  }
                XParse(Src);
              }
            return;
          }
        break;
      }
    if(a==4)
      {
        if(str_cmp(Keyword,"declare")==0 && iMatchWrd(Stk[4],"lib"))
          {
            char alias[2048];
            int     i;
            int     idx=-1;
            char AR_DllName[2048];
            strcpy(Stk[5],RemoveStr(Stk[5],DQ));
            for(i=0; i<=LoadLibsCnt-1; i+=1)
              {
                if(str_cmp(Stk[5],Loadlibs[i])==0)
                  {
                    idx=i;
                    break;
                  }
              }
            if(idx<0)
              {
                strcpy(Loadlibs[LoadLibsCnt],Stk[5]);
                LoadLibsCnt++;
              }
            if(iMatchWrd(Stk[6],"alias"))
              {
                strcpy(alias,Stk[7]);
                *Stk[6]=0;
                *Stk[7]=0;
              }
            else
              {
                strcpy(alias,enc(Stk[3]));
              }
            DllCnt++;
            if(DllCnt>799)
              {
                Abort("Maximum number of declarations exceded.");
              }
            if(inchr(Stk[5],"-"))
              {
                strcpy(AR_DllName,extract(Stk[5],"-"));
              }
            else if(inchr(Stk[5],"."))
              {
                strcpy(AR_DllName,extract(Stk[5],"."));
              }
            strcpy(DllDecl[DllCnt], join(11,"static BCXFPROT",ltrim(str(DllCnt)),SPC,Clean(Stk[3]),"=(BCXFPROT",ltrim(str(DllCnt)),")dlsym(H_",ucase(AR_DllName),", ",alias,");"));
            *Stk[4]=0;
            *Stk[5]=0;
            return;
          }
        break;
      }
    if(a==7)
      {
        if(str_cmp(Keyword,"get$")==0)
          {
            strcpy(Stk[1],"~get");
            return;
          }
        if(str_cmp(Keyword,"global")==0 && iMatchWrd(Stk[2],"dynamic"))
          {
            strcpy(Stk[1],"global");
            return;
          }
        break;
      }
    if(a==9)
      {
        if(str_cmp(Keyword,"iremove")==0)
          {
            char Mat[2048];
            char Fat[2048];
            *Mat=0;
            *Fat=0;
            for(i=2; i<=Ndx; i+=1)
              {
                if(iMatchWrd(Stk[i],"from"))
                  {
                    *Stk[i]=0;
                    break;
                  }
              }
            for(j=2; j<=i; j+=1)
              {
                strcat(Mat,Stk[j]);
              }
            for(j=i; j<=Ndx; j+=1)
              {
                strcat(Fat,Stk[j]);
              }
            strcpy(lszTmp, join(5,"=iremove$(",Fat,",",Mat,")"));
            FastLexer(Fat," ()","");
            strcpy(lszTmp, join(2,Stk[Ndx],lszTmp));
            XParse(lszTmp);
            TokenSubstitutions();
            Emit();
            Ndx=0;
            return;
          }
        if(str_cmp(Keyword,"ireplace")==0)
          {
            if(Ndx<6)
              {
                Abort("Problem with IREPLACE statement");
              }
            int     W;
            int     I;
            char VV[2048];
            char RR[2048];
            char WW[2048];
            *VV=0;
            *RR=0;
            *WW=0;
            for(W=2; W<=Ndx; W+=1)
              {
                if(iMatchWrd(Stk[W],"with"))
                  {
                    *Stk[W]=0;
                    break;
                  }
              }
            for(I=2; I<=Ndx; I+=1)
              {
                if(iMatchWrd(Stk[I],"in"))
                  {
                    *Stk[I]=0;
                    break;
                  }
              }
            i=I+1;
            for(j=i; j<=Ndx; j+=1)
              {
                strcat(VV,Stk[j]);
              }
            for(j=2; j<=W; j+=1)
              {
                strcat(RR,Stk[j]);
              }
            i=W+1;
            for(j=i; j<=I; j+=1)
              {
                strcat(WW,Stk[j]);
              }
            strcpy(lszTmp, join(7,"=ireplace$(",VV,",",RR,",",WW,")"));
            FastLexer(VV," ()","");
            strcpy(lszTmp, join(2,Stk[Ndx],lszTmp));
            XParse(lszTmp);
            TokenSubstitutions();
            Emit();
            Ndx=0;
            return;
          }
        break;
      }
    if(a==12)
      {
        if(str_cmp(Keyword,"local")==0 && iMatchWrd(Stk[2],"dynamic"))
          {
            strcpy(Stk[1],"dim");
            return;
          }
        break;
      }
    if(a==16)
      {
        if(str_cmp(Keyword,"put$")==0)
          {
            strcpy(Stk[1],"~put");
            return;
          }
        break;
      }
    if(a==18)
      {
        if(str_cmp(Keyword,"remove")==0)
          {
            char Mat[2048];
            char Fat[2048];
            *Mat=0;
            *Fat=0;
            for(i=2; i<=Ndx; i+=1)
              {
                if(iMatchWrd(Stk[i],"from"))
                  {
                    *Stk[i]=0;
                    break;
                  }
              }
            for(j=2; j<=i; j+=1)
              {
                strcat(Mat,Stk[j]);
              }
            for(j=i; j<=Ndx; j+=1)
              {
                strcat(Fat,Stk[j]);
              }
            strcpy(lszTmp, join(5,"=remove$(",Fat,",",Mat,")"));
            FastLexer(Fat," ()","");
            strcpy(lszTmp, join(2,Stk[Ndx],lszTmp));
            XParse(lszTmp);
            TokenSubstitutions();
            Emit();
            Ndx=0;
            return;
          }
        if(str_cmp(Keyword,"replace")==0)
          {
            if(Ndx<6)
              {
                Abort("Problem with REPLACE statement");
              }
            int     W;
            int     I;
            char VV[2048];
            char RR[2048];
            char WW[2048];
            *VV=0;
            *RR=0;
            *WW=0;
            for(W=2; W<=Ndx; W+=1)
              {
                if(iMatchWrd(Stk[W],"with"))
                  {
                    *Stk[W]=0;
                    break;
                  }
              }
            for(I=2; I<=Ndx; I+=1)
              {
                if(iMatchWrd(Stk[I],"in"))
                  {
                    *Stk[I]=0;
                    break;
                  }
              }
            i=I+1;
            for(j=i; j<=Ndx; j+=1)
              {
                strcat(VV,Stk[j]);
              }
            for(j=2; j<=W; j+=1)
              {
                strcat(RR,Stk[j]);
              }
            i=W+1;
            for(j=i; j<=I; j+=1)
              {
                strcat(WW,Stk[j]);
              }
            strcpy(lszTmp, join(7,"=replace$(",VV,",",RR,",",WW,")"));
            FastLexer(VV," ()","");
            strcpy(lszTmp, join(2,Stk[Ndx],lszTmp));
            XParse(lszTmp);
            TokenSubstitutions();
            Emit();
            Ndx=0;
            return;
          }
        break;
      }
    if(a==27)
      {
        for(;;)
        {
          if(str_cmp(Keyword,"$ifndef")==0)
            {
              strcpy(Stk[1],"~ifndef");
              InConditional++;
              break;
            }
          if(str_cmp(Keyword,"$if")==0 ||  str_cmp(Keyword,"$ifdef")==0)
            {
              strcpy(Stk[1],"~if");
              InConditional++;
              break;
            }
          if(str_cmp(Keyword,"$else")==0)
            {
              strcpy(Stk[1],"~else");
              break;
            }
          if(str_cmp(Keyword,"$elseif")==0)
            {
              strcpy(Stk[1],"~elseif");
              break;
            }
          if(str_cmp(Keyword,"$endif")==0)
            {
              strcpy(Stk[1],"~endif");
              InConditional--;
              if(InConditional<0)
                {
                  Abort("To many $ENDIFs");
                }
              break;
            }
          if(str_cmp(Keyword,"$cpp")==0)
            {
              Ndx=0;
              UseCpp=TRUE;
              break;
            }
          if(str_cmp(Keyword,"$CPP")==0)
            {
              Ndx=0;
              UseCpp=TRUE;
            }
          break;
        }
        return;
      }
    break;
  }
  IFCond=0;
  for(i=1; i<=Ndx; i+=1)
    {
      if(iMatchWrd(Stk[i],"if"))
        {
          IFCond=i+1;
        }
      if(iMatchWrd(Stk[i],"then")&&iMatchWrd(Stk[i+1],"if"))
        {
          for(j=i+2; j<=Ndx; j+=1)
            {
              if(iMatchWrd(Stk[j],"else"))
                {
                  break;
                }
            }
          if(j>Ndx)
            {
              for(j=i; j>=IFCond+1; j+=-1)
                {
                  strcpy(Stk[j],Stk[j-1]);
                }
              strcpy(Stk[IFCond],"(");
              i++;
              strcpy(Stk[i],")");
              i++;
              for(j=Ndx; j>=i; j+=-1)
                {
                  strcpy(Stk[j+2],Stk[j]);
                }
              Ndx++;
              Ndx++;
              strcpy(Stk[i],"&&");
              i++;
              strcpy(Stk[i],"(");
              i++;
              for(i=i; i<=Ndx; i+=1)
                {
                  if(iMatchWrd(Stk[i],"then"))
                    {
                      Ndx++;
                      for(j=Ndx; j>=i; j+=-1)
                        {
                          strcpy(Stk[j],Stk[j-1]);
                        }
                      strcpy(Stk[i],")");
                      break;
                    }
                }
              i--;
            }
          else
            {
              break;
            }
        }
    }
}


void Parse (char *Arg)
{
  int     A;
  int     B;
  int     CommaCnt;
  int     Tmp;
  int     i;
  int     j;
  int     k;
  char lszTmp[2048];
  char L_Stk_1[2048];
  char L_Stk_2[2048];
  char Var1[2048];
  int     Plus2Amp=0;
  int     vt;
  *L_Stk_1=0;
  *L_Stk_2=0;
  *lszTmp=0;
  *Var1=0;
  XParse(Arg);
  PassOne=0;
  if(!iMatchWrd(Stk[1],"function"))
    {
      Plus2Amp=iMatchNQ(Arg,"&");
      for(Tmp=2; Tmp<=Ndx-1; Tmp+=1)
        {
          if(str_cmp(Stk[Tmp],"+")==0)
            {
              vt=DataType(Stk[Tmp+1]);
              if(vt==vt_STRVAR||vt==vt_STRLIT)
                {
                  strcpy(Stk[Tmp],"&");
                  Plus2Amp=TRUE;
                }
              else
                {
                  vt=DataType(Stk[Tmp-1]);
                  if(vt==vt_STRVAR||vt==vt_STRLIT)
                    {
                      strcpy(Stk[Tmp],"&");
                      Plus2Amp=TRUE;
                    }
                }
            }
        }
      if(Plus2Amp>0)
        {
          Use_Join=UseFlag=TRUE;
          j=0;
          k=0;
          for(Tmp=1; Tmp<=Ndx-1; Tmp+=1)
            {
              A=CheckLocal(Stk[Tmp], &i);
              if(A==vt_UNKNOWN)
                {
                  A=CheckGlobal(Stk[Tmp], &i);
                }
              if(A==vt_STRUCT||A==vt_UDT||A==vt_UNION)
                {
                  j=1;
                }
              if(str_cmp(Stk[Tmp],"&")==0)
                {
                  A=DataType(Stk[Tmp+1]);
                  if(A==vt_STRVAR||A==vt_STRLIT)
                    {
                      k=1;
                    }
                  else
                    {
                      A=DataType(Stk[Tmp-1]);
                      if(A==vt_STRVAR||A==vt_STRLIT)
                        {
                          k=1;
                        }
                    }
                }
            }
          if(k)
            {
              if(j)
                {
                  AsmUnknownStructs(0);
                }
              JoinStrings(1,0);
              *Src=0;
              for(i=1; i<=Ndx; i+=1)
                {
                  if(Stk[i][0])
                    {
                      strcpy(Src, join(3,Src,Stk[i]," "));
                    }
                }
              XParse(Src);
            }
        }
    }
  if(UseCpp)
    {
      if(iMatchNQ(Src,"->lpVtbl"))
        {
            {int i;
          for(i=1; i<=Ndx; i+=1)
            {
              if(iMatchRgt(Stk[i],"->lpVtbl"))
                {
                  strcpy(Stk[i],extract(Stk[i],"->lpVtbl"));
                  if((str_cmp(Stk[i+3],Stk[i-1])==0 ||  str_cmp(Stk[i+3],Stk[i])==0) &&  str_cmp(Stk[i+3],")")!=0)
                    {
                      *Stk[i+3]=0;
                      if(str_cmp(Stk[i+4],",")==0)
                        {
                          *Stk[i+4]=0;
                        }
                    }
                }
            }
            }
          RemEmptyTokens();
        }
    }
  TokenSubstitutions();
  if(Ndx==0)
    {
      return;
    }
  Transforms();
  if(Ndx==0)
    {
      return;
    }
  if(iMatchWrd(Stk[1],"function"))
    {
      if(iMatchWrd(Stk[Ndx-2],"as")&&str_cmp(Stk[Ndx],")")!=0)
        {
          if(!iMatchWrd(Stk[Ndx],"export")&&!iMatchWrd(Stk[Ndx],"stdcall"))
            {
              strcpy(Stk[Ndx-1], join(3,Stk[Ndx-1]," ",Stk[Ndx]));
              Ndx--;
            }
        }
    }
  if(iMatchWrd(Stk[1],"function")||iMatchWrd(Stk[1],"sub"))
    {
      int     offset;
      int     LastBrk=Ndx-2;
      for(i=Ndx; i>=3; i+=-1)
        {
          if(str_cmp(Stk[i],")")==0)
            {
              LastBrk=i;
              break;
            }
        }
      for(i=3; i<=LastBrk; i+=1)
        {
          offset=2;
          if(iMatchWrd(Stk[i],"as")&&(i<LastBrk)&&str_cmp(Stk[i+offset],"=")!=0)
            {
              if(iMatchWrd(Stk[i+1],"function"))
                {
                  offset=3;
                }
              if(!inchr(Stk[i+offset],")")&&!inchr(Stk[i+offset],","))
                {
                  if(strlen(Stk[i+offset])!=0&&!iMatchWrd(Stk[i+3],"as"))
                    {
                      strcpy(Stk[i+offset-1], join(3,Stk[i+offset-1]," ",Stk[i+offset]));
                      *Stk[i+offset]=0;
                    }
                }
            }
        }
    }
  if(!iMatchWrd(Stk[1],"declare"))
    {
      for(i=1; i<=Ndx; i+=1)
        {
          if(iMatchWrd(Stk[i],"lib"))
            {
              if(str_cmp(Stk[i-1],"(")==0 && (DataType(Stk[i+1])==vt_STRLIT||DataType(Stk[i+1])==vt_STRVAR))
                {
                  j=GetNumArgs(i+2);
                  strcpy(lszTmp,"BCX_DynaCall");
                  if(!iMatchWrd(Stk[1],"print"))
                    {
                      if(DataType(Stk[i-2])==vt_STRVAR||DataType(Stk[1])==vt_STRVAR)
                        {
                          strcpy(lszTmp, join(2,"(char*)",lszTmp));
                        }
                    }
                  strcpy(Var1,right(Stk[i-2],1));
                  if(inchr("!$#¦%",Var1))
                    {
                      strcat(lszTmp,Var1);
                      strcpy(Stk[i],enc(left(Stk[i-2],strlen(Stk[i-2])-1)));
                    }
                  else
                    {
                      strcpy(Stk[i],enc(Stk[i-2]));
                    }
                  strcpy(Stk[i-2],lszTmp);
                  for(B=Ndx+3; B>=i+3; B+=-1)
                    {
                      strcpy(Stk[B],Stk[B-3]);
                    }
                  strcpy(Stk[i+2],Stk[i+1]);
                  strcpy(Stk[i+1],",");
                  strcpy(Stk[i+3],",");
                  strcpy(Stk[i+4],ltrim(str(j)));
                  strcpy(Stk[i+5],sziif(j,",",")"));
                  Ndx+=(3);
                  Use_Dynacall=TRUE;
                }
            }
        }
    }
  if(inchr(Arg,"^"))
    {
      int     lp=0;
      int     rp=0;
      Test=FALSE;
      for(i=1; i<=Ndx; i+=1)
        {
          if(str_cmp(Stk[i],"^")==0)
            {
              Test=TRUE;
              if(str_cmp(Stk[i+1],"-")==0)
                {
                  Ndx++;
                  for(A=Ndx; A>=i+2; A+=-1)
                    {
                      strcpy(Stk[A],Stk[A-1]);
                    }
                  strcpy(Stk[i+1],"(");
                  B=i+3;
                  if(str_cmp(Stk[B],"(")==0)
                    {
                      lp=0;
                      rp=0;
                      for(;;)
                        {
                          if(str_cmp(Stk[B],"(")==0)
                            {
                              lp++;
                            }
                          if(str_cmp(Stk[B],")")==0)
                            {
                              rp++;
                            }
                          B++;
                          if(lp==rp)
                            {
                              break;
                            }
                        }
                      Ndx++;
                      j=B+1;
                      for(A=Ndx; A>=j; A+=-1)
                        {
                          strcpy(Stk[A],Stk[A-1]);
                        }
                      strcpy(Stk[B],")");
                    }
                  else
                    {
                      B=i+4;
                      if(inchr("[",Stk[B]))
                        {
                          for(;;)
                            {
                              B++;
                              if(inchr("]",Stk[B]))
                                {
                                  break;
                                }
                            }
                          Ndx++;
                          j=B+2;
                          for(A=Ndx; A>=j; A+=-1)
                            {
                              strcpy(Stk[A],Stk[A-1]);
                            }
                          strcpy(Stk[B+1],")");
                        }
                      else
                        {
                          if(inchr("(",Stk[B]))
                            {
                              for(;;)
                                {
                                  B++;
                                  if(inchr(")",Stk[B]))
                                    {
                                      break;
                                    }
                                }
                              Ndx++;
                              j=B+2;
                              for(A=Ndx; A>=j; A+=-1)
                                {
                                  strcpy(Stk[A],Stk[A-1]);
                                }
                              strcpy(Stk[B+1],")");
                            }
                          else
                            {
                              Ndx++;
                              j=B+1;
                              for(A=Ndx; A>=j; A+=-1)
                                {
                                  strcpy(Stk[A],Stk[A-1]);
                                }
                              strcpy(Stk[B],")");
                            }
                        }
                    }
                }
            }
        }
      if(Test)
        {
          for(i=1; i<=Ndx; i+=1)
            {
              if(str_cmp(Stk[i],"^")==0)
                {
                  A=i-1;
                  B=0;
                  while(str_cmp(Stk[A],"=")!=0)
                    {
                      if(str_cmp(Stk[A],"]")==0)
                        {
                          B++;
                        }
                      if(str_cmp(Stk[A],")")==0)
                        {
                          B++;
                        }
                      if(str_cmp(Stk[A],"[")==0)
                        {
                          B--;
                        }
                      if(str_cmp(Stk[A],"(")==0)
                        {
                          B--;
                        }
                      if(B==0)
                        {
                          break;
                        }
                      A--;
                    }
                  if(str_cmp(Stk[A],"[")==0)
                    {
                      A--;
                    }
                  if(str_cmp(Stk[A],"=")==0)
                    {
                      A++;
                    }
                  if(str_cmp(Stk[A],"(")==0)
                    {
                      B=DataType(Stk[A-1]);
                      if(!iMatchWrd(Stk[A-1],"print")&&(B==vt_INTEGER||B==vt_SINGLE||B==vt_DOUBLE))
                        {
                          A--;
                        }
                    }
                  strcpy(Arg,"pow(");
                  B=A-1;
                  while(B>0)
                    {
                      strcpy(Arg, join(4,Stk[B]," ",Arg," "));
                      B--;
                    }
                  for(B=A; B<=i-1; B+=1)
                    {
                      strcpy(Arg, join(3,Arg," ",Stk[B]));
                    }
                  strcat(Arg,",");
                  A=i+1;
                  B=DataType(Stk[A]);
                  if((str_cmp(Stk[A+1],"(")==0 ||  str_cmp(Stk[A+1],"[")==0) && (B==vt_INTEGER||B==vt_SINGLE||B==vt_DOUBLE))
                    {
                      A++;
                    }
                  B=0;
                  while(A<=Ndx)
                    {
                      if(str_cmp(Stk[A],"[")==0)
                        {
                          B++;
                        }
                      if(str_cmp(Stk[A],"(")==0)
                        {
                          B++;
                        }
                      if(str_cmp(Stk[A],"]")==0)
                        {
                          B--;
                        }
                      if(str_cmp(Stk[A],")")==0)
                        {
                          B--;
                        }
                      if(!B)
                        {
                          break;
                        }
                      A++;
                    }
                  for(B=i+1; B<=A; B+=1)
                    {
                      strcpy(Arg, join(3,Arg," ",Stk[B]));
                    }
                  strcat(Arg,")");
                  A++;
                  while(A<=Ndx)
                    {
                      strcpy(Arg, join(3,Arg," ",Stk[A]));
                      A++;
                    }
                  break;
                }
            }
          Parse(Arg);
        }
    }
  strcpy(L_Stk_1,lcase(Stk[1]));
  strcpy(L_Stk_2,lcase(Stk[2]));
  if(str_cmp(L_Stk_1,"$dll")==0)
    {
      MakeDLL=NoMain=TRUE;
      if(IsApple)
        {
          strcpy(LD_FLAGS,"-fPIC -shared $FILE$.so");
        }
      else
        {
          strcpy(LD_FLAGS,"-fPIC -shared -Wl,-soname,$FILE$.so");
        }
      Ndx=0;
      return;
    }
  IsCallBack=0;
  if(iMatchWrd(Stk[Ndx],"callback"))
    {
      IsCallBack=1;
      Ndx--;
    }
  if(str_cmp(L_Stk_1,"open")==0)
    {
      for(A=1; A<=Ndx; A+=1)
        {
          if(iMatchWrd(Stk[A],"binary"))
            {
              break;
            }
        }
      if(A<Ndx)
        {
          A++;
          strcpy(Var1,lcase(Stk[A]));
          if(str_cmp(Var1,"new")==0)
            {
              strcpy(Stk[A-1],"binarynew");
              for(i=A+1; i<=Ndx; i+=1)
                {
                  strcpy(Stk[i-1],Stk[i]);
                }
              Ndx--;
            }
          if(str_cmp(Var1,"append")==0)
            {
              strcpy(Stk[A-1],"binaryappend");
              for(i=A+1; i<=Ndx; i+=1)
                {
                  strcpy(Stk[i-1],Stk[i]);
                }
              Ndx--;
            }
          if(str_cmp(Var1,"input")==0)
            {
              strcpy(Stk[A-1],"binaryinput");
              for(i=A+1; i<=Ndx; i+=1)
                {
                  strcpy(Stk[i-1],Stk[i]);
                }
              Ndx--;
            }
          if(str_cmp(Var1,"output")==0)
            {
              strcpy(Stk[A-1],"binaryoutput");
              for(i=A+1; i<=Ndx; i+=1)
                {
                  strcpy(Stk[i-1],Stk[i]);
                }
              Ndx--;
            }
        }
    }
  if(str_cmp(L_Stk_1,"option")==0 &&  str_cmp(L_Stk_2,"base")==0)
    {
      OptionBase=VAL(Stk[3]);
      Ndx=0;
      return;
    }
  if(str_cmp(L_Stk_1,"dim")==0)
    {
      if(str_cmp(L_Stk_2,"shared")==0 ||  str_cmp(L_Stk_2,"dynamic")==0 ||  str_cmp(L_Stk_2,"raw")==0 ||  str_cmp(L_Stk_2,"local")==0 ||  str_cmp(L_Stk_2,"auto")==0 ||  str_cmp(L_Stk_2,"register")==0 ||  str_cmp(L_Stk_2,"static")==0)
        {
          strcpy(Stk[1],L_Stk_2);
          strcpy(L_Stk_1,L_Stk_2);
          for(i=3; i<=Ndx; i+=1)
            {
              strcpy(Stk[i-1],Stk[i]);
            }
          Ndx--;
        }
    }
  if(str_cmp(L_Stk_1,"public")==0)
    {
      if(str_cmp(L_Stk_2,"function")==0 ||  str_cmp(L_Stk_2,"sub")==0)
        {
          strcpy(Stk[1],L_Stk_2);
          strcpy(L_Stk_1,L_Stk_2);
          for(i=3; i<=Ndx; i+=1)
            {
              strcpy(Stk[i-1],Stk[i]);
            }
          Ndx--;
        }
    }
  if(str_cmp(L_Stk_1,"private")==0)
    {
      if(str_cmp(L_Stk_2,"function")==0 ||  str_cmp(L_Stk_2,"sub")==0)
        {
          Use_Static=TRUE;
          strcpy(Stk[1],L_Stk_2);
          strcpy(L_Stk_1,L_Stk_2);
          for(i=3; i<=Ndx; i+=1)
            {
              strcpy(Stk[i-1],Stk[i]);
            }
          Ndx--;
        }
    }
  if(str_cmp(L_Stk_1,"onexit")==0)
    {
      if(str_cmp(L_Stk_2,"sub")==0)
        {
          Use_ExitCode=TRUE;
          ExitNdx++;
          strcpy(ExitSub[ExitNdx],Stk[3]);
          strcpy(Stk[1],L_Stk_2);
          strcpy(L_Stk_1,L_Stk_2);
          for(i=3; i<=Ndx; i+=1)
            {
              strcpy(Stk[i-1],Stk[i]);
            }
          Ndx--;
        }
    }
  if(str_cmp(L_Stk_1,"onstart")==0)
    {
      if(str_cmp(L_Stk_2,"sub")==0)
        {
          Use_StartupCode=TRUE;
          StartNdx++;
          strcpy(StartSub[StartNdx],Stk[3]);
          strcpy(Stk[1],L_Stk_2);
          strcpy(L_Stk_1,L_Stk_2);
          for(i=3; i<=Ndx; i+=1)
            {
              strcpy(Stk[i-1],Stk[i]);
            }
          Ndx--;
        }
    }
  if(str_cmp(L_Stk_1,"overloaded")==0 &&  str_cmp(L_Stk_2,"function")==0)
    {
      strcpy(Stk[1],"overloadedfunction");
      strcpy(L_Stk_1,"overloadedfunction");
      for(i=3; i<=Ndx; i+=1)
        {
          strcpy(Stk[i-1],Stk[i]);
        }
      Ndx--;
    }
  if(str_cmp(L_Stk_1,"overloadedfunction")==0 &&  str_cmp(Stk[2],"=")!=0)
    {
      OkayToSend=TRUE;
    }
  if(str_cmp(L_Stk_1,"overloaded")==0 &&  str_cmp(L_Stk_2,"sub")==0)
    {
      strcpy(Stk[1],"overloadedsub");
      for(i=3; i<=Ndx; i+=1)
        {
          strcpy(Stk[i-1],Stk[i]);
        }
      Ndx--;
    }
  if(str_cmp(L_Stk_1,"function")==0 && iMatchWrd(Stk[3],"optional"))
    {
      strcpy(Stk[1],"optfunction");
      strcpy(L_Stk_1,"optfunction");
      for(i=4; i<=Ndx; i+=1)
        {
          strcpy(Stk[i-1],Stk[i]);
        }
      Ndx--;
    }
  if(str_cmp(L_Stk_1,"optfunction")==0 &&  str_cmp(Stk[2],"=")!=0)
    {
      OkayToSend=TRUE;
    }
  if(str_cmp(L_Stk_1,"sub")==0 && iMatchWrd(Stk[3],"optional"))
    {
      strcpy(L_Stk_1,"optsub");
      strcpy(Stk[1],"optsub");
      for(i=4; i<=Ndx; i+=1)
        {
          strcpy(Stk[i-1],Stk[i]);
        }
      Ndx--;
    }
  if(str_cmp(L_Stk_1,"end")==0 &&  str_cmp(Stk[2],"=")!=0)
    {
      strcpy(Stk[1], join(2,L_Stk_1,L_Stk_2));
      Ndx=1;
    }
  if(str_cmp(L_Stk_1,"function")==0 &&  str_cmp(Stk[2],"=")!=0)
    {
      OkayToSend=TRUE;
    }
  if(str_cmp(L_Stk_1,"midstr")==0)
    {
      CommaCnt=0;
      for(i=1; i<=Ndx; i+=1)
        {
          if(str_cmp(Stk[i],",")==0)
            {
              CommaCnt++;
            }
          else if(str_cmp(Stk[i],"=")==0)
            {
              if(CommaCnt<2)
                {
                  strcpy(Stk[i],"-1,");
                }
              else
                {
                  *Stk[i]=0;
                }
              strcpy(Stk[i-1],",");
              Ndx++;
              strcpy(Stk[Ndx],")");
              break;
            }
        }
    }
  if(str_cmp(Stk[2],":")==0)
    {
      if(Ndx==2)
        {
          strcpy(Stk[1], join(2,ucase(Stk[1]),":"));
          Ndx=1;
          return;
        }
    }
  if(str_cmp(L_Stk_1,"case")==0 &&  str_cmp(L_Stk_2,"else")==0)
    {
      Ndx=1;
      strcpy(Stk[1],"caseelse");
    }
  for(i=1; i<=Ndx; i+=1)
    {
      if(iMatchWrd(Stk[i],"let"))
        {
          for(j=i+1; j<=Ndx; j+=1)
            {
              strcpy(Stk[j-1],Stk[j]);
            }
          Ndx--;
        }
    }
  if(str_cmp(Stk[Ndx],"*")==0)
    {
      strcpy(Stk[Ndx-1], join(2,Stk[Ndx-1],"*"));
      Ndx--;
    }
  if(TestState==TRUE)
    {
      if(LastCmd==0)
        {
          if(str_cmp(Stk[1],"*")==0)
            {
              strcpy(Z,Clean(Stk[2]));
            }
          else
            {
              strcpy(Z,Clean(Stk[1]));
            }
          if(str_cmp(left(Z,1),"*")==0)
            {
              strcpy(Z,mid(Z,2));
            }
          i=inchr(Z,".");
          if(i==0)
            {
              i=instr_b(Z,"->");
            }
          if(i>0)
            {
              if(WithCnt)
                {
                  strcpy(Z,WithVar[WithCnt]);
                }
              else
                {
                  strcpy(Z,left(Z,i-1));
                }
            }
          if(inchr(Z,"["))
            {
              strcpy(Z,extract(Z,"["));
            }
          if(CheckLocal(Z, &j)==vt_UNKNOWN)
            {
              if(CheckGlobal(Z, &j)==vt_UNKNOWN)
                {
                  strcpy(Z,lcase(Z));
                  if(str_cmp(Stk[2],"=")==0 &&  str_cmp(Z,"functionreturn")!=0 &&  str_cmp(Z,"bcx_retstr")!=0 &&  str_cmp(Z,"end")!=0)
                    {
                      Warning(join(6,"Assignment before Declaration in Line ",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx]),": ",Src));
                    }
                }
            }
        }
    }
}


void FuncSubDecs1 (char *s)
{
  int     i;
  int     j;
  if(iMatchWrd(Stk[1],s))
    {
      if(DataType(Stk[2])==vt_STRVAR)
        {
          Abort(join(3,"Invalid ",s,"name"));
        }
    }
  for(i=1; i<=Ndx; i+=1)
    {
      if(str_cmp(Stk[i],"[")==0 &&  str_cmp(Stk[i+1],"]")==0)
        {
          if(iMatchWrd(Stk[i+2],"as"))
            {
              strcpy(Stk[i+3], join(2,Stk[i+3],"*"));
            }
          else if(str_cmp(Stk[i+2],"[")==0)
            {
              j=i-1;
              while(i<=Ndx)
                {
                  if(iMatchWrd(Stk[i],"as"))
                    {
                      break;
                    }
                  if(iMatchRgt(Stk[j],"]")&&inchr(",)=",Stk[i]))
                    {
                      break;
                    }
                  strcpy(Stk[j], join(2,Stk[j],Stk[i]));
                  *Stk[i++]=0;
                }
              continue;
            }
          else
            {
              if(DataType(Stk[i-1])==vt_STRVAR)
                {
                  strcpy(Stk[i-1], join(2,Stk[i-1],"[][65535]"));
                }
              strcpy(Stk[i-1], join(2,"*",Stk[i-1]));
            }
          *Stk[i++]=0;
          *Stk[i]=0;
        }
    }
  RemEmptyTokens();
  IsExported=FALSE;
  if(iMatchWrd(Stk[Ndx],"export"))
    {
      Ndx--;
      IsExported=TRUE;
      if(UseStdCall)
        {
          strcpy(CallType,"__attribute__((stdcall)) ");
        }
      else
        {
          strcpy(CallType,"__attribute__((cdecl)) ");
        }
    }
}


void RemEmptyTokens (void)
{
  int     i;
  int     j;
  for(i=1; i<=Ndx; i+=1)
    {
      if(!*Stk[i])
        {
          j=i;
          while(!*Stk[j]&&(j<Ndx))
            {
              j++;
            }
          if(!*Stk[j])
            {
              break;
            }
          strcpy(Stk[i],Stk[j]);
          *Stk[j]=0;
        }
    }
  Ndx=i-1;
}


void FuncSubDecs2 (char *s, int method)
{
  if(iMatchWrd(Stk[1],s))
    {
      if(iMatchWrd(Stk[Ndx-1],"as"))
        {
          Abort(join(2,"Attempted type assignment to ",s));
        }
      VarCode.IsPtrFlag=0;
      CurrentFuncType=vt_VOID;
    }
  else
    {
      if(iMatchWrd(Stk[Ndx-1],"as"))
        {
          CurrentFuncType=CheckType(Stk[Ndx]);
          strcpy(VarCode.Token,Stk[2]);
          strcpy(VarCode.AsToken,Stk[Ndx]);
          VarCode.IsPtrFlag=tally(Stk[Ndx],"*");
          *Stk[Ndx]=0;
          *Stk[Ndx-1]=0;
          Ndx--;
          Ndx--;
        }
      else
        {
          CurrentFuncType=DataType(Stk[2]);
          strcpy(VarCode.Token,Stk[2]);
          VarCode.IsPtrFlag=tally(Stk[2],"*");
          *VarCode.AsToken=0;
        }
    }
  strcpy(VarCode.Proto," (");
  strcpy(VarCode.Header," (");
  *VarCode.Functype=0;
  VarCode.Method=method;
  VarCode.VarNo=CurrentFuncType;
  GetVarCode( &VarCode);
}


void FuncSubDecs3 (VARCODE* varcode)
{
  if(*Stk[Ndx-1]==46)
    {
      strcat(varcode->Header,"...");
    }
  strcpy(varcode->Header,rtrim(varcode->Header));
  if(iMatchRgt(varcode->Header,","))
    {
      midstr(varcode->Header,strlen(varcode->Header),-1,")");
    }
  else
    {
      strcat(varcode->Header,")");
    }
  strcpy(varcode->Header,replace(varcode->Header,"()","(void)"));
  strcpy(varcode->Header, join(3,varcode->Functype,varcode->Token,varcode->Header));
  if(varcode->Method==2)
    {
      if(*Stk[Ndx-1]==46)
        {
          strcat(varcode->Proto,"...");
        }
      strcpy(varcode->Proto,rtrim(varcode->Proto));
      if(iMatchRgt(varcode->Proto,","))
        {
          midstr(varcode->Proto,strlen(varcode->Proto),-1,")");
        }
      else
        {
          strcat(varcode->Proto,")");
        }
      strcpy(varcode->Proto,replace(varcode->Proto,"()","(void)"));
      strcpy(varcode->Proto, join(4,varcode->Functype,varcode->Token,varcode->Proto,";"));
    }
  if(IsExported)
    {
      strcpy(varcode->Proto, join(2,"C_EXPORT ",varcode->Proto));
      strcpy(varcode->Header, join(2,"C_EXPORT ",varcode->Header));
    }
}


void AddTypeDefs (char *TypeName, int TDef)
{
  TypeDefsCnt++;
  if(TypeDefsCnt==MaxTypes)
    {
      Abort("Exceeded TYPE Limits.");
    }
  strcpy(TypeDefs[TypeDefsCnt].VarName,TypeName);
  TypeDefs[TypeDefsCnt].TypeofDef=TDef;
  TypeDefs[TypeDefsCnt].EleCnt=0;
}


int DefsID (char *ZZ)
{
  int     i;
  if(TypeDefsCnt>0)
    {
      for(i=1; i<=TypeDefsCnt; i+=1)
        {
          if(str_cmp(ZZ,TypeDefs[i].VarName)==0)
            {
              return i;
            }
        }
    }
  return 0;
}


void GetTypeInfo (char *stk, int* IsPointer, int* UdtIdx, int* vtCode)
{
  char Var1[2048];
  (*IsPointer)=tally(stk,"*");
  strcpy(Var1,RemoveStr(stk,"*"));
  if(str_cmp(right(Var1,6),"_CLASS")==0)
    {
      strcpy(Var1,left(Var1,strlen(Var1)-6));
    }
  (*vtCode)=CheckType(Var1);
  if((*vtCode)==vt_UNKNOWN)
    {
      AddTypeDefs(Var1,vt_UDT);
      (*vtCode)=vt_UDT;
    }
  (*UdtIdx)=0;
  if((*vtCode)==vt_STRUCT||(*vtCode)==vt_UNION||(*vtCode)==vt_UDT)
    {
      (*UdtIdx)=DefsID(Var1);
    }
}


void AddTypedefElement (int WorkingTypeDefsCnt, int ElType, char *EName, char *EType, int EPtr)
{
   UserTypeDefs*  TD;
  TD= &(TypeDefs[WorkingTypeDefsCnt]);
  if(TD->EleCnt==MaxElements)
    {
      Abort("Exceeded TYPE Element Limits.");
    }
  TD->Elements[TD->EleCnt].ElementType=ElType;
  TD->Elements[TD->EleCnt].ElementDynaPtr=EPtr;
  if(ElType==vt_STRUCT||ElType==vt_UNION||ElType==vt_UDT)
    {
      TD->Elements[TD->EleCnt].ElementID=DefsID(EType);
    }
  else
    {
      TD->Elements[TD->EleCnt].ElementID=0;
    }
  strcpy(TD->Elements[TD->EleCnt].ElementName,EName);
  TD->EleCnt=1+TD->EleCnt;
}


char * GetElement (int StartStk, int* vt, int* dms, int id)
{
  char *BCX_RetStr={0};
  int     BC=0;
  int     i;
  char ZZ[2048];
  for(i=StartStk+1; i<=Ndx; i+=1)
    {
      if(str_cmp(Stk[i],"[")==0)
        {
          BC++;
        }
      else if(str_cmp(Stk[i],"]")==0)
        {
          BC--;
        }
      else if(BC==0)
        {
          if(iMatchLft(Stk[i],"->")||*Stk[i]==46)
            {
              strcpy(ZZ,Clean(Stk[i]));
              RemoveAll(ZZ,".->(*)",1);
              (*vt)=GetElementInfo( &id,dms,ZZ);
              if((*vt)!=vt_STRUCT&&(*vt)!=vt_UNION)
                {
                  break;
                }
            }
        }
    }
  if((*vt)==vt_UDT||(*vt)==vt_UNION||(*vt)==vt_STRUCT)
    {
      strcpy(ZZ,TypeDefs[id].VarName);
    }
  else
    {
      strcpy(ZZ,GetVarTypeName(*vt));
    }
  BCX_RetStr=BCX_TmpStr(strlen(ZZ));
  strcpy(BCX_RetStr,ZZ);
  return BCX_RetStr;
}


int GetElementInfo (int* DefID, int* EPtr, char *Elename)
{
  int     i;
  int     id;
  id=(*DefID);
  for(i=0; i<=TypeDefs[id].EleCnt-1; i+=1)
    {
      if(str_cmp(Elename,TypeDefs[id].Elements[i].ElementName)==0)
        {
          (*DefID)=TypeDefs[id].Elements[i].ElementID;
          (*EPtr)=TypeDefs[id].Elements[i].ElementDynaPtr;
          return TypeDefs[id].Elements[i].ElementType;
        }
    }
  return 0;
}


void HandleNonsense (void)
{
  int     i;
  for(i=1; i<=Ndx; i+=1)
    {
      if(iMatchWrd(Stk[i],"as"))
        {
          strcpy(Stk[i-1],Clean(Stk[i-1]));
        }
      if(OptionBase)
        {
          if(str_cmp(Stk[i],"[")==0)
            {
              strcpy(Stk[i+1], join(3,ltrim(str(OptionBase)),"+",Stk[i+1]));
            }
        }
    }
}


void ValidVar (char *v)
{
  char *ZZ;
  ZZ=(char*)calloc(256+65535,1);
  if(!isalpha(*v)&&*v!=95)
    {
      if(!iMatchLft(v,"(*"))
        {
          Abort("Invalid String Variable Name");
        }
    }
  if(RestrictedWords(v)&&TestState)
    {
      strcpy(ZZ, join(3,"Variable ",v," on line"));
      strcpy(ZZ, join(5,ZZ,str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," is a Restricted Word"));
      Warning(ZZ);
    }
  if(ZZ)free(ZZ);
}


void PointerFix (void)
{
  strcpy(Stk[Ndx-1], join(2,Stk[Ndx-1],Stk[Ndx]));
  Stk[Ndx][0]=0;
  Ndx--;
  while(tally(Stk[Ndx],"*")==strlen(Stk[Ndx]))
    {
      strcpy(Stk[Ndx-1], join(2,Stk[Ndx-1],Stk[Ndx]));
      Stk[Ndx][0]=0;
      Ndx--;
    }
}


void DimDynaString (char *SVar, int DG, int s)
{
  int     A;
  char DS[2048];
  strcpy(DS, join(5,"if(",SVar,")free(",SVar,");"));
  if(InFunc&&(IsLocal||IsDim||IsRaw||IsAuto||IsRegister)&&DG==0)
    {
      LocalDynaCnt++;
      strcpy(DynaStr[LocalDynaCnt],DS);
      if(IsAuto)
        {
          fprintf(Outfile,"%s%s%s%s\n",Scoot,"char *",SVar,";");
        }
      else if(IsRegister)
        {
          fprintf(Outfile,"%s%s%s%s\n",Scoot,"register char *",SVar,";");
        }
      else
        {
          fprintf(Outfile,"%s%s%s%s\n",Scoot,"char *",SVar,";");
        }
      AddLocal(SVar,vt_CHAR,0,"",1,0,0);
    }
  else
    {
      if(Use_GenFree)
        {
          GlobalDynaCnt++;
          strcpy(GlobalDynaStr[GlobalDynaCnt],DS);
        }
      if(DG==2)
        {
          AddGlobal(SVar,vt_CHAR,0,"",1,0,1,0);
        }
      else
        {
          if(s)
            {
              AddGlobal(SVar,vt_CHAR,0,"",1,0,2,0);
            }
          else
            {
              AddGlobal(SVar,vt_CHAR,0,"",1,0,0,0);
            }
        }
    }
  if(DG!=2)
    {
      fprintf(Outfile,"%s%s%s",Scoot,SVar,"=(char*)calloc(256+");
      for(A=4; A<=Ndx; A+=1)
        {
          fprintf(Outfile,"%s",Clean(Stk[A]));
        }
      fprintf(Outfile,"%s\n",",1);");
    }
}


int SubFuncTest (void)
{
  if(iMatchWrd(Stk[2],"function")||iMatchWrd(Stk[2],"sub"))
    {
      return 1;
    }
  return 0;
}


int DimSubFunc (int IsDynamic)
{
  int     i;
  char lszTmp[2048];
  int     StartPoint=3;
  int     Funptr=0;
  *lszTmp=0;
  if(iMatchWrd(Stk[Ndx],"stdcall"))
    {
      strcpy(CallType,"__attribute__((stdcall)) ");
      Ndx--;
      IsStdFunc=TRUE;
    }
  else
    {
      strcpy(CallType,"__attribute__((cdecl)) ");
      IsStdFunc=FALSE;
    }
  static   struct _functionParse  FP;
  memset(&FP,0,sizeof(FP));
  SepFuncArgs(3, &FP,TRUE);
  StartPoint=_MAX_(FP.CommaPos[0],3);
  if(!InTypeDef)
    {
      SFPOINTER=TRUE;
      if(FP.NumArgs==0)
        {
          i=_MIN_(FP.CommaPos[1]+1,Ndx);
        }
      else
        {
          i=_MIN_(FP.CommaPos[FP.NumArgs]+1,Ndx);
        }
      if(str_cmp(Stk[i],"=")==0)
        {
          *Stk[i++]=0;
          while(!iMatchWrd(Stk[i],"as")&&i<=Ndx)
            {
              strcat(lszTmp,Stk[i]);
              *Stk[i++]=0;
            }
          RemoveAll(lszTmp,"{}",1);
          if(lszTmp[0]!=0)
            {
              RemEmptyTokens();
            }
        }
      if(!InNameSpace)
        {
          fprintf(FP4,"%s%s\n",MakeDecProto( &FP),";");
        }
      SFPOINTER=FALSE;
      Ndx=StartPoint;
      *Stk[2]=0;
      if(lszTmp[0]!=0)
        {
          strcpy(Stk[Ndx++],"=");
          strcpy(Stk[Ndx++],"{");
          strcpy(Stk[Ndx++],Clean(lszTmp));
          strcpy(Stk[Ndx++],"}");
        }
      strcpy(Stk[Ndx++],"as");
      strcpy(Stk[Ndx], join(3,Clean(Stk[3]),"_TYPE",stringx(Funptr,42)));
      RemEmptyTokens();
      return FALSE;
    }
  else
    {
      if(iMatchWrd(Stk[2],"constructor")||iMatchWrd(Stk[2],"destructor"))
        {
          fprintf(Outfile,"%s%s%s%s\n",LF,Scoot,MakeDecProto( &FP),";");
        }
      else if(Use_Virtual)
        {
          fprintf(Outfile,"%s%s%s%s%s\n",Scoot,"virtual ",MakeDecProto( &FP),vproc,";");
          Use_Virtual=FALSE;
        }
      else
        {
          fprintf(Outfile,"%s%s%s\n",Scoot,MakeDecProto( &FP),";");
        }
    }
  return TRUE;
}


void Emit (void)
{
  int     HasStorage=0;
  int     A;
  int     B;
  int     i;
  int     j;
  int     Tmp;
  int     FuncRetnFlag;
  int     IsPointer=0;
  int     VType;
  int     id=0;
  int     k=0;
  int     vt=0;
  char Arg[2048];
  char CVar[2048];
  char Keyword[2048];
  char lszTmp[2048];
  char Var1[2048];
  char *ZZ;
  ZZ=(char*)calloc(256+65535,1);
  int     IsSubOrFuncPtr;
  int     dms;
  static int     NoBreak;
  static int     NoBreak2;
  FuncRetnFlag=0;
  *lszTmp=0;
  *ZZ=0;
  strcpy(Keyword,lcase(Stk[1]));
  if(NoBreak2&&!iMatchLft(Keyword,"case")&&!iMatchWrd(Keyword,"endselect"))
    {
      NoBreak2=0;
    }

EMITAGAIN:;
  if(Ndx==0)
    {
      if(ZZ)free(ZZ);
      return;
    }
  Statements++;
  if(iMatchRgt(Stk[1],":"))
    {
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s%s\n",ucase(Stk[1]),";");
      if(ZZ)free(ZZ);
      return;
    }
  for(i=1; i<=Ndx; i+=1)
    {
      strcpy(Stk[i],replace(Stk[i],chr(-15),":"));
    }
  if((CurrentFuncType==vt_STRVAR)&&InFunc&&OkayToSend)
    {
      fprintf(Outfile,"%s%s\n",Scoot,"char *BCX_RetStr={0};");
      OkayToSend=0;
    }
  strcpy(Lookup,lcase(Stk[1]));
  for(;;)
  {
    if(str_cmp(Lookup,"fprint")==0 ||  str_cmp(Lookup,"sprint")==0)
      {
        int     IsLprint=FALSE;
        int     IsSprint=FALSE;
        if(iMatchWrd(Stk[1],"sprint"))
          {
            IsSprint=TRUE;
          }
        if(IsNumber(Stk[2]))
          {
            strcpy(Stk[2], join(2,"FP",Stk[2]));
          }
        if(IsSprint)
          {
            strcpy(Handl,Clean(Stk[2]));
          }
        else
          {
            if(str_cmp(lcase(Stk[2]),"stderr")==0)
              {
                strcpy(Handl,lcase(Stk[2]));
              }
            else
              {
                if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
                  {
                    if(CheckGlobal(Stk[2], &i)==vt_UNKNOWN)
                      {
                        AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
                      }
                  }
                *Handl=0;
                for(i=2; i<=Ndx; i+=1)
                  {
                    if(*Stk[i]==44||*Stk[i]==59)
                      {
                        *Stk[i]=0;
                        break;
                      }
                    strcat(Handl,Stk[i]);
                    *Stk[i]=0;
                  }
                strcat(Handl,"@");
              }
          }
        *Stk[2]=0;
        *Stk[3]=0;
        if(IsSprint)
          {
            strcpy(ZZ, join(2,"s",PrintWriteFormat(0)));
            strcpy(ZZ,RemoveStr(ZZ,"\\n"));
          }
        else
          {
            strcpy(ZZ, join(2,"f",PrintWriteFormat(0)));
          }
        strcpy(ZZ, join(4,left(ZZ,8),RemoveStr(Handl,"@"),",",mid(ZZ,9)));
        fprintf(Outfile,"%s%s\n",Scoot,ZZ);
        break;
      }
    if(str_cmp(Lookup,"end")==0)
      {
        if(Ndx==1)
          {
            fprintf(Outfile,"%s%s\n",Scoot,"fflush(stdout);");
            fprintf(Outfile,"%s%s\n",Scoot,"exit(0);");
            break;
          }
        if(str_cmp(Stk[2],"=")==0)
          {
            fprintf(Outfile,"%s%s\n",Scoot,"fflush(stdout);");
            fprintf(Outfile,"%s%s",Scoot,"exit(");
            for(Tmp=3; Tmp<=Ndx; Tmp+=1)
              {
                fprintf(Outfile,"%s",Clean(Stk[Tmp]));
              }
            fprintf(Outfile,"%s\n",");");
            break;
          }
        if(iMatchWrd(Stk[2],"if"))
          {
            BumpDown();
            fprintf(Outfile,"%s%s\n",Scoot,"}");
            BumpDown();
            break;
          }
        break;
      }
    if(str_cmp(Lookup,"endif")==0)
      {
        BumpDown();
        fprintf(Outfile,"%s%s\n",Scoot,"}");
        BumpDown();
        break;
      }
    if(str_cmp(Lookup,"if")==0)
      {
        EmitIfCond("if");
        break;
      }
    if(str_cmp(Lookup,"elseif")==0)
      {
        BumpDown();
        fprintf(Outfile,"%s%s\n",Scoot,"}");
        BumpDown();
        EmitIfCond("else if");
        break;
      }
    if(str_cmp(Lookup,"for")==0)
      {
        int     FFlg=0;
        int     For1=0;
        int     For2=0;
        int     For3=0;
        int     For4=0;
        char Reg[2048];
        char xxx[2048];
        char yyy[2048];
        char zzz[2048];
        char qqq[2048];
        *Reg=0;
        *xxx=0;
        *yyy=0;
        *zzz=0;
        *qqq=0;
        for(i=Ndx; i>=1; i+=-1)
          {
            if(iMatchWrd(Stk[i],"step"))
              {
                FFlg=TRUE;
                break;
              }
          }
        if(!FFlg)
          {
            Ndx++;
            strcpy(Stk[Ndx],"step");
            Ndx++;
            strcpy(Stk[Ndx],"1");
          }
        Test=FALSE;
        for(i=1; i<=Ndx; i+=1)
          {
            if(str_cmp(Stk[i],"=")==0)
              {
                Test=TRUE;
              }
          }
        if(Test==FALSE)
          {
            Abort("Missing =");
          }
        Test=FALSE;
        for(i=1; i<=Ndx; i+=1)
          {
            if(iMatchWrd(Stk[i],"to"))
              {
                Test=TRUE;
              }
          }
        if(Test==FALSE)
          {
            Abort("Missing TO");
          }
        strcpy(Reg,lcase(Stk[2]));
        for(;;)
        {
          if(str_cmp(Reg,"int")==0 ||  str_cmp(Reg,"fint")==0)
            {
              strcpy(Reg,SPC);
              LoopLocalVar[LoopLocalCnt++]=1;
              fprintf(Outfile,"%s%s",Scoot,"  {int ");
              break;
            }
          if(str_cmp(Reg,"single")==0 ||  str_cmp(Reg,"float")==0)
            {
              strcpy(Reg,SPC);
              LoopLocalVar[LoopLocalCnt++]=1;
              fprintf(Outfile,"%s%s",Scoot,"  {float ");
              break;
            }
          if(str_cmp(Reg,"double")==0)
            {
              strcpy(Reg,SPC);
              LoopLocalVar[LoopLocalCnt++]=1;
              fprintf(Outfile,"%s%s",Scoot,"  {double ");
              break;
            }
          if(str_cmp(Reg,"ldouble")==0)
            {
              strcpy(Reg,SPC);
              LoopLocalVar[LoopLocalCnt++]=1;
              fprintf(Outfile,"%s%s",Scoot,"  {LDOUBLE ");
              break;
            }
            // case else
            {
              *Reg=0;
              LoopLocalVar[LoopLocalCnt++]=0;
            }
          break;
        }
        if(strlen(Reg))
          {
            for(j=3; j<=Ndx; j+=1)
              {
                strcpy(Stk[j-1],Stk[j]);
              }
            Ndx--;
          }
        for(i=2; i<=Ndx; i+=1)
          {
            if(str_cmp(Stk[i],"=")==0)
              {
                For1=i-1;
                break;
              }
          }
        for(i=For1+2; i<=Ndx; i+=1)
          {
            if(iMatchWrd(Stk[i],"to"))
              {
                For2=i-1;
                break;
              }
          }
        for(i=For2+2; i<=Ndx; i+=1)
          {
            if(iMatchWrd(Stk[i],"step"))
              {
                For3=i-1;
                break;
              }
          }
        For4=For3+2;
        for(i=2; i<=For1; i+=1)
          {
            strcat(xxx,Stk[i]);
          }
        for(i=For1+2; i<=For2; i+=1)
          {
            strcat(yyy,Stk[i]);
          }
        for(i=For2+2; i<=For3; i+=1)
          {
            strcat(zzz,Stk[i]);
          }
        for(i=For4; i<=Ndx; i+=1)
          {
            strcat(qqq,Stk[i]);
          }
        strcpy(xxx,Clean(xxx));
        strcpy(yyy,Clean(yyy));
        strcpy(zzz,Clean(zzz));
        strcpy(qqq,Clean(qqq));
        if(str_cmp(Reg,SPC)==0)
          {
            fprintf(Outfile,"%s%s\n",xxx,";");
          }
        *Reg=0;
        if(IsNumberEx(qqq))
          {
            if(str_cmp(left(qqq,1),"-")==0)
              {
                fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",Scoot,"for(",Reg,xxx,"=",yyy,"; ",xxx,">=",zzz,"; ",xxx,"+=",qqq,")");
              }
            else
              {
                fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",Scoot,"for(",Reg,xxx,"=",yyy,"; ",xxx,"<=",zzz,"; ",xxx,"+=",qqq,")");
              }
          }
        else
          {
            fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",Scoot,"for(",Reg,xxx,"=",yyy,"; ",qqq,">=0 ? ",xxx,"<=",zzz," : ",xxx,">=",zzz,"; ",xxx,"+=",qqq,")");
          }
        BumpUp();
        fprintf(Outfile,"%s%s\n",Scoot,"{");
        BumpUp();
        break;
      }
    if(str_cmp(Lookup,"next")==0)
      {
        BumpDown();
        fprintf(Outfile,"%s%s\n",Scoot,"}");
        if(LoopLocalVar[--LoopLocalCnt])
          {
            fprintf(Outfile,"%s%s\n",Scoot,"}");
          }
        if(LoopLocalCnt<0)
          {
            Abort("Next without For");
          }
        BumpDown();
        break;
      }
    if(str_cmp(Lookup,"do")==0)
      {
        fprintf(Outfile,"%s%s\n",Scoot,"for(;;)");
        BumpUp();
        fprintf(Outfile,"%s%s\n",Scoot,"{");
        BumpUp();
        break;
      }
    if(str_cmp(Lookup,"loop")==0)
      {
        BumpDown();
        fprintf(Outfile,"%s%s\n",Scoot,"}");
        BumpDown();
        break;
      }
    if(str_cmp(Lookup,"caseelse")==0)
      {
        CaseElseFlag[Pusher]=TRUE;
        if(CaseFlag)
          {
            if(NoBreak2==0)
              {
                fprintf(Outfile,"%s%s\n",Scoot,"break;");
              }
            BumpDown();
            fprintf(Outfile,"%s%s\n",Scoot,"}");
            fprintf(Outfile,"%s%s\n",Scoot,"// case else");
            fprintf(Outfile,"%s%s\n",Scoot,"{");
            BumpUp();
          }
        break;
      }
    if(str_cmp(Lookup,"endselect")==0)
      {
        if(CaseFlag)
          {
            BumpDown();
            fprintf(Outfile,"%s%s\n",Scoot,"}");
          }
        BumpDown();
        if(CaseElseFlag[Pusher]==0||NoBreak2==0)
          {
            fprintf(Outfile,"%s%s\n",Scoot,"break;");
          }
        BumpDown();
        fprintf(Outfile,"%s%s\n",Scoot,"}");
        NoBreak2=CaseElseFlag[Pusher]=0;
        Pop(CaseVar);
        break;
      }
    if(str_cmp(Lookup,"else")==0)
      {
        BumpDown();
        fprintf(Outfile,"%s%s\n",Scoot,"}");
        BumpDown();
        fprintf(Outfile,"%s%s\n",Scoot,"else");
        BumpUp();
        fprintf(Outfile,"%s%s\n",Scoot,"{");
        BumpUp();
        break;
      }
    if(str_cmp(Lookup,"case")==0)
      {
        for(i=2; i<=Ndx; i+=1)
          {
            if(str_cmp(Stk[i],"%")==0)
              {
                strcpy(Stk[i]," % ");
              }
            if(str_cmp(Stk[i],"!=")==0)
              {
                strcpy(Stk[i],"<>");
              }
            if(str_cmp(Stk[i],"!")==0 &&  str_cmp(Stk[i+1],"=")==0)
              {
                strcpy(Stk[i],"<>");
                *Stk[i+1]=0;
              }
            if(isalpha(Stk[i][0]))
              {
                strcat(Stk[i]," ");
              }
          }
        *szTmp=0;
        Test=FALSE;
        if(DataType(CaseVar)==vt_STRVAR)
          {
            Test=TRUE;
          }
        i=0;
        for(A=2; A<=Ndx; A+=1)
          {
            if(inchr("([",Stk[A]))
              {
                i++;
              }
            if(inchr(")]",Stk[A]))
              {
                i--;
              }
            if(i)
              {
                strcat(szTmp,Stk[A]);
                continue;
              }
            if(str_cmp(Stk[A],",")==0)
              {
                if(!inchr("<>=",Stk[A+1]))
                  {
                    strcpy(szTmp, join(4,szTmp," or ",CaseVar,"="));
                  }
                else
                  {
                    strcpy(szTmp, join(3,szTmp," or ",CaseVar));
                  }
                *Stk[A]=0;
                continue;
              }
            if(str_cmp(Stk[A],"&&")==0)
              {
                strcpy(szTmp, join(3,szTmp," and ",CaseVar));
                *Stk[A]=0;
              }
            else if(str_cmp(Stk[A],"||")==0)
              {
                strcpy(szTmp, join(3,szTmp," or ",CaseVar));
                *Stk[A]=0;
              }
            else
              {
                strcat(szTmp,Stk[A]);
              }
          }
        if(CaseFlag==0)
          {
            NoBreak=0;
          }
        if(CaseFlag)
          {
            if(NoBreak==0)
              {
                if(NoBreak2==0)
                  {
                    fprintf(Outfile,"%s%s\n",Scoot,"break;");
                  }
              }
            BumpDown();
            fprintf(Outfile,"%s%s\n",Scoot,"}");
            BumpDown();
          }
        CaseFlag=TRUE;
        if(iMatchLft(CaseVar," BAND "))
          {
            NoBreak=1;
            strcpy(Src, join(4,"IF ",szTmp,CaseVar," Then "));
          }
        else
          {
            if(inchr("<>=",szTmp)&&!IsQuoted(szTmp))
              {
                strcpy(Src, join(4,"IF ",CaseVar,szTmp," Then "));
              }
            else
              {
                strcpy(Src, join(5,"IF ",CaseVar," = ",szTmp," Then "));
              }
          }
        Parse(Src);
        Emit();
        break;
      }
    if(str_cmp(Lookup,"delay")==0)
      {
        *lszTmp=0;
        for(i=2; i<=Ndx; i+=1)
          {
            strcat(lszTmp,Clean(Stk[i]));
          }
        fprintf(Outfile,"%s%s%s%s\n",Scoot,"sleep(",lszTmp,");");
        break;
      }
    if(str_cmp(Lookup,"qsortidx")==0)
      {
        *lszTmp=0;
        strcpy(Var,Clean(Stk[2]));
        for(i=4; i<=Ndx-4; i+=1)
          {
            strcat(lszTmp,Stk[i]);
          }
        strcpy(lszTmp,Clean(lszTmp));
        fprintf(Outfile,"%s%s%s%s\n",Scoot,"Key = ",Stk[Ndx],";");
        if(str_cmp(Var,"0")!=0)
          {
            fprintf(Outfile,"%s%s\n",Scoot,"int iDx;");
            fprintf(Outfile,"%s%s%s%s",Scoot,"for(iDx=0; iDx<",lszTmp,"; iDx+=1) ");
            fprintf(Outfile,"%s%s\n",Var,"[iDx]=iDx;");
          }
        if(!inchr(Stk[Ndx-2],"."))
          {
            Use_Idxqsort=TRUE;
            fprintf(Outfile,"%s%s%s%s\n",Scoot,"pppStr = ",Clean(Stk[Ndx-2]),";");
            fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"qsort(",Var,",",lszTmp,",sizeof(int),IdxCompare);");
          }
        else
          {
            char Stptr[2048];
            char StMem[2048];
            char StName[2048];
            strcpy(StMem,remain(Clean(Stk[Ndx-2]),"."));
            strcpy(Stptr,extract(Stk[Ndx-2],"."));
            if(CheckLocal(Stptr, &i)!=vt_UNKNOWN)
              {
                strcpy(StName,TypeDefs[LocalVars[i].VarDef].VarName);
              }
            else if(CheckGlobal(Stptr, &i)!=vt_UNKNOWN)
              {
                strcpy(StName,TypeDefs[GlobalVars[i].VarDef].VarName);
              }
            if(str_cmp(Var,"0")!=0)
              {
                Use_IdxqsortSt=TRUE;
                fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"cmp1 =(char*)(",Stptr,") + offsetof(",StName,",",StMem,");");
                fprintf(Outfile,"%s%s%s%s\n",Scoot,"StructSize = sizeof(",StName,");");
                fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"qsort(",Var,",",lszTmp,",sizeof(int),IdxCompareSt);");
              }
            else
              {
                Use_PtrqsortSt=TRUE;
                fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"OffSet = offsetof(",StName,",",StMem,");");
                fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"qsort(",Stptr,",",lszTmp,",sizeof(",StName,"),PtrCompareSt);");
              }
          }
        break;
      }
    if(str_cmp(Lookup,"qsort")==0)
      {
        int     QST=0;
        int     order=0;
        if(iMatchWrd(Stk[2],"dynamic"))
          {
            QST=TRUE;
            for(j=3; j<=Ndx; j+=1)
              {
                strcpy(Stk[j-1],Stk[j]);
              }
            Ndx--;
          }
        if(str_cmp(lcase(Stk[Ndx]),"ascending")==0)
          {
            order=2;
            Ndx--;
            Ndx--;
          }
        if(str_cmp(lcase(Stk[Ndx]),"descending")==0)
          {
            order=1;
            Ndx--;
            Ndx--;
          }
        if(order==0)
          {
            order=2;
          }
        *lszTmp=0;
        for(i=4; i<=Ndx; i+=1)
          {
            strcat(lszTmp,Stk[i]);
          }
        strcpy(Var,Clean(Stk[2]));
        vt=DataType(Stk[2]);
        if(vt!=vt_STRVAR&&vt!=vt_INTEGER&&vt!=vt_SINGLE&&vt!=vt_DOUBLE)
          {
            vt=CheckType(Stk[2]);
          }
        fprintf(Outfile,"%s%s%s%s%s",Scoot,"qsort(",Var,",",Clean(lszTmp));
        for(;;)
        {
          if(vt==vt_STRVAR)
            {
              if(!QST)
                {
                  if(order==1)
                    {
                      fprintf(Outfile,"%s%s%s\n",",sizeof(",Var,"[0]),StrCompareD);");
                      Use_Strqsortd=TRUE;
                    }
                  else
                    {
                      fprintf(Outfile,"%s%s%s\n",",sizeof(",Var,"[0]),StrCompareA);");
                      Use_Strqsorta=TRUE;
                    }
                }
              else
                {
                  if(order==1)
                    {
                      fprintf(Outfile,"%s%s%s\n",",sizeof(",Var,"[0]),DynStrCompareD);");
                      Use_DynStrqsortd=TRUE;
                    }
                  else
                    {
                      fprintf(Outfile,"%s%s%s\n",",sizeof(",Var,"[0]),DynStrCompareA);");
                      Use_DynStrqsorta=TRUE;
                    }
                }
              break;
            }
          if(vt==vt_INTEGER)
            {
              if(order==1)
                {
                  fprintf(Outfile,"%s\n",",sizeof(int),NumCompareDint);");
                  Use_Numqsortdint=TRUE;
                }
              else
                {
                  fprintf(Outfile,"%s\n",",sizeof(int),NumCompareAint);");
                  Use_Numqsortaint=TRUE;
                }
              break;
            }
          if(vt==vt_SINGLE)
            {
              if(order==1)
                {
                  fprintf(Outfile,"%s\n",",sizeof(float),NumCompareDfloat);");
                  Use_Numqsortdfloat=TRUE;
                }
              else
                {
                  fprintf(Outfile,"%s\n",",sizeof(float),NumCompareAfloat);");
                  Use_Numqsortafloat=TRUE;
                }
              break;
            }
          if(vt==vt_DOUBLE)
            {
              if(order==1)
                {
                  fprintf(Outfile,"%s\n",",sizeof(double),NumCompareDdouble);");
                  Use_Numqsortddouble=TRUE;
                }
              else
                {
                  fprintf(Outfile,"%s\n",",sizeof(double),NumCompareAdouble);");
                  Use_Numqsortadouble=TRUE;
                }
              break;
            }
            // case else
            {
              if(order==1)
                {
                  fprintf(Outfile,"%s\n",",sizeof(int),NumCompareDint);");
                  Use_Numqsortdint=TRUE;
                }
              else
                {
                  fprintf(Outfile,"%s\n",",sizeof(int),NumCompareAint);");
                  Use_Numqsortaint=TRUE;
                }
            }
          break;
        }
        break;
      }
    if(str_cmp(Lookup,"endprogram")==0)
      {
        fprintf(Outfile,"%s\n","  return 0;         //  End of main program");
        fprintf(Outfile,"%s\n","}\n\n");
        EndOfProgram=1;
        break;
      }
    if(str_cmp(Lookup,"~ifndef")==0)
      {
        strcpy(InIfDef,"#ifndef ");
        for(i=2; i<=Ndx; i+=1)
          {
            strcpy(InIfDef, join(3,InIfDef,Stk[i]," "));
          }
        strcpy(InIfDef,trim(InIfDef));
        if(InFunc||InMain)
          {
            fprintf(Outfile,"%s\n",InIfDef);
          }
        else
          {
            fprintf(FP6,"%s\n",InIfDef);
          }
        break;
      }
    if(str_cmp(Lookup,"~if")==0)
      {
        strcpy(InIfDef,"#if defined ");
        for(i=2; i<=Ndx; i+=1)
          {
            strcpy(InIfDef, join(3,InIfDef,Stk[i]," "));
          }
        strcpy(InIfDef,trim(InIfDef));
        strcpy(ConstLastDef,InIfDef);
        if(InFunc)
          {
            if(Outfile==FP3)
              {
                fprintf(Outfile,"%s\n","// FP3");
              }
            if(Outfile==FP2)
              {
                fprintf(Outfile,"%s\n","// FP2");
              }
            fprintf(Outfile,"%s%s\n",InIfDef,"// OUTFILE");
            strcpy(InIfDef,"FP3");
          }
        else if(InMain)
          {
            fprintf(Outfile,"%s%s\n",InIfDef,"// --FP2--");
          }
        break;
      }
    if(str_cmp(Lookup,"~else")==0)
      {
        strcpy(InIfDef,"#else");
        strcpy(ConstLastDef,InIfDef);
        if(InFunc||InMain)
          {
            fprintf(Outfile,"%s\n",InIfDef);
          }
        else
          {
            fprintf(FP6,"%s\n",InIfDef);
          }
        break;
      }
    if(str_cmp(Lookup,"~elseif")==0)
      {
        strcpy(InIfDef,"#elif defined ");
        for(i=2; i<=Ndx; i+=1)
          {
            strcpy(InIfDef, join(3,InIfDef,Stk[i]," "));
          }
        strcpy(InIfDef,trim(InIfDef));
        strcpy(ConstLastDef,InIfDef);
        if(InFunc||InMain)
          {
            fprintf(Outfile,"%s\n",InIfDef);
          }
        else
          {
            fprintf(FP6,"%s\n",InIfDef);
          }
        break;
      }
    if(str_cmp(Lookup,"~endif")==0)
      {
        if(str_cmp(InIfDef,"FP3")==0)
          {
            fprintf(FP3,"%s\n","#endif  // FP3");
          }
        else
          {
            fprintf(Outfile,"%s\n","#endif  // Main");
          }
        if(str_cmp(ConstLastDef,"FP6")==0)
          {
            fprintf(FP6,"%s\n","#endif  // FP6");
          }
        strcpy(InIfDef,"#endif  // other");
        if(InConditional==0)
          {
            *InIfDef=0;
            *ConstLastDef=0;
          }
        break;
      }
    if(str_cmp(Lookup,"incr")==0)
      {
        j=FALSE;
        fprintf(Outfile,"%s",Scoot);
        for(i=2; i<=Ndx; i+=1)
          {
            if(str_cmp(Stk[i],",")==0)
              {
                fprintf(Outfile,"%s","+=(");
                j=TRUE;
              }
            else
              {
                fprintf(Outfile,"%s",Clean(Stk[i]));
              }
          }
        fprintf(Outfile,"%s\n",sziif(j,");","++;"));
        break;
      }
    if(str_cmp(Lookup,"decr")==0)
      {
        j=FALSE;
        fprintf(Outfile,"%s",Scoot);
        for(i=2; i<=Ndx; i+=1)
          {
            if(str_cmp(Stk[i],",")==0)
              {
                fprintf(Outfile,"%s","-=(");
                j=TRUE;
              }
            else
              {
                fprintf(Outfile,"%s",Clean(Stk[i]));
              }
          }
        fprintf(Outfile,"%s\n",sziif(j,");","--;"));
        break;
      }
    if(str_cmp(Lookup,"seek")==0)
      {
        if(DataType(Stk[2])==vt_NUMBER)
          {
            strcpy(Stk[2], join(2,"FP",Stk[2]));
          }
        if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
          {
            AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
          }
        fprintf(Outfile,"%s%s",Scoot,"fseek(");
        for(Tmp=2; Tmp<=Ndx; Tmp+=1)
          {
            fprintf(Outfile,"%s",Clean(Stk[Tmp]));
          }
        fprintf(Outfile,"%s\n",",0);");
        break;
      }
    if(str_cmp(Lookup,"select")==0)
      {
        *CaseVar=0;
        CaseFlag=0;
        for(A=3; A<=Ndx; A+=1)
          {
            strcat(CaseVar,Stk[A]);
          }
        Push(CaseVar);
        fprintf(Outfile,"%s%s\n",Scoot,"for(;;)");
        fprintf(Outfile,"%s%s\n",Scoot,"{");
        BumpUp();
        break;
      }
    if(str_cmp(Lookup,"~get")==0)
      {
        Use_Get=TRUE;
        if(DataType(Stk[2])==vt_NUMBER)
          {
            strcpy(Stk[2], join(2,"FP",Stk[2]));
          }
        if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
          {
            if(CheckGlobal(Stk[2], &i)==vt_UNKNOWN)
              {
                AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
              }
          }
        fprintf(Outfile,"%s%s",Scoot,"GET(");
        for(Tmp=2; Tmp<=Ndx; Tmp+=1)
          {
            fprintf(Outfile,"%s",Clean(Stk[Tmp]));
          }
        fprintf(Outfile,"%s\n",");");
        break;
      }
    if(str_cmp(Lookup,"~put")==0)
      {
        Use_Put=TRUE;
        if(DataType(Stk[2])==vt_NUMBER)
          {
            strcpy(Stk[2], join(2,"FP",Stk[2]));
          }
        if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
          {
            if(CheckGlobal(Stk[2], &i)==vt_UNKNOWN)
              {
                AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
              }
          }
        fprintf(Outfile,"%s%s",Scoot,"PUT(");
        for(Tmp=2; Tmp<=Ndx; Tmp+=1)
          {
            fprintf(Outfile,"%s",Clean(Stk[Tmp]));
          }
        fprintf(Outfile,"%s\n",");");
        break;
      }
    if(str_cmp(Lookup,"gosub")==0)
      {
        Use_Gosub=TRUE;
        fprintf(Outfile,"%s%s",Scoot,"if (setjmp(GosubStack[GosubNdx++])==0)");
        fprintf(Outfile,"%s%s%s\n"," goto ",ucase(Stk[2]),";");
        break;
      }
    if(str_cmp(Lookup,"return")==0)
      {
        Use_Gosub=TRUE;
        fprintf(Outfile,"%s%s\n",Scoot,"longjmp (GosubStack [--GosubNdx],1 );");
        fprintf(Outfile,"%s\n","");
        break;
      }
    if(str_cmp(Lookup,"data")==0)
      {
        if(str_cmp(Stk[Ndx],",")!=0)
          {
            strcpy(Stk[Ndx+1],",");
            Ndx++;
          }
        for(A=2; A<=Ndx; A+=1)
          {
            if(inchr(Stk[A],DQ)==0&&str_cmp(Stk[A],",")!=0)
              {
                strcpy(Stk[A],enc(Stk[A]));
              }
            fprintf(FP5,"%s",Stk[A]);
          }
        fprintf(FP5,"%s\n","");
        break;
      }
    if(str_cmp(Lookup,"namespace")==0)
      {
        UseCpp=TRUE;
        strcpy(szTmp,mid(Src,inchr(Src," ")+1));
        fprintf(Outfile,"%s%s\n","namespace ",ltrim(szTmp));
        fprintf(Outfile,"%s\n","{");
        InNameSpace++;
        BumpUp();
        break;
      }
    if(str_cmp(Lookup,"endnamespace")==0)
      {
        InNameSpace--;
        BumpDown();
        fprintf(Outfile,"%s%s\n",Scoot,"}");
        break;
      }
    if(str_cmp(Lookup,"class")==0)
      {
        if(InTypeDef==0)
          {
            SaveOutfileNum=Outfile;
          }
        Outfile=FP4;
        InTypeDef++;
        strcpy(TypeName[InTypeDef],Stk[2]);
        if(str_cmp(Stk[3],"inherits")==0)
          {
            strcpy(Stk[3], join(2,": public ",Stk[4]));
          }
        AddTypeDefs(TypeName[InTypeDef],vt_STRUCT);
        BaseTypeDefsCnt[InTypeDef]=TypeDefsCnt;
        if(InTypeDef==1)
          {
            fprintf(Outfile,"%s\n","");
            fprintf(Outfile,"%s%s%s%s\n","class ",TypeName[InTypeDef],Stk[3]," {");
            BumpUp();
          }
        break;
      }
    if(str_cmp(Lookup,"endclass")==0)
      {
        BumpDown();
        fprintf(Outfile,"%s%s\n","};",LF);
        InTypeDef--;
        break;
      }
    if(str_cmp(Lookup,"type")==0)
      {
        if(InTypeDef==0)
          {
            SaveOutfileNum=Outfile;
          }
        Outfile=FP4;
        if(Ndx>2)
          {
            if(InTypeDef)
              {
                Abort("Single line TYPE within type/union not supported");
              }
            for(i=Ndx; i>=1; i+=-1)
              {
                if(iMatchWrd(Stk[i],"as"))
                  {
                    break;
                  }
              }
            if(!iMatchWrd(Stk[i],"as"))
              {
                Abort("Missing AS TYPE");
              }
            fprintf(Outfile,"%s","typedef ");
            j=i-1;
            i++;
            while(i<=Ndx)
              {
                fprintf(Outfile,"%s%s",Stk[i]," ");
                i++;
              }
            for(i=2; i<=j; i+=1)
              {
                fprintf(Outfile,"%s",Stk[i]);
              }
            fprintf(Outfile,"%s\n",";");
            Outfile=SaveOutfileNum;
          }
        else
          {
            InTypeDef++;
            strcpy(TypeName[InTypeDef],Stk[2]);
            AddTypeDefs(TypeName[InTypeDef],vt_STRUCT);
            BaseTypeDefsCnt[InTypeDef]=TypeDefsCnt;
            if(InTypeDef==1)
              {
                fprintf(Outfile,"%s\n","");
                fprintf(Outfile,"%s%s\n","typedef struct _",TypeName[InTypeDef]);
                fprintf(Outfile,"%s\n","{");
                BumpUp();
              }
            else
              {
                fprintf(Outfile,"%s%s\n",Scoot,"struct");
                fprintf(Outfile,"%s%s\n",Scoot,"{");
                AddTypedefElement(BaseTypeDefsCnt[InTypeDef-1],vt_STRUCT,TypeName[InTypeDef],TypeName[InTypeDef],0);
                BumpUp();
              }
          }
        break;
      }
    if(str_cmp(Lookup,"endtype")==0)
      {
        if(InTypeDef==1)
          {
            BumpDown();
            fprintf(Outfile,"%s%s%s%s%s%s\n","}",TypeName[InTypeDef],", *","LP",ucase(TypeName[InTypeDef]),";");
            fprintf(Outfile,"%s\n","");
            Outfile=SaveOutfileNum;
            fprintf(FP6,"%s%s%s%s%s%s\n",Scoot,"#define ",ucase(TypeName[InTypeDef]),"_CLASS struct _",ucase(TypeName[InTypeDef]),"*");
          }
        else
          {
            BumpDown();
            fprintf(Outfile,"%s%s%s%s\n",Scoot,"} ",TypeName[InTypeDef],";");
            fprintf(Outfile,"%s\n","");
          }
        InTypeDef--;
        break;
      }
    if(str_cmp(Lookup,"union")==0)
      {
        if(InTypeDef==0)
          {
            SaveOutfileNum=Outfile;
          }
        Outfile=FP4;
        InTypeDef++;
        strcpy(TypeName[InTypeDef],Stk[2]);
        AddTypeDefs(TypeName[InTypeDef],vt_UNION);
        BaseTypeDefsCnt[InTypeDef]=TypeDefsCnt;
        if(InTypeDef==1)
          {
            fprintf(Outfile,"%s\n","");
            fprintf(Outfile,"%s\n","typedef union ");
            fprintf(Outfile,"%s\n","{");
            BumpUp();
          }
        else
          {
            fprintf(Outfile,"%s%s\n",Scoot,"union");
            fprintf(Outfile,"%s%s\n",Scoot,"{");
            AddTypedefElement(BaseTypeDefsCnt[InTypeDef-1],vt_UNION,TypeName[InTypeDef],TypeName[InTypeDef],0);
            BumpUp();
          }
        break;
      }
    if(str_cmp(Lookup,"endunion")==0)
      {
        if(InTypeDef==1)
          {
            BumpDown();
            fprintf(Outfile,"%s%s%s%s%s%s\n","} ",TypeName[InTypeDef],", *","LP",ucase(TypeName[InTypeDef]),";");
            fprintf(Outfile,"%s\n","");
            Outfile=SaveOutfileNum;
          }
        else
          {
            BumpDown();
            fprintf(Outfile,"%s%s%s%s\n",Scoot,"} ",TypeName[InTypeDef],";");
            fprintf(Outfile,"%s\n","");
          }
        InTypeDef--;
        break;
      }
    if(str_cmp(Lookup,"with")==0)
      {
        WithCnt++;
        if(WithCnt==8)
          {
            Abort("[With] depth exceeded");
          }
        *WithVar[WithCnt]=0;
        for(i=2; i<=Ndx; i+=1)
          {
            strcat(WithVar[WithCnt],Stk[i]);
          }
        break;
      }
    if(str_cmp(Lookup,"endwith")==0)
      {
        WithCnt--;
        break;
      }
    if(str_cmp(Lookup,"clear")==0)
      {
        Use_Clear=TRUE;
        fprintf(Outfile,"%s%s",Scoot,"Clear ");
        if(str_cmp(Stk[2],"(")!=0)
          {
            fprintf(Outfile,"%s","(");
          }
        for(i=2; i<=Ndx; i+=1)
          {
            fprintf(Outfile,"%s",Clean(Stk[i]));
          }
        if(str_cmp(Stk[2],"(")!=0)
          {
            fprintf(Outfile,"%s",")");
          }
        fprintf(Outfile,"%s\n",";");
        break;
      }
    if(str_cmp(Lookup,"repeat")==0)
      {
        *lszTmp=0;
        for(i=2; i<=Ndx; i+=1)
          {
            strcat(lszTmp,Stk[i]);
          }
        strcpy(lszTmp,Clean(lszTmp));
        BumpUp();
        if(inchr(Stk[2],"-"))
          {
            if(str_cmp(left(lszTmp,1),"-")==0)
              {
                strcpy(lszTmp,mid(lszTmp,2));
              }
            fprintf(Outfile,"%s%s\n",Scoot,"{int BCX_REPEAT;");
            fprintf(Outfile,"%s%s%s%s\n",Scoot,"for(BCX_REPEAT=",lszTmp,";BCX_REPEAT>=1;BCX_REPEAT--)");
            fprintf(Outfile,"%s%s\n",Scoot,"{");
          }
        else
          {
            fprintf(Outfile,"%s%s\n",Scoot,"{int BCX_REPEAT;");
            fprintf(Outfile,"%s%s%s%s\n",Scoot,"for(BCX_REPEAT=1;BCX_REPEAT<=",lszTmp,";BCX_REPEAT++)");
            fprintf(Outfile,"%s%s\n",Scoot,"{");
          }
        BumpUp();
        break;
      }
    if(str_cmp(Lookup,"endrepeat")==0)
      {
        BumpDown();
        fprintf(Outfile,"%s%s\n",Scoot,"}");
        fprintf(Outfile,"%s%s\n",Scoot,"}");
        BumpDown();
        break;
      }
    if(str_cmp(Lookup,"const")==0)
      {
        char Buffer[2048];
        char Sep[2048];
        *Buffer=0;
        *Sep=0;
        *Stk[1]=0;
        for(i=2; i<=Ndx; i+=1)
          {
            if(str_cmp(Stk[i],"=")==0)
              {
                i++;
                break;
              }
            else
              {
                strcat(Stk[1],Stk[i]);
              }
          }
        strcpy(Stk[1], join(3,"#define ",Clean(Stk[1]),SPC));
        for(i=i; i<=Ndx; i+=1)
          {
            if(isalpha(Stk[i][0])||(Stk[i][0]==95&&isalpha(Stk[i+1][0]))||Stk[i+1][0]==95)
              {
                strcpy(Sep," ");
              }
            else
              {
                *Sep=0;
              }
            if(!IsQuoted(Stk[i]))
              {
                strcpy(Stk[i],RemoveStr(Stk[i],"$"));
              }
            strcpy(Buffer, join(3,Buffer,Stk[i],Sep));
          }
        strcpy(Buffer, join(2,Stk[1],Buffer));
        if(InConditional)
          {
            if(InFunc)
              {
                fprintf(Outfile,"%s\n",Buffer);
              }
            else
              {
                if(str_cmp(ConstLastDef,"FP6")!=0)
                  {
                    fprintf(FP6,"%s%s\n",InIfDef,"// FP6");
                    strcpy(ConstLastDef,"FP6");
                  }
                fprintf(FP6,"%s\n",Buffer);
              }
          }
        else
          {
            fprintf(FP6,"%s\n",Buffer);
          }
        break;
      }
    if(str_cmp(Lookup,"kill")==0)
      {
        fprintf(Outfile,"%s%s",Scoot,"remove (");
        for(A=2; A<=Ndx; A+=1)
          {
            fprintf(Outfile,"%s",Clean(trim(Stk[A])));
          }
        fprintf(Outfile,"%s\n",");");
        break;
      }
    if(str_cmp(Lookup,"chdir")==0 ||  str_cmp(Lookup,"_chdir")==0 ||  str_cmp(Lookup,"rmdir")==0 ||  str_cmp(Lookup,"_rmdir")==0 ||  str_cmp(Lookup,"mkdir")==0 ||  str_cmp(Lookup,"_mkdir")==0)
      {
        fprintf(Outfile,"%s%s%s",Scoot,Lookup," (");
        for(A=2; A<=Ndx; A+=1)
          {
            fprintf(Outfile,"%s",Clean(trim(Stk[A])));
          }
        fprintf(Outfile,"%s\n",");");
        break;
      }
    if(str_cmp(Lookup,"free")==0)
      {
         VarInfo*  VI;
        A=2;
        if(iMatchWrd(Stk[2],"dynamic"))
          {
            A=3;
          }
        if(str_cmp(Stk[A],"(")==0)
          {
            A++;
            Ndx--;
          }
        strcpy(CVar,Clean(Stk[A]));
        vt=CheckLocal(CVar, &id);
        if(vt==vt_UNKNOWN)
          {
            vt=CheckGlobal(CVar, &id);
            if(vt==vt_UNKNOWN)
              {
                Abort(join(3,"Can not REDIM ",CVar," not previously dimensioned"));
              }
            VI= &GlobalVars[id];
          }
        else
          {
            VI= &LocalVars[id];
            Warning("Local dynamic variables are automatically freed.",1);
          }
        *CVar=0;
        for(i=A; i<=Ndx; i+=1)
          {
            strcat(CVar,Stk[i]);
          }
        strcpy(CVar,Clean(CVar));
        if(vt==vt_STRUCT||vt==vt_UNION)
          {
            GetElement(2, &vt, &dms,VI->VarDef);
            if(vt!=vt_UNKNOWN&&dms>0)
              {
                Use_DynamicA=TRUE;
                fprintf(Outfile,"%s%s%s",Scoot,"if (",CVar);
                fprintf(Outfile,"%s%s%s%d%s",") { DestroyArr((void **)",CVar,",",(int)dms,", 1); ");
                fprintf(Outfile,"%s%s\n",CVar,"=NULL; }");
                break;
              }
          }
        if(VI->VarPntr>1)
          {
            Use_DynamicA=TRUE;
            fprintf(Outfile,"%s%s%s",Scoot,"if (",CVar);
            fprintf(Outfile,"%s%s%s%s%s",") { DestroyArr((void **)",CVar,",",str(VI->VarPntr),", 1); ");
            fprintf(Outfile,"%s%s\n",CVar,"=NULL; }");
          }
        else
          {
            fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"free(",CVar,"), ",CVar,"=NULL;");
          }
        break;
      }
    if(str_cmp(Lookup,"midstr")==0)
      {
        *Src=0;
        for(A=1; A<=Ndx; A+=1)
          {
            strcat(Src,Clean(Stk[A]));
          }
        fprintf(Outfile,"%s%s%s\n",Scoot,trim(Src),";");
        break;
      }
    if(str_cmp(Lookup,"swap")==0)
      {
         VarInfo*  VI1;
         VarInfo*  VI2;
         int  indx;
        fprintf(Outfile,"%s%s",Scoot,"swap ((BYTE*)&");
        for(i=2; i<=Ndx; i+=1)
          {
            if(str_cmp(Stk[i],",")==0)
              {
                break;
              }
            fprintf(Outfile,"%s",Clean(Stk[i]));
          }
        A=CheckLocal(Stk[2], &indx);
        if(A==vt_UNKNOWN)
          {
            A=CheckGlobal(Stk[2], &indx);
            if(A==vt_UNKNOWN)
              {
                Abort(join(3,"Variable '",Stk[2],"' in swap statement unknown"));
              }
            VI1= &GlobalVars[indx];
          }
        else
          {
            VI1= &LocalVars[indx];
          }
        if(str_cmp(right(Stk[i-1],1),"]")!=0)
          {
            if(VI1->VarType==vt_CHAR&&VI1->VarPntr==1)
              {
                fprintf(Outfile,"%s","[0]");
              }
          }
        fprintf(Outfile,"%s",",(BYTE*)&");
        i++;
        for(j=i; j<=Ndx; j+=1)
          {
            fprintf(Outfile,"%s",Clean(Stk[j]));
          }
        A=CheckLocal(Stk[i], &indx);
        if(A==vt_UNKNOWN)
          {
            A=CheckGlobal(Stk[i], &indx);
            if(A==vt_UNKNOWN)
              {
                Abort(join(3,"Variable '",Stk[i],"' in swap statement unknown"));
              }
            VI2= &GlobalVars[indx];
          }
        else
          {
            VI2= &LocalVars[indx];
          }
        if(str_cmp(right(Stk[j-1],1),"]")!=0)
          {
            if(VI2->VarType==vt_CHAR&&VI2->VarPntr==1)
              {
                fprintf(Outfile,"%s","[0]");
              }
          }
        if(VI1->VarType!=VI2->VarType)
          {
            Warning("Possible size error in swap statement");
          }
        if(VI2->VarType==vt_STRVAR||VI2->VarType==vt_CHAR)
          {
            fprintf(Outfile,"%s",",strlen(");
          }
        else
          {
            fprintf(Outfile,"%s",",sizeof(");
          }
        for(j=i; j<=Ndx; j+=1)
          {
            fprintf(Outfile,"%s",Clean(Stk[j]));
          }
        fprintf(Outfile,"%s\n","));");
        break;
      }
    if(str_cmp(Lookup,"rename")==0)
      {
        fprintf(Outfile,"%s%s",Scoot,"rename (");
        for(A=2; A<=Ndx; A+=1)
          {
            fprintf(Outfile,"%s",Clean(trim(Stk[A])));
          }
        fprintf(Outfile,"%s\n",");");
        break;
      }
    if(str_cmp(Lookup,"copyfile")==0)
      {
        fprintf(Outfile,"%s%s",Scoot,"CopyFile ");
        if(str_cmp(Stk[2],"(")!=0)
          {
            fprintf(Outfile,"%s","(");
          }
        for(A=2; A<=Ndx; A+=1)
          {
            fprintf(Outfile,"%s",Clean(trim(Stk[A])));
          }
        if(str_cmp(Stk[Ndx],")")!=0)
          {
            fprintf(Outfile,"%s\n",");");
          }
        else
          {
            fprintf(Outfile,"%s\n",";");
          }
        break;
      }
    if(str_cmp(Lookup,"shell")==0)
      {
        if(Ndx>2)
          {
            for(A=3; A<=Ndx; A+=1)
              {
                strcpy(Stk[2], join(2,Stk[2],Stk[A]));
              }
          }
        strcpy(ZZ,Stk[2]);
        if(ZZ[0]==0)
          {
            strcpy(ZZ,DDQ);
          }
        fprintf(Outfile,"%s%s%s%s\n",Scoot,"Shell(",Clean(ZZ),");");
        break;
      }
    if(str_cmp(Lookup,"lineinput")==0)
      {
        i=DataType(Stk[2]);
        if(i==vt_STRLIT||i==vt_STRVAR)
          {
            if(i!=vt_STRLIT)
              {
                strcpy(Stk[2],Clean(Stk[2]));
              }
            fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"printf(",enc("%s"),",",Stk[2],");");
            fprintf(Outfile,"%s%s%s%s\n",Scoot,"AR_fgets_retval=fgets(",Clean(Stk[3]),",65535,stdin);");
            fprintf(Outfile,"%s%s%s%s%s\n",Scoot,Clean(Stk[3]),"[strlen(",Clean(Stk[3]),")-1]=0;");
            break;
          }
        strcpy(Stk[2],RemoveStr(Stk[2],"#"));
        if(DataType(Stk[2])==vt_NUMBER)
          {
            strcpy(Stk[2], join(2,"FP",Stk[2]));
          }
        strcpy(Handl,extract(Stk[2],"["));
        if(CheckLocal(Handl, &i)==vt_UNKNOWN)
          {
            if(CheckGlobal(Handl, &i)==vt_UNKNOWN)
              {
                AddGlobal(Handl,vt_FILEPTR,0,"",0,0,0,0);
              }
          }
        strcpy(Var,Clean(Stk[3]));
        *Var1=0;
        strcpy(CVar,Var);
        if(inchr(Var,"[")&&inchr(Var,"]"))
          {
            if(instr_b(Var,"[++"))
              {
                strcpy(CVar,replace(CVar,"++",""));
              }
            if(instr_b(Var,"[--"))
              {
                strcpy(CVar,replace(CVar,"--",""));
              }
            if(instr_b(Var,"++]"))
              {
                strcpy(CVar,replace(CVar,"++",""));
                strcpy(Var1,mid(Var,inchr(Var,"[")+1));
                strcpy(Var1,extract(Var1,"]"));
                strcpy(Var,CVar);
              }
            if(instr_b(Var,"--]"))
              {
                strcpy(CVar,replace(CVar,"--",""));
                strcpy(Var1,mid(Var,inchr(Var,"[")+1));
                strcpy(Var1,extract(Var1,"]"));
                strcpy(Var,CVar);
              }
          }
        fprintf(Outfile,"%s%s%s\n",Scoot,Var,"[0]=0;");
        fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"AR_fgets_retval=fgets(",Var,",65535,",Clean(Stk[2]),");");
        fprintf(Outfile,"%s%s%s%s%s%s",Scoot,"if(",CVar,"[strlen(",CVar,")-1]==10)");
        fprintf(Outfile,"%s%s%s%s\n",CVar,"[strlen(",CVar,")-1]=0;");
        if(Var1[0]!=0)
          {
            fprintf(Outfile,"%s%s\n",Var1,";");
          }
        break;
      }
    if(str_cmp(Lookup,"open")==0)
      {
        for(A=1; A<=Ndx; A+=1)
          {
            strcpy(Keyword,lcase(Stk[A]));
            for(;;)
            {
              if(str_cmp(Keyword,"open")==0)
                {
                  *Stk[A]=0;
                  break;
                }
              if(str_cmp(Keyword,"for")==0)
                {
                  *Stk[A]=0;
                  *Filnam=0;
                  for(j=2; j<=A-1; j+=1)
                    {
                      strcat(Filnam,Stk[j]);
                    }
                  strcpy(Filnam,Clean(Filnam));
                  break;
                }
              if(str_cmp(Keyword,"as")==0)
                {
                  *Stk[A]=0;
                  if(DataType(Stk[A+1])==vt_NUMBER)
                    {
                      strcpy(Stk[A+1], join(2,"FP",Stk[A+1]));
                    }
                  if(CheckLocal(Stk[A+1], &i)==vt_UNKNOWN)
                    {
                      if(CheckGlobal(Stk[A+1], &i)==vt_UNKNOWN)
                        {
                          AddGlobal(Stk[A+1],vt_FILEPTR,0,"",0,0,0,0);
                        }
                    }
                  *Var=0;
                  for(j=A+1; j<=Ndx; j+=1)
                    {
                      if(iMatchWrd(Stk[j],"reclen"))
                        {
                          break;
                        }
                      strcat(Var,Stk[j]);
                      *Stk[j]=0;
                    }
                  strcpy(Handl, join(2,Var,"@"));
                  break;
                }
              if(str_cmp(Keyword,"network")==0)
                {
                  Use_Socket=TRUE;
                  break;
                }
              if(str_cmp(Keyword,"input")==0)
                {
                  strcpy(Op,enc("r"));
                  *Stk[A]=0;
                  break;
                }
              if(str_cmp(Keyword,"output")==0)
                {
                  strcpy(Op,enc("w"));
                  *Stk[A]=0;
                  break;
                }
              if(str_cmp(Keyword,"append")==0)
                {
                  strcpy(Op,enc("a"));
                  *Stk[A]=0;
                  break;
                }
              if(str_cmp(Keyword,"binary")==0)
                {
                  strcpy(Op,enc("rb+"));
                  *Stk[A]=0;
                  break;
                }
              if(str_cmp(Keyword,"binaryappend")==0)
                {
                  strcpy(Op,enc("ab+"));
                  *Stk[A]=0;
                  break;
                }
              if(str_cmp(Keyword,"binarynew")==0)
                {
                  strcpy(Op,enc("wb+"));
                  *Stk[A]=0;
                  break;
                }
              if(str_cmp(Keyword,"binaryinput")==0)
                {
                  strcpy(Op,enc("rb"));
                  *Stk[A]=0;
                  break;
                }
              if(str_cmp(Keyword,"binaryoutput")==0)
                {
                  strcpy(Op,enc("rb+"));
                  *Stk[A]=0;
                  break;
                }
              if(str_cmp(Keyword,"reclen")==0)
                {
                  if(str_cmp(Stk[A+1],"=")==0)
                    {
                      for(j=A+2; j<=Ndx; j+=1)
                        {
                          strcpy(Stk[j-1],Stk[j]);
                        }
                      Ndx--;
                    }
                  strcpy(Var, join(2,extract(Clean(Handl),"["),"len"));
                  if(CheckLocal(Var, &i)==vt_UNKNOWN)
                    {
                      AddGlobal(Var,vt_INTEGER,0,"",0,0,0,0);
                    }
                  else
                    {
                      if(CheckLocal(Var, &i)==vt_UNKNOWN)
                        {
                          AddLocal(Var,vt_INTEGER,0,"",0,0,0);
                          strcpy(Var, join(2,"int ",Var));
                        }
                    }
                  i=CheckType(Stk[A+1]);
                  strcpy(ZZ,lcase(Stk[A+1]));
                  if(i==vt_STRUCT||i==vt_UNION||str_cmp(ZZ,"int")==0 ||  str_cmp(ZZ,"double")==0 ||  str_cmp(ZZ,"float")==0)
                    {
                      fprintf(Outfile,"%s%s%s%s%s\n",Scoot,Var," = sizeof(",Stk[A+1],");");
                    }
                  else
                    {
                      fprintf(Outfile,"%s%s%s%s%s\n",Scoot,Var," = ",Clean(Stk[A+1]),";");
                    }
                  *Stk[A]=0;
                  *Stk[A+1]=0;
                }
              break;
            }
          }
        fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"if((",Clean(Handl),"=fopen(",Filnam,",",Op,"))==0)");
        fprintf(Outfile,"%s%s\n",Scoot," {");
        strcpy(lszTmp,enc("Can't open file %s\\n"));
        fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"   fprintf(stderr,",lszTmp,",",Filnam,");");
        fprintf(Outfile,"%s%s\n",Scoot,"   exit(1);");
        fprintf(Outfile,"%s%s\n",Scoot," }");
        break;
      }
    if(str_cmp(Lookup,"record")==0)
      {
        static   struct _functionParse  ffp;
        memset(&ffp,0,sizeof(ffp));
        int     numargs=0;
        if(DataType(Stk[2])==vt_NUMBER)
          {
            strcpy(Stk[2], join(2,"FP",Stk[2]));
          }
        if(Ndx>1)
          {
            numargs=SepFuncArgs(1, &ffp,FALSE);
          }
        if(numargs<1)
          {
            Abort("Missing required arguments to RECORD");
          }
        if(numargs>4)
          {
            Abort("Too many arguments to RECORD");
          }
        if(numargs==3)
          {
            fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s\n",Scoot,"fseek(",GetArg(1, &ffp),", (",GetArg(2, &ffp)," - 1) * ",Stk[2],"len + ",GetArg(3, &ffp),", SEEK_SET);");
          }
        else if(numargs==2)
          {
            fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"fseek(",GetArg(1, &ffp),", (",GetArg(2, &ffp)," - 1) * ",Stk[2],"len, SEEK_SET);");
          }
        else
          {
            fprintf(Outfile,"%s%s%s%s\n",Scoot,"fseek(",GetArg(1, &ffp),", 0, SEEK_SET);");
          }
        break;
      }
    if(str_cmp(Lookup,"fwrite")==0)
      {
        if(DataType(Stk[2])==vt_NUMBER)
          {
            strcpy(Stk[2], join(2,"FP",Stk[Ndx]));
          }
        if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
          {
            AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
          }
        *Handl=0;
        for(j=2; j<=Ndx; j+=1)
          {
            if(iMatchWrd(Stk[j],",")||iMatchWrd(Stk[j],";"))
              {
                *Stk[j]=0;
                break;
              }
            strcat(Handl,Stk[j]);
            *Stk[j]=0;
          }
        strcat(Handl,"@");
        strcpy(ZZ, join(2,"f",PrintWriteFormat(1)));
        strcpy(ZZ, join(4,left(ZZ,8),Clean(Handl),",",mid(ZZ,9)));
        fprintf(Outfile,"%s%s\n",Scoot,ZZ);
        break;
      }
    if(str_cmp(Lookup,"close")==0)
      {
        if(Ndx==1)
          {
            fprintf(Outfile,"%s%s\n",Scoot,"fcloseall();");
            break;
          }
        if(DataType(Stk[2])==vt_NUMBER)
          {
            strcpy(Stk[2], join(2,"FP",Stk[Ndx]));
          }
        if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
          {
            if(CheckGlobal(Stk[2], &i)==vt_UNKNOWN)
              {
                AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
              }
          }
        *Handl=0;
        for(j=2; j<=Ndx; j+=1)
          {
            strcat(Handl,Stk[j]);
          }
        fprintf(Outfile,"%s%s%s%s\n",Scoot,"if(",Handl,")");
        fprintf(Outfile,"%s%s\n",Scoot," {");
        fprintf(Outfile,"%s%s%s%s\n",Scoot,"   fclose(",Handl,");");
        fprintf(Outfile,"%s%s%s%s\n",Scoot,"   ",Handl,"=NULL;");
        fprintf(Outfile,"%s%s\n",Scoot," }");
        break;
      }
    if(str_cmp(Lookup,"call")==0)
      {
        *lszTmp=0;
        for(Tmp=2; Tmp<=Ndx; Tmp+=1)
          {
            strcat(lszTmp,Clean(Stk[Tmp]));
          }
        if(!iMatchRgt(lszTmp,")"))
          {
            strcat(lszTmp,"()");
          }
        strcat(lszTmp,";");
        fprintf(Outfile,"%s%s\n",Scoot,lszTmp);
        break;
      }
    if(str_cmp(Lookup,"declare")==0)
      {
        static   struct _functionParse  FP;
        memset(&FP,0,sizeof(FP));
        char TempProto[2048];
        FuncSubDecs1("sub");
        SepFuncArgs(3, &FP,TRUE);
        strcpy(TempProto,MakeDecProto( &FP));
        if(!NoTypeDeclare)
          {
            fprintf(FP4,"%s%s\n",TempProto,";");
          }
        else
          {
            ProtoCnt++;
            strcpy(ProtoType[ProtoCnt].Prototype, join(2,TempProto,";"));
          }
        break;
      }
    if(str_cmp(Lookup,"function")==0 ||  str_cmp(Lookup,"sub")==0 ||  str_cmp(Lookup,"constructor")==0 ||  str_cmp(Lookup,"destructor")==0)
      {
        static char CTOR_USE[2048];
        memset(&CTOR_USE,0,sizeof(CTOR_USE));
        static char CTOR_SRC[2048];
        memset(&CTOR_SRC,0,sizeof(CTOR_SRC));
        static int     New_Ndx;
        memset(&New_Ndx,0,sizeof(New_Ndx));
        if(str_cmp(Stk[2],"main")==0)
          {
            strcpy(Stk[1],"function");
            strcpy(Stk[2],"main%");
            ForceMainToFunc=TRUE;
          }
        if(iMatchWrd(Stk[1],"constructor")||iMatchWrd(Stk[1],"destructor"))
          {
            strcpy(Stk[1],"sub");
              {int ct;
            for(ct=1; ct<=Ndx; ct+=1)
              {
                if(str_cmp(Stk[ct],"using")==0)
                  {
                    New_Ndx=ct-1;
                      {int ut;
                    for(ut=ct; ut<=Ndx; ut+=1)
                      {
                        strcat(CTOR_USE,Stk[ut]);
                      }
                      }
                  }
              }
              }
            if(strlen(CTOR_USE))
              {
                strcpy(CTOR_USE,iReplace(CTOR_USE,"using",":"));
                Ndx=New_Ndx;
              }
            Use_Ctor=TRUE;
          }
        FuncSubDecs1("sub");
        IsStdFunc=FALSE;
        if(iMatchWrd(Stk[Ndx],"stdcall"))
          {
            strcpy(CallType,"__attribute__((stdcall)) ");
            Ndx--;
            IsStdFunc=TRUE;
          }
        InFunc=TRUE;
        InMain=FALSE;
        LocalVarCnt=0;
        if(InNameSpace)
          {
            Outfile=FP2;
          }
        else
          {
            Outfile=FP3;
          }
        FuncSubDecs2("sub",mt_FuncSubDecC_Dec);
        strcpy(VarCode.Functype,ltrim(VarCode.Functype));
        strcpy(Funcname,Clean(Stk[2]));
        if(IsExported||IsStdFunc)
          {
            strcpy(Funcname, join(2,CallType,Funcname));
          }
        VarCode.Method=mt_FuncSubDecC_Dec2;
        A=3;
        while(A<=Ndx)
          {
            if(str_cmp(Stk[A+1],"(")==0)
              {
                for(k=A+2; k<=Ndx; k+=1)
                  {
                    if(str_cmp(Stk[k],")")==0)
                      {
                        break;
                      }
                  }
                if(iMatchWrd(Stk[k+2],"sub"))
                  {
                    j=vt_VOID;
                    strcpy(VarCode.AsToken,"void");
                  }
                else if(iMatchWrd(Stk[k+2],"function"))
                  {
                    GetTypeInfo(Stk[k+3], &IsPointer, &i, &j);
                    strcpy(VarCode.AsToken,Stk[k+3]);
                  }
                strcpy(VarCode.Token,Stk[A]);
                VarCode.VarNo=j;
                VarCode.IsPtrFlag=1;
                VarCode.Method=mt_FuncSubx1;
                GetVarCode( &VarCode);
                strcpy(Var,Clean(Stk[A]));
                *lszTmp=0;
                A+=2;
                while(A<=k)
                  {
                    if(iMatchWrd(Stk[A+1],"as")&&A<k)
                      {
                        Tmp=A+2;
                        while(str_cmp(Stk[Tmp],",")!=0 &&  str_cmp(Stk[Tmp],")")!=0)
                          {
                            GetTypeInfo(Stk[Tmp], &IsPointer, &i, &j);
                            AddLocal(Stk[A],j,i,"",IsPointer,0,0);
                            strcpy(VarCode.Token,Stk[A]);
                            strcpy(VarCode.AsToken,Stk[Tmp]);
                            VarCode.VarNo=j;
                            VarCode.IsPtrFlag=1;
                            VarCode.Method=mt_FuncSubx2;
                            GetVarCode( &VarCode);
                            Tmp++;
                            if(str_cmp(Stk[Tmp],",")==0)
                              {
                                strcat(VarCode.Proto,",");
                                strcat(VarCode.Header,",");
                              }
                          }
                        A=Tmp;
                      }
                    else
                      {
                        if(str_cmp(Stk[A],",")!=0 &&  str_cmp(Stk[A],")")!=0)
                          {
                            IsPointer=tally((Stk[A]),"*");
                            strcpy(Var,RemoveStr(Stk[A],"*"));
                            j=DataType(Var);
                            if(j!=vt_UNKNOWN&&InFunc==TRUE&&Var[0])
                              {
                                AddLocal(Clean(Var),j,0,"",IsPointer,0,0);
                              }
                            strcpy(VarCode.Token,Stk[A]);
                            *VarCode.AsToken=0;
                            VarCode.VarNo=j;
                            VarCode.IsPtrFlag=IsPointer;
                            VarCode.Method=mt_FuncSubDecC_Dec2;
                            GetVarCode( &VarCode);
                          }
                      }
                    A++;
                  }
                A=k+3;
                if(VarCode.Method==mt_FuncSubDecC_Dec2)
                  {
                    midstr(VarCode.Proto,strlen(VarCode.Proto)-1,1,")");
                    midstr(VarCode.Header,strlen(VarCode.Header)-1,1,")");
                  }
                else
                  {
                    strcat(VarCode.Proto,")");
                    strcat(VarCode.Header,")");
                  }
                VarCode.Method=mt_FuncSubDecC_Dec2;
              }
            else
              {
                if(iMatchWrd(Stk[A+1],"as"))
                  {
                    GetTypeInfo(Stk[A+2], &IsPointer, &i, &j);
                    strcpy(Var,Clean(Stk[A]));
                    AddLocal(Var,j,i,"",IsPointer,0,0);
                    strcpy(VarCode.Token,Stk[A]);
                    strcpy(VarCode.AsToken,Stk[A+2]);
                    VarCode.VarNo=j;
                    VarCode.IsPtrFlag=IsPointer;
                    GetVarCode( &VarCode);
                    *Stk[A+1]=0;
                    *Stk[A+2]=0;
                    A+=2;
                  }
                else
                  {
                    if(inchr("=",Stk[A])&&str_cmp(Stk[A],"")!=0)
                      {
                        Abort("Illegal optional parameter found");
                      }
                    if(!inchr(",().",Stk[A])&&str_cmp(Stk[A],"")!=0)
                      {
                        IsPointer=tally((Stk[A]),"*");
                        strcpy(Var,RemoveStr(Stk[A],"*"));
                        j=DataType(Var);
                        if(j!=vt_UNKNOWN&&Var[0])
                          {
                            AddLocal(Clean(Var),j,0,"",IsPointer,0,0);
                          }
                        strcpy(VarCode.Token,Stk[A]);
                        *VarCode.AsToken=0;
                        VarCode.VarNo=j;
                        VarCode.IsPtrFlag=IsPointer;
                        GetVarCode( &VarCode);
                      }
                  }
              }
            A++;
          }
        VarCode.Method=2;
        strcpy(VarCode.Token,Funcname);
        FuncSubDecs3( &VarCode);
        if(iMatchLft(VarCode.Header,"main("))
          {
            strcpy(VarCode.Header,"int main(int argc, char *argv[])");
            strcpy(VarCode.Proto,"int main(int argc, char *argv[]);");
            CurrentFuncType=vt_INTEGER;
          }
        if(Use_Static)
          {
            strcpy(VarCode.Header, join(2,"static ",VarCode.Header));
            strcpy(VarCode.Proto, join(2,"static ",VarCode.Proto));
          }
        if(!InNameSpace)
          {
            ProtoCnt++;
            strcpy(ProtoType[ProtoCnt].Prototype,VarCode.Proto);
          }
        if(str_cmp(InIfDef,"FP3")==0)
          {
            if(ProtoCnt>1)
              {
                strcpy(ProtoType[ProtoCnt].Condition,ProtoType[ProtoCnt-1].Condition);
              }
            else
              {
                *ProtoType[ProtoCnt].Condition=0;
              }
          }
        else
          {
            strcpy(ProtoType[ProtoCnt].Condition,InIfDef);
          }
        ProtoType[ProtoCnt].CondLevel=InConditional;
        if(*InIfDef)
          {
            if(str_cmp(InIfDef,"FP3")!=0)
              {
                fprintf(Outfile,"%s\n",InIfDef);
                printf("%s\n",InIfDef);
              }
          }
        if(Use_Ctor)
          {
            strcpy(VarCode.Header,replace(VarCode.Header,"void ",""));
            strcpy(VarCode.Header,replace(VarCode.Header,"void",""));
            if(strlen(CTOR_USE))
              {
                fprintf(Outfile,"%s\n",VarCode.Header);
                fprintf(Outfile,"%s%s\n",Scoot,CTOR_USE);
              }
            else
              {
                fprintf(Outfile,"%s\n",VarCode.Header);
              }
            Use_Ctor=FALSE;
          }
        else if(InNameSpace)
          {
            char szCPP_SF1[2048];
            *szCPP_SF1=0;
            if(iMatchLft(Lookup,"public"))
              {
                strcpy(szCPP_SF1,"public: virtual ");
              }
            fprintf(Outfile,"%s%s%s\n",Scoot,szCPP_SF1,VarCode.Header);
          }
        else
          {
            fprintf(Outfile,"%s\n",VarCode.Header);
          }
        fprintf(Outfile,"%s%s\n",Scoot,"{");
        BumpUp();
        break;
      }
    if(str_cmp(Lookup,"optfunction")==0 ||  str_cmp(Lookup,"optsub")==0)
      {
        FuncSubDecs1("optsub");
        InFunc=TRUE;
        LocalVarCnt=0;
        Outfile=FP3;
        if(InNameSpace)
          {
            Outfile=FP2;
          }
        else
          {
            Outfile=FP3;
          }
        FuncSubDecs2("optsub",mt_Opts);
        strcpy(Funcname,Clean(Stk[2]));
        VarCode.Method=mt_Opts2;
        A=4;
        while(A<Ndx)
          {
            if(Stk[A][0]==0)
              {
                A++;
                continue;
              }
            if(str_cmp(Stk[A],",")==0)
              {
                VarCode.Method=mt_Opts3;
                strcpy(VarCode.Token,Stk[A]);
                GetVarCode( &VarCode);
                VarCode.Method=mt_Opts2;
              }
            else if(str_cmp(Stk[A],"=")==0)
              {
                VarCode.Method=mt_Opts3;
                if(str_cmp(Stk[A+1],"-")==0)
                  {
                    strcpy(VarCode.Token, join(3,Stk[A],Stk[A+1],Stk[A+2]));
                    *Stk[A+1]=0;
                    *Stk[A+2]=0;
                    A++;
                  }
                else
                  {
                    strcpy(VarCode.Token, join(2,Stk[A],Stk[A+1]));
                    *Stk[A+1]=0;
                  }
                if(iMatchWrd(Stk[A+2],"as"))
                  {
                    *Stk[A+2]=0;
                    *Stk[A+3]=0;
                  }
                VarCode.VarNo=j;
                VarCode.IsPtrFlag=IsPointer;
                GetVarCode( &VarCode);
                VarCode.Method=mt_Opts2;
              }
            else if(iMatchWrd(Stk[A+1],"as"))
              {
                GetTypeInfo(Stk[A+2], &IsPointer, &i, &j);
                if(InFunc)
                  {
                    strcpy(Var,Clean(Stk[A]));
                    AddLocal(Var,j,i,"",IsPointer,0,0);
                  }
                VarCode.VarNo=j;
                strcpy(VarCode.Token,Stk[A]);
                strcpy(VarCode.AsToken,Stk[A+2]);
                VarCode.IsPtrFlag=IsPointer;
                GetVarCode( &VarCode);
                *Stk[A+1]=0;
                *Stk[A+2]=0;
              }
            else
              {
                IsPointer=tally((Stk[A]),"*");
                strcpy(Var,RemoveStr(Stk[A],"*"));
                j=DataType(Var);
                if(j!=vt_UNKNOWN)
                  {
                    AddLocal(Clean(Var),j,0,"",IsPointer,0,0);
                  }
                VarCode.VarNo=j;
                strcpy(VarCode.Token,Stk[A]);
                *VarCode.AsToken=0;
                VarCode.IsPtrFlag=IsPointer;
                GetVarCode( &VarCode);
              }
            A++;
          }
        VarCode.Method=2;
        strcpy(VarCode.Token,Funcname);
        FuncSubDecs3( &VarCode);
        if(Use_Static)
          {
            strcpy(VarCode.Header, join(2,"static ",VarCode.Header));
            strcpy(VarCode.Proto, join(2,"static ",VarCode.Proto));
          }
        ProtoCnt++;
        strcpy(ProtoType[ProtoCnt].Prototype,VarCode.Proto);
        if(str_cmp(InIfDef,"FP3")==0)
          {
            *ProtoType[ProtoCnt].Condition=0;
          }
        else
          {
            strcpy(ProtoType[ProtoCnt].Condition,InIfDef);
          }
        ProtoType[ProtoCnt].CondLevel=InConditional;
        fprintf(Outfile,"%s\n",VarCode.Header);
        fprintf(Outfile,"%s%s\n",Scoot,"{");
        BumpUp();
        break;
      }
    if(str_cmp(Lookup,"overloadedfunction")==0 ||  str_cmp(Lookup,"overloadedsub")==0)
      {
        Use_Overloaded=TRUE;
        FuncSubDecs1("overloadedsub");
        InFunc=TRUE;
        InMain=FALSE;
        LocalVarCnt=0;
        Outfile=FP8;
        FuncSubDecs2("overloadedsub",mt_OverLoad);
        strcpy(Funcname,Clean(Stk[2]));
        strcpy(lszTmp, join(2," overloaded ",Funcname));
        strcpy(Funcname,lszTmp);
        VarCode.Method=mt_OverLoad2;
        for(A=3; A<=Ndx; A+=1)
          {
            if(iMatchWrd(Stk[A+1],"as"))
              {
                GetTypeInfo(Stk[A+2], &IsPointer, &i, &j);
                strcpy(Var,Clean(Stk[A]));
                AddLocal(Var,j,i,"",IsPointer,0,0);
                strcpy(VarCode.AsToken,Stk[A+2]);
                *Stk[A+1]=0;
                *Stk[A+2]=0;
              }
            else
              {
                strcpy(Var,RemoveStr(Stk[A],"*"));
                j=DataType(Var);
                if(!inchr(",().",Stk[A])&&str_cmp(Stk[A],"")!=0)
                  {
                    IsPointer=tally((Stk[A]),"*");
                    if(j!=vt_UNKNOWN&&InFunc==TRUE&&Var[0])
                      {
                        AddLocal(Clean(Var),j,0,"",IsPointer,0,0);
                      }
                  }
                *VarCode.AsToken=0;
              }
            VarCode.VarNo=j;
            strcpy(VarCode.Token,Stk[A]);
            GetVarCode( &VarCode);
          }
        VarCode.Method=1;
        strcpy(VarCode.Token,Funcname);
        FuncSubDecs3( &VarCode);
        if(Use_Static)
          {
            strcpy(VarCode.Header, join(2,"static ",VarCode.Header));
          }
        fprintf(Outfile,"%s\n",VarCode.Header);
        fprintf(Outfile,"%s%s\n",Scoot,"{");
        BumpUp();
        break;
      }
    if(str_cmp(Lookup,"functionreturn")==0)
      {
        if(CaseFlag)
          {
            NoBreak2=TRUE;
          }
        *lszTmp=0;
        for(A=3; A<=Ndx; A+=1)
          {
            strcpy(lszTmp, join(3,lszTmp,Stk[A]," "));
          }
        if(CurrentFuncType==vt_STRVAR)
          {
            strcpy(lszTmp, join(2,"BCX_RetStr$ = ",lszTmp));
            FuncRetnFlag=1;
            UseFlag=TRUE;
          }
        else
          {
            FuncRetnFlag=2;
          }
        if(FuncRetnFlag==2)
          {
            if(LocalDynaCnt!=0)
              {
                for(j=1; j<=LocalDynaCnt; j+=1)
                  {
                    fprintf(Outfile,"%s%s\n",Scoot,DynaStr[j]);
                  }
              }
            if(LocalDynArrCount!=0)
              {
                for(i=1; i<=LocalDynArrCount; i+=1)
                  {
                    fprintf(Outfile,"%s%s\n",Scoot,LocalDynArrName[i]);
                  }
              }
            fprintf(Outfile,"%s%s",Scoot,"return ");
            LastCmd=2;
          }
        Parse(lszTmp);
        LastCmd=0;
        goto EMITAGAIN;
      }
    if(str_cmp(Lookup,"endfunction")==0 ||  str_cmp(Lookup,"endsub")==0 ||  str_cmp(Lookup,"endconstructor")==0 ||  str_cmp(Lookup,"enddestructor")==0)
      {
        if(iMatchWrd(Stk[1],"endfunction"))
          {
            LocalDynaCnt=0;
            LocalDynArrCount=0;
          }
        if(iMatchWrd(Stk[1],"endsub")||iMatchWrd(Stk[1],"endconstructor")||iMatchWrd(Stk[1],"enddestructor"))
          {
            if(LocalDynaCnt!=0)
              {
                for(j=1; j<=LocalDynaCnt; j+=1)
                  {
                    fprintf(Outfile,"%s%s\n",Scoot,DynaStr[j]);
                  }
                LocalDynaCnt=0;
              }
            if(LocalDynArrCount!=0)
              {
                for(i=1; i<=LocalDynArrCount; i+=1)
                  {
                    fprintf(Outfile,"%s%s\n",Scoot,LocalDynArrName[i]);
                  }
                LocalDynArrCount=0;
              }
          }
        if(ForceMainToFunc==TRUE)
          {
            fprintf(Outfile,"%s%s\n",Scoot,"return 0;");
            ForceMainToFunc=FALSE;
          }
        BumpDown();
        if(InNameSpace)
          {
            fprintf(FP2,"%s%s\n",Scoot,"}\n");
          }
        else
          {
            fprintf(Outfile,"%s%s\n",Scoot,"}\n\n");
            BumpDown();
          }
        InFunc=FALSE;
        Use_Static=FALSE;
        if(Outfile==FP3)
          {
            strcpy(InIfDef,"FP3");
          }
        Outfile=FP2;
        ByrefCnt=0;
        break;
      }
    if(str_cmp(Lookup,"input")==0)
      {
        EmitInputCode();
        break;
      }
    if(str_cmp(Lookup,"finput")==0)
      {
        EmitFileInputCode();
        break;
      }
    if(str_cmp(Lookup,"dynamic")==0)
      {
        int     w=0;
        char SOF[2048];
        HandleNonsense();
        strcpy(CVar,Clean(Stk[2]));
        ValidVar(CVar);
        if(str_cmp(Stk[Ndx],"*")==0)
          {
            PointerFix();
          }
        if(str_cmp(Stk[Ndx],"&")==0)
          {
            *Stk[Ndx--]=0;
            strcat(Stk[Ndx],"&");
          }
        *ZZ=0;
        if(iMatchWrd(Stk[Ndx-1],"as"))
          {
            strcpy(SOF,Stk[Ndx]);
            GetTypeInfo(SOF, &w, &id, &vt);
            if(vt==vt_STRLIT||vt==vt_DECFUNC||vt==vt_NUMBER||(vt==vt_VOID&&inchr(Stk[Ndx],"*")==0))
              {
                Abort(join(2,SOF," is not a valid type"));
              }
            if(vt==vt_FILEPTR&&inchr(SOF,"*")==0)
              {
                strcat(SOF,"*");
              }
            Ndx-=2;
          }
        else
          {
            vt=DataType(Stk[2]);
            id=0;
            strcpy(SOF,GetVarTypeName(vt));
          }
        Use_DynamicA=TRUE;
        for(i=3; i<=Ndx; i+=1)
          {
            strcat(ZZ,Stk[i]);
          }
        dms=tally(ZZ,"][")+1;
        if(dms>1)
          {
            strcpy(ZZ,replace(ZZ,"][",","));
          }
        strcpy(ZZ,Clean(ZZ));
        RemoveAll(ZZ,"[]");
        if(vt==vt_STRVAR)
          {
            vt=vt_CHAR;
            strcpy(SOF,"char");
            if(InTypeDef)
              {
                if(str_cmp(Stk[3],"[")!=0)
                  {
                    dms--;
                  }
                else
                  {
                    vt=vt_CHARPTR;
                  }
              }
            dms++;
            strcat(ZZ,",65535");
          }
        if(InTypeDef)
          {
            if(vt==vt_STRUCT)
              {
                fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,"struct _",SOF,"  ",stringx(dms,42),CVar,";");
              }
            else
              {
                fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,SOF,"  ",stringx(dms,42),CVar,";");
              }
            AddTypedefElement(BaseTypeDefsCnt[InTypeDef],vt,CVar,SOF,dms);
          }
        else if(InFunc)
          {
            LocalDynArrCount++;
            strcpy(LocalDynArrName[LocalDynArrCount], join(9,"if (",CVar,") { DestroyArr((void **)",CVar,",",str(dms),", 1); ",CVar,"=NULL; }"));
            fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,SOF,"  ",stringx(dms,42),CVar,"=0;");
            AddLocal(CVar,vt,id,"",dms,0,0);
          }
        else
          {
            if(Use_GenFree)
              {
                GlobalDynaCnt++;
                strcpy(GlobalDynaStr[GlobalDynaCnt], join(9,"if (",CVar,") { DestroyArr((void **)",CVar,",",str(dms),", 1); ",CVar,"=NULL; }"));
              }
            AddGlobal(CVar,vt,id,"",dms,0,0,0);
          }
        if(!InTypeDef)
          {
            fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",Scoot,CVar,"= (",SOF,stringx(dms,42),")CreateArr (",CVar,",sizeof(",SOF,"),0,",trim(str(dms)),",",ZZ,");");
          }
        break;
      }
    if(str_cmp(Lookup,"redim")==0)
      {
        int     IsPreserve;
        char SOF[2048];
         VarInfo*  VI;
        int     vt1=0;
        int     IsSplat=0;
        int     BC=0;
        int     StartPoint;
        int     AsPos=Ndx;
        HandleNonsense();
        IsPreserve=iMatchWrd(Stk[2],"preserve");
        StartPoint=2+IsPreserve;
        vt1=DataType(Stk[StartPoint]);
        strcpy(CVar,Clean(Stk[StartPoint]));
        IsSplat=iMatchWrd(Stk[StartPoint+1],"*");
        ValidVar(CVar);
        for(i=Ndx; i>=1; i+=-1)
          {
            if(iMatchWrd(Stk[AsPos],"as"))
              {
                AsPos=i-1;
                break;
              }
          }
        int     L=AsPos;
        int     SP=0;
        while(L>StartPoint)
          {
            if(str_cmp(Stk[L],"[")==0)
              {
                BC--;
              }
            else if(str_cmp(Stk[L],"]")==0)
              {
                BC++;
                if(BC==1)
                  {
                    L--;
                    continue;
                  }
              }
            if(BC==0)
              {
                SP++;
                if(str_cmp(Stk[L-1],"]")!=0)
                  {
                    break;
                  }
                strcpy(ZZ, join(2,",",ZZ));
              }
            else
              {
                strcpy(ZZ, join(2,Stk[L],ZZ));
              }
            L--;
          }
        vt=CheckLocal(CVar, &id);
        if(vt==vt_UNKNOWN)
          {
            vt=CheckGlobal(CVar, &id);
            if(vt==vt_UNKNOWN)
              {
                Abort(join(3,"Can not REDIM ",CVar," not previously dimensioned"));
              }
            VI= &GlobalVars[id];
          }
        else
          {
            VI= &LocalVars[id];
          }
        dms=VI->VarPntr;
        if(vt==vt_STRUCT||vt==vt_UDT||vt==vt_UNION)
          {
            strcpy(SOF,GetElement(StartPoint, &vt, &dms,VI->VarDef));
            i=Ndx;
            Ndx=L-1;
            AsmUnknownStructs(1);
            Ndx=i;
            RemEmptyTokens();
            strcpy(CVar,Clean(Stk[StartPoint]));
            IsSplat=iMatchWrd(Stk[StartPoint+1],"*");
          }
        else
          {
            strcpy(SOF,GetVarTypeName(vt));
          }
        if(iMatchWrd(Stk[Ndx-1],"as"))
          {
            if(str_cmp(SOF,Stk[Ndx])!=0 && !iMatchWrd(Stk[Ndx],"string"))
              {
                Abort(join(6,"Can not change types for variable ",CVar," previously defined as ",SOF," on line",str(VI->VarLine)));
              }
            if(iMatchWrd(Stk[Ndx],"string"))
              {
                Ndx--;
                strcpy(Stk[Ndx],"[");
                strcpy(Stk[++Ndx],"65535");
                strcpy(Stk[++Ndx],"]");
              }
            else
              {
                Ndx-=2;
              }
          }
        else
          {
            if((vt==vt_CHAR&&vt1==vt_STRVAR&&IsSplat==0)||vt==vt_CHARPTR)
              {
                Ndx++;
                strcpy(Stk[Ndx],"[");
                strcpy(Stk[++Ndx],"65535");
                strcpy(Stk[++Ndx],"]");
              }
          }
        if(str_cmp(Stk[3+IsPreserve],"[")==0)
          {
            if(IsPreserve)
              {
                StartPoint=4;
              }
            else
              {
                fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s\n",Scoot,"if (",CVar,") { DestroyArr((void **)",CVar,",",str(dms),", 1); ",CVar,"=NULL; }");
                StartPoint=3;
              }
            Use_DynamicA=TRUE;
            A=0;
            *ZZ=0;
            for(i=StartPoint; i<=Ndx; i+=1)
              {
                if(str_cmp(Stk[i],"[")==0)
                  {
                    A++;
                    i++;
                    BC=1;
                    while(BC>0)
                      {
                        if(str_cmp(Stk[i],"[")==0)
                          {
                            BC++;
                            strcat(ZZ,Stk[i]);
                          }
                        else
                          {
                            if(str_cmp(Stk[i],"]")==0)
                              {
                                BC--;
                                if(BC==0&&i<Ndx)
                                  {
                                    strcat(ZZ,",");
                                  }
                                if(BC)
                                  {
                                    strcat(ZZ,Stk[i]);
                                  }
                              }
                            else
                              {
                                strcat(ZZ,Stk[i]);
                              }
                          }
                        i++;
                      }
                    i--;
                  }
              }
            strcpy(ZZ,Clean(ZZ));
            if(vt==vt_STRLIT||vt==vt_DECFUNC||vt==vt_NUMBER||(vt==vt_VOID&&inchr(Stk[Ndx],"*")==0))
              {
                Abort(join(2,Stk[Ndx]," is not a valid type"));
              }
            if(vt==vt_STRVAR)
              {
                strcpy(SOF,"char");
                A++;
                strcat(ZZ,",65535");
              }
            if(A!=dms)
              {
                Abort(join(6,"Mismatch in dimensions for ",CVar,", orignally ",str(dms)," found ",str(A)));
              }
            fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%d%s%s%s\n",Scoot,CVar,"= (",SOF,stringx(dms,42),")CreateArr (",CVar,",sizeof(",SOF,"),",trim(str(IsPreserve)),",",(int)dms,",",ZZ,");");
            break;
          }
        if(str_cmp(Stk[3],"*")==0 || (IsPreserve&&str_cmp(Stk[4],"*")==0))
          {
            if(IsPreserve)
              {
                fprintf(Outfile,"%s%s%s%s%s",Scoot,CVar,"=(char*)realloc(",CVar,",256+");
                i=5;
              }
            else
              {
                fprintf(Outfile,"%s%s%s%s\n",Scoot,"free(",CVar,");");
                fprintf(Outfile,"%s%s%s",Scoot,CVar,"=(char*)calloc(256+");
                i=4;
              }
            for(A=i; A<=Ndx; A+=1)
              {
                fprintf(Outfile,"%s",Clean(Stk[A]));
              }
            if(IsPreserve)
              {
                fprintf(Outfile,"%s\n",");");
              }
            else
              {
                fprintf(Outfile,"%s\n",",1);");
              }
            break;
          }
        Abort("Invalid REDIM statement");
        break;
      }
    if(str_cmp(Lookup,"dim")==0 ||  str_cmp(Lookup,"local")==0 ||  str_cmp(Lookup,"raw")==0 ||  str_cmp(Lookup,"static")==0 ||  str_cmp(Lookup,"auto")==0 ||  str_cmp(Lookup,"register")==0)
      {
        int     w=0;
        char UseStatic[2048];
        int     IsVolatile=0;
        char IV[2048];
        IsVolatile=iMatchWrd(Stk[2],"volatile");
        if(IsVolatile)
          {
            strcpy(IV,"volatile ");
          }
        else
          {
            *IV=0;
          }
        IsSubOrFuncPtr=SubFuncTest();
        HandleNonsense();
        if(str_cmp(Stk[Ndx],"*")==0)
          {
            PointerFix();
          }
        if(str_cmp(Stk[Ndx],"&")==0)
          {
            *Stk[Ndx--]=0;
            strcat(Stk[Ndx],"&");
          }
        IsRegister=IsAuto=IsDim=IsLocal=IsStatic=IsRaw=FALSE;
        strcpy(Cmd,lcase(Stk[1]));
        for(;;)
        {
          if(str_cmp(Cmd,"dim")==0)
            {
              IsDim=TRUE;
              break;
            }
          if(str_cmp(Cmd,"local")==0)
            {
              IsLocal=TRUE;
              break;
            }
          if(str_cmp(Cmd,"static")==0)
            {
              IsStatic=TRUE;
              break;
            }
          if(str_cmp(Cmd,"raw")==0)
            {
              IsRaw=TRUE;
              break;
            }
          if(str_cmp(Cmd,"auto")==0)
            {
              IsAuto=TRUE;
              break;
            }
          if(str_cmp(Cmd,"register")==0)
            {
              IsRegister=TRUE;
            }
          break;
        }
        if(InTypeDef)
          {
            if(iMatchWrd(Stk[2],"public")||iMatchWrd(Stk[2],"private")||iMatchWrd(Stk[2],"protected"))
              {
                fprintf(Outfile,"%s%s%s\n",LF,lcase(Stk[2]),":");
                break;
              }
            else if(iMatchWrd(Stk[2],"constructor")||iMatchWrd(Stk[2],"destructor"))
              {
                DimSubFunc(0);
                break;
              }
            else if(iMatchWrd(Stk[2],"virtual"))
              {
                *vproc=0;
                if(iMatchWrd(Stk[Ndx-1],"=")&&iMatchWrd(Stk[Ndx],"0"))
                  {
                    strcpy(vproc, join(2,Stk[Ndx-1],Stk[Ndx]));
                    Ndx-=2;
                  }
                  {int act;
                for(act=3; act<=Ndx; act+=1)
                  {
                    strcpy(Stk[act-1],Stk[act]);
                  }
                  }
                Ndx--;
                DimSubFunc(0);
                break;
              }
          }
        if(IsSubOrFuncPtr)
          {
            if(IsVolatile)
              {
                Abort("volatile SUB/FUNCTION pointers not supported");
              }
            if(DimSubFunc(0))
              {
                break;
              }
          }
        strcpy(CVar,Clean(Stk[2+IsVolatile]));
        ValidVar(CVar);
        VType=DataType(Stk[2+IsVolatile]);
        if(str_cmp(Stk[3+IsVolatile],"*")==0)
          {
            if(IsVolatile)
              {
                Abort("volatile dynamic strings not supported");
              }
            DimDynaString(CVar,0,0);
            break;
          }
        int     iASoffset=0;
        char sConst[2048];
        int     iIsConst;
        if(iMatchWrd(Stk[Ndx-1],"as"))
          {
            iASoffset=Ndx-1;
          }
        if(iMatchWrd(Stk[Ndx-2],"as"))
          {
            iASoffset=Ndx-2;
          }
        if(iASoffset)
          {
            iIsConst=0;
            *sConst=0;
            if(iASoffset==Ndx-2)
              {
                if(iMatchWrd(Stk[Ndx-1],"const"))
                  {
                    strcpy(sConst,"const");
                    iIsConst=1;
                  }
              }
            strcpy(Var1,CVar);
            IsPointer=tally(Stk[Ndx],"*");
            *DimType=0;
            *lszTmp=0;
            for(i=2+IsVolatile; i<=iASoffset-1; i+=1)
              {
                strcat(lszTmp,Stk[i]);
                if(i>2+IsVolatile)
                  {
                    strcat(DimType,Stk[i]);
                  }
              }
            strcpy(Var,RemoveStr(Stk[Ndx],"*"));
            GetTypeInfo(Var, &w, &id, &vt);
            if(vt==vt_STRVAR)
              {
                strcpy(Stk[Ndx],"char");
                strcpy(Var,Stk[Ndx]);
                strcat(DimType,"[65535]");
                strcat(lszTmp,"[65535]");
              }
            if(InFunc||InTypeDef)
              {
                if(IsRegister||IsAuto)
                  {
                    if(IsRegister)
                      {
                        if(IsVolatile)
                          {
                            Abort("Register volatile not supported");
                          }
                        if(vt==vt_FILEPTR)
                          {
                            fprintf(Outfile,"%s%s",Scoot,"register  FILE*   ");
                          }
                        else
                          {
                            fprintf(Outfile,"%s%s%s%s%s%s",Scoot,"register  ",sConst," ",Stk[Ndx],"  ");
                          }
                      }
                    else
                      {
                        if(vt==vt_FILEPTR)
                          {
                            fprintf(Outfile,"%s%s%s%s",Scoot,"auto ",IV,"  FILE*   ");
                          }
                        else
                          {
                            fprintf(Outfile,"%s%s%s%s%s%s%s%s",Scoot,"auto ",IV," ",sConst," ",Stk[Ndx],"  ");
                          }
                      }
                  }
                else
                  {
                    if(IsRaw==TRUE)
                      {
                        if(vt==vt_FILEPTR)
                          {
                            fprintf(Outfile,"%s%s%s%s",Scoot,"static ",IV,"  FILE*   ");
                          }
                        else
                          {
                            fprintf(Outfile,"%s%s%s%s%s%s",Scoot,IV,sConst," ",Stk[Ndx],"  ");
                          }
                      }
                    else
                      {
                        if(InTypeDef)
                          {
                            *UseStatic=0;
                          }
                        else
                          {
                            strcpy(UseStatic,"static  ");
                          }
                        if(vt==vt_STRUCT)
                          {
                            fprintf(Outfile,"%s%s%s%s%s%s%s%s",Scoot,UseStatic,IV,sConst," ","struct _",Stk[Ndx],"  ");
                          }
                        else
                          {
                            if(vt==vt_FILEPTR)
                              {
                                fprintf(Outfile,"%s%s%s%s",Scoot,UseStatic,IV,"FILE   *");
                              }
                            else
                              {
                                fprintf(Outfile,"%s%s%s%s%s%s%s",Scoot,UseStatic,IV,sConst," ",Stk[Ndx],"  ");
                              }
                          }
                        if(InTypeDef)
                          {
                            AddTypedefElement(BaseTypeDefsCnt[InTypeDef],vt,CVar,Var,0);
                          }
                      }
                  }
                if(InFunc&&!InTypeDef)
                  {
                    AddLocal(Var1,vt,id,DimType,IsPointer,0,0,iIsConst);
                  }
                fprintf(Outfile,"%s%s\n",Clean(lszTmp),";");
                if(!InTypeDef&&!IsStatic&&!IsRaw&&!IsRegister&&!IsVolatile)
                  {
                    strcpy(T,Clean(extract(lszTmp,"[")));
                    if(IsPointer)
                      {
                        fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",Clean(Var)," *","));");
                      }
                    else
                      {
                        fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",T,"));");
                      }
                  }
              }
            else
              {
                if(IsVolatile)
                  {
                    AddGlobal(Var1,vt,id,DimType,IsPointer,0,3,0,iIsConst);
                  }
                else
                  {
                    AddGlobal(Var1,vt,id,DimType,IsPointer,0,0,0,iIsConst);
                  }
              }
            break;
          }
        if(InFunc||InTypeDef)
          {
            *lszTmp=0;
            if(iMatchWrd(Stk[3+IsVolatile],"as"))
              {
                VType=CheckType(Stk[4+IsVolatile]);
                if(VType==vt_CHAR)
                  {
                    if(str_cmp(Stk[5],"*")==0)
                      {
                        strcpy(lszTmp, join(3,"[",Stk[6+IsVolatile],"]"));
                      }
                  }
              }
            else
              {
                for(i=3+IsVolatile; i<=Ndx; i+=1)
                  {
                    strcat(lszTmp,Stk[i]);
                  }
                strcpy(lszTmp,ltrim(Clean(lszTmp)));
                if(VType==vt_STRVAR)
                  {
                    if(str_cmp(lszTmp,"[65535]")!=0)
                      {
                        strcat(lszTmp,"[2048]");
                      }
                  }
              }
            j=(!InTypeDef BAND !IsStatic BAND !IsRaw BAND !IsRegister);
            if(j)
              {
                strcpy(T,Clean(extract(CVar,"[")));
              }
            for(;;)
            {
              if(VType==vt_STRVAR)
                {
                  if(IsRaw)
                    {
                      fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,IV,"char ",CVar,lszTmp,";");
                    }
                  else if(IsAuto)
                    {
                      fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,"auto ",IV,"char ",CVar,lszTmp,";");
                    }
                  else if(IsRegister)
                    {
                      if(IsVolatile)
                        {
                          Abort("register volatile not supported");
                        }
                      fprintf(Outfile,"%s%s%s%s%s\n",Scoot,"register char ",CVar,lszTmp,";");
                    }
                  else
                    {
                      if(InTypeDef)
                        {
                          fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,IV,"char ",CVar,lszTmp,";");
                        }
                      else
                        {
                          fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,"static ",IV,"char ",CVar,lszTmp,";");
                        }
                    }
                  if(j&&!IsVolatile)
                    {
                      fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",T,"));");
                    }
                  break;
                }
              if(VType>=vt_VarMin&&VType<=vt_VarMax)
                {
                  strcpy(ZZ,GetVarTypeName(VType));
                  strcpy(ZZ,rpad(ZZ,7));
                  if(IsRaw)
                    {
                      fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,IV,ZZ," ",CVar,lszTmp,";");
                    }
                  else if(IsAuto)
                    {
                      fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"auto ",IV,ZZ," ",CVar,lszTmp,";");
                    }
                  else if(IsRegister)
                    {
                      if(IsVolatile)
                        {
                          Abort("Regester volatile not supported");
                        }
                      fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,"register ",ZZ," ",CVar,lszTmp,";");
                    }
                  else
                    {
                      if(InTypeDef)
                        {
                          fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,IV,ZZ," ",CVar,lszTmp,";");
                        }
                      else
                        {
                          fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"static ",IV,ZZ," ",CVar,lszTmp,";");
                        }
                    }
                  if(j&&!IsVolatile)
                    {
                      fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",T,"));");
                    }
                }
              break;
            }
            if(InFunc&&!InTypeDef)
              {
                AddLocal(CVar,VType,0,lszTmp,0,0,0);
              }
            if(InTypeDef)
              {
                AddTypedefElement(BaseTypeDefsCnt[InTypeDef],VType,CVar,Var,0);
              }
            break;
          }
        *lszTmp=0;
        for(i=3+IsVolatile; i<=Ndx; i+=1)
          {
            strcat(lszTmp,Stk[i]);
          }
        if(VType==vt_STRVAR&&str_cmp(lszTmp,"")!=0)
          {
            strcat(lszTmp,"[65535]");
          }
        if(IsVolatile)
          {
            AddGlobal(CVar,VType,0,lszTmp,0,0,3,0);
          }
        else
          {
            AddGlobal(CVar,VType,0,lszTmp,0,0,0,0);
          }
        break;
      }
    if(str_cmp(Lookup,"extern")==0)
      {
        int     IsVolatile;
        IsSubOrFuncPtr=SubFuncTest();
        HandleNonsense();
        IsVolatile=iMatchWrd(Stk[2],"volatile");
        strcpy(CVar,Clean(Stk[2+IsVolatile]));
        ValidVar(CVar);
        if(str_cmp(Stk[Ndx],"*")==0)
          {
            PointerFix();
          }
        if(str_cmp(Stk[Ndx],"&")==0)
          {
            *Stk[Ndx--]=0;
            strcat(Stk[Ndx],"&");
          }
        if(str_cmp(Stk[3+IsVolatile],"*")==0)
          {
            if(IsVolatile)
              {
                Abort("volatile dynamic strings not supported");
              }
            DimDynaString(CVar,2,0);
            break;
          }
        if(IsSubOrFuncPtr)
          {
            if(IsVolatile)
              {
                Abort("volatile SUB/FUNCTION pointers not supported");
              }
            if(DimSubFunc(0))
              {
                break;
              }
          }
        strcpy(Var,Clean(Stk[2+IsVolatile]));
        ValidVar(Var);
        IsPointer=0;
        *DimType=0;
        if(iMatchWrd(Stk[Ndx-1],"as"))
          {
            GetTypeInfo(Stk[Ndx], &IsPointer, &id, &vt);
            strcpy(Stk[Ndx],RemoveStr(Stk[Ndx],"*"));
            for(i=3+IsVolatile; i<=Ndx-2; i+=1)
              {
                strcat(DimType,Stk[i]);
              }
          }
        else
          {
            i=3+IsVolatile;
            while(i<=Ndx)
              {
                strcat(DimType,Stk[i]);
                i++;
              }
            vt=DataType(Stk[2+IsVolatile]);
            id=0;
          }
        if(vt==vt_STRVAR)
          {
            strcat(DimType,"[65535]");
          }
        if(IsVolatile)
          {
            AddGlobal(Var,vt,id,DimType,IsPointer,0,4,0);
          }
        else
          {
            AddGlobal(Var,vt,id,DimType,IsPointer,0,1,0);
          }
        break;
      }
    if(str_cmp(Lookup,"shared")==0 ||  str_cmp(Lookup,"global")==0)
      {
        int     w=0;
        char SOF[2048];
        int     IsShared;
        int     IsVolatile;
        IsSubOrFuncPtr=SubFuncTest();
        HandleNonsense();
        IsVolatile=iMatchWrd(Stk[2],"volatile");
        strcpy(CVar,Clean(Stk[2+IsVolatile]));
        ValidVar(CVar);
        IsShared=iMatchWrd(Stk[1],"shared");
        if(str_cmp(Stk[Ndx],"*")==0)
          {
            PointerFix();
          }
        if(str_cmp(Stk[Ndx],"&")==0)
          {
            *Stk[Ndx--]=0;
            strcat(Stk[Ndx],"&");
          }
        if(str_cmp(Stk[3+IsVolatile],"*")==0)
          {
            if(IsVolatile)
              {
                Abort("volatile dynamic strings not supported");
              }
            DimDynaString(CVar,1,IsShared);
            break;
          }
        if(IsSubOrFuncPtr)
          {
            if(IsVolatile)
              {
                Abort("volatile SUB/FUNCTION pointers not supported");
              }
            DimSubFunc(0);
            break;
          }
        if(iMatchWrd(Stk[2],"dynamic"))
          {
            strcpy(CVar,Clean(Stk[3]));
            ValidVar(CVar);
            if(iMatchWrd(Stk[Ndx-1],"as"))
              {
                strcpy(SOF,Stk[Ndx]);
                GetTypeInfo(SOF, &w, &id, &vt);
                if(vt==vt_STRLIT||vt==vt_DECFUNC||vt==vt_NUMBER||(vt==vt_VOID&&inchr(Stk[Ndx],"*")==0))
                  {
                    Abort(join(2,Stk[Ndx]," is not a valid type"));
                  }
                Ndx-=2;
              }
            else
              {
                vt=DataType(Stk[3]);
                id=0;
                strcpy(SOF,GetVarTypeName(vt));
              }
            Use_DynamicA=TRUE;
            *ZZ=0;
            for(i=4; i<=Ndx; i+=1)
              {
                strcat(ZZ,Stk[i]);
              }
            dms=tally(ZZ,"][")+1;
            if(dms>1)
              {
                strcpy(ZZ,replace(ZZ,"][",","));
              }
            strcpy(ZZ,Clean(ZZ));
            RemoveAll(ZZ,"[]");
            if(vt==vt_STRVAR)
              {
                vt=vt_CHAR;
                strcpy(SOF,"char");
                dms++;
                strcat(ZZ,",65535");
              }
            if(Use_GenFree)
              {
                GlobalDynaCnt++;
                strcpy(GlobalDynaStr[GlobalDynaCnt], join(9,"if (",CVar,") { DestroyArr((void **)",CVar,",",str(dms),", 1); ",CVar,"=NULL; }"));
              }
            AddGlobal(CVar,vt,id,"",dms,0,0,0);
            fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",Scoot,CVar,"= (",SOF,stringx(dms,42),")CreateArr (",CVar,",sizeof(",SOF,"),0,",trim(str(dms)),",",ZZ,");");
            break;
          }
        IsPointer=0;
        strcpy(Var,Clean(Stk[2+IsVolatile]));
        ValidVar(Var);
        if(iMatchWrd(Stk[Ndx-1],"as"))
          {
            if(inchr(Stk[Ndx],"*"))
              {
                IsPointer=tally(Stk[Ndx],"*");
                strcpy(Stk[Ndx],RemoveStr(Stk[Ndx],"*"));
              }
            *DimType=0;
            for(i=3+IsVolatile; i<=Ndx-2; i+=1)
              {
                strcat(DimType,Stk[i]);
              }
            GetTypeInfo(Stk[Ndx], &w, &id, &vt);
          }
        else
          {
            *DimType=0;
            i=3+IsVolatile;
            while(i<=Ndx)
              {
                strcat(DimType,Stk[i]);
                i++;
              }
            vt=DataType(Stk[2+IsVolatile]);
            id=0;
          }
        if(vt==vt_STRVAR)
          {
            strcat(DimType,"[65535]");
          }
        if(IsShared)
          {
            if(IsVolatile)
              {
                AddGlobal(Var,vt,id,DimType,IsPointer,0,5,0);
              }
            else
              {
                AddGlobal(Var,vt,id,DimType,IsPointer,0,2,0);
              }
          }
        else
          {
            if(IsVolatile)
              {
                AddGlobal(Var,vt,id,DimType,IsPointer,0,3,0);
              }
            else
              {
                AddGlobal(Var,vt,id,DimType,IsPointer,0,0,0);
              }
          }
        break;
      }
    if(str_cmp(Lookup,"while")==0)
      {
        EmitIfCond("while");
        break;
      }
    if(str_cmp(Lookup,"wend")==0 ||  str_cmp(Lookup,"endwhile")==0)
      {
        BumpDown();
        fprintf(Outfile,"%s%s\n",Scoot,"}");
        BumpDown();
        break;
      }
    if(str_cmp(Lookup,"exit")==0)
      {
        if(CaseFlag)
          {
            NoBreak2=TRUE;
          }
        if(iMatchWrd(Stk[2],"sub"))
          {
            if(LocalDynaCnt!=0)
              {
                for(j=1; j<=LocalDynaCnt; j+=1)
                  {
                    fprintf(Outfile,"%s%s\n",Scoot,DynaStr[j]);
                  }
              }
            if(LocalDynArrCount!=0)
              {
                for(i=1; i<=LocalDynArrCount; i+=1)
                  {
                    fprintf(Outfile,"%s%s\n",Scoot,LocalDynArrName[i]);
                  }
              }
            fprintf(Outfile,"%s%s\n",Scoot,"return;");
            break;
          }
        if(iMatchWrd(Stk[2],"function"))
          {
            if(LocalDynaCnt!=0)
              {
                for(j=1; j<=LocalDynaCnt; j+=1)
                  {
                    fprintf(Outfile,"%s%s\n",Scoot,DynaStr[j]);
                  }
              }
            if(LocalDynArrCount!=0)
              {
                for(i=1; i<=LocalDynArrCount; i+=1)
                  {
                    fprintf(Outfile,"%s%s\n",Scoot,LocalDynArrName[i]);
                  }
              }
            fprintf(Outfile,"%s%s\n",Scoot,"return 0;");
          }
        else
          {
            fprintf(Outfile,"%s%s\n",Scoot,"break;");
          }
        break;
      }
    if(str_cmp(Lookup,"goto")==0)
      {
        if(CaseFlag)
          {
            NoBreak2=TRUE;
          }
        fprintf(Outfile,"%s%s%s%s\n",Scoot,"goto ",ucase(Stk[2]),";");
        break;
      }
    if(str_cmp(Lookup,"print")==0)
      {
        fprintf(Outfile,"%s%s\n",Scoot,PrintWriteFormat(0));
        break;
      }
    if(str_cmp(Lookup,"write")==0)
      {
        fprintf(Outfile,"%s%s\n",Scoot,PrintWriteFormat(1));
        break;
      }
    if(str_cmp(Lookup,"run")==0)
      {
        fprintf(Outfile,"%s%s",Scoot,"Run (");
        for(A=2; A<=Ndx; A+=1)
          {
            fprintf(Outfile,"%s",Clean(Stk[A]));
          }
        fprintf(Outfile,"%s%s\n",Scoot,");");
        break;
      }
    if(str_cmp(Lookup,"color")==0)
      {
        fprintf(Outfile,"%s%s",Scoot,"color (");
        for(A=2; A<=Ndx; A+=1)
          {
            fprintf(Outfile,"%s",Clean(Stk[A]));
          }
        fprintf(Outfile,"%s\n",");");
        break;
      }
    if(str_cmp(Lookup,"locate")==0)
      {
        fprintf(Outfile,"%s%s",Scoot,"locate (");
        for(A=2; A<=Ndx; A+=1)
          {
            fprintf(Outfile,"%s",Clean(Stk[A]));
          }
        fprintf(Outfile,"%s\n",");");
        break;
      }
    if(str_cmp(Lookup,"cls")==0)
      {
        fprintf(Outfile,"%s%s\n",Scoot,"cls();");
        break;
      }
      // case else
      {
        for(B=1; B<=Ndx; B+=1)
          {
            if(str_cmp(Stk[B],"=")==0)
              {
                break;
              }
          }
        if(B-1==Ndx)
          {
            *lszTmp=0;
            for(Tmp=1; Tmp<=Ndx; Tmp+=1)
              {
                strcat(lszTmp,Clean(Stk[Tmp]));
              }
            strcat(lszTmp,";");
            if(FuncRetnFlag==2)
              {
                fprintf(Outfile,"%s\n",lszTmp);
              }
            else
              {
                fprintf(Outfile,"%s%s\n",Scoot,lszTmp);
              }
            if(FuncRetnFlag==2)
              {
                FuncRetnFlag=0;
                *Stk[1]=0;
                if(ZZ)free(ZZ);
                return;
              }
            break;
          }
        for(i=2; i<=B-1; i+=1)
          {
            strcat(Stk[1],Stk[i]);
          }
        A=inchr(Stk[1],"*");
        if(A)
          {
            if(!(inchr(Stk[1],"$")&&A>1))
              {
                RemoveAll(Stk[1],"$");
                goto PROCESSNUMERIC;
              }
          }
        static int     strtest;
        memset(&strtest,0,sizeof(strtest));
        static int     varid;
        memset(&varid,0,sizeof(varid));
        static   struct _VarInfo*  vi;
        memset(&vi,0,sizeof(VarInfo *));
        static char vr[2048];
        memset(&vr,0,sizeof(vr));
        static int     brcnt;
        memset(&brcnt,0,sizeof(brcnt));
        strtest=DataType(Stk[1]);
        if(strtest==vt_INTEGER)
          {
            brcnt=tally(Stk[1],"[");
            strcpy(vr,extract(Stk[1],"["));
            strtest=CheckLocal(vr, &varid);
            if(strtest==vt_UNKNOWN)
              {
                strtest=CheckGlobal(vr, &varid);
                vi= &(GlobalVars[varid]);
              }
            else
              {
                vi= &(LocalVars[varid]);
              }
            if(strtest==vt_CHAR)
              {
                strtest=vt_STRVAR;
              }
            if(strtest==vt_STRVAR)
              {
                if(vi->VarPntr!=0)
                  {
                    goto PROCESSNUMERIC;
                  }
                if(tally(vi->VarDim,"[")==brcnt)
                  {
                    goto PROCESSNUMERIC;
                  }
                if(tally(vi->VarDim,"[")!=brcnt+1)
                  {
                    goto PROCESSNUMERIC;
                  }
              }
          }
        if(strtest==vt_STRVAR)
          {
            if(B+1==Ndx)
              {
                if(str_cmp(Stk[Ndx],DDQ)==0)
                  {
                    fprintf(Outfile,"%s%s%s%s\n",Scoot,"*",Clean(Stk[1]),"=0;");
                    goto STRINGEXIT;
                  }
              }
            if(Ndx==3)
              {
                strcpy(Stk[1],Clean(Stk[1]));
                strcpy(Stk[3],Clean(Stk[3]));
                if(str_cmp(Stk[1],"BCX_RetStr")==0)
                  {
                    fprintf(Outfile,"%s%s%s%s\n",Scoot,"BCX_RetStr=BCX_TmpStr(strlen(",Stk[3],"));");
                  }
                fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"strcpy(",Stk[1],",",Stk[3],");");
                goto STRINGEXIT;
              }
            *Arg=0;
            *lszTmp=0;
            j=k=0;
            if(iMatchLft(Stk[3],"$$"))
              {
                HasStorage=TRUE;
              }
            strcpy(Var,Clean(Stk[1]));
            if(str_cmp(Clean(Stk[B+1]),Var)==0)
              {
                k=TRUE;
              }
            for(A=B+1; A<=Ndx; A+=1)
              {
                if(str_cmp(Stk[A],"&")==0 &&  str_cmp(Stk[A-1],",")!=0 &&  str_cmp(Stk[A-1],"(")!=0)
                  {
                    j++;
                    strcat(Arg,lszTmp);
                    strcpy(lszTmp,",");
                  }
                else
                  {
                    strcat(lszTmp,Clean(Stk[A]));
                  }
              }
            if(*lszTmp!=0&&str_cmp(lszTmp,",")!=0)
              {
                strcat(Arg,lszTmp);
              }
            RemoveAll(Var,SPC);
            if(j==0)
              {
                if(str_cmp(Var,"BCX_RetStr")==0)
                  {
                    if(HasStorage)
                      {
                        fprintf(Outfile,"%s%s%s%s\n",Scoot,"BCX_RetStr=",Arg,";");
                        goto STRINGEXIT;
                      }
                    else
                      {
                        fprintf(Outfile,"%s%s%s%s\n",Scoot,"BCX_RetStr=BCX_TmpStr(strlen(",Arg,"));");
                      }
                  }
                fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"strcpy(",Var,",",Arg,");");
                goto STRINGEXIT;
              }
            if(k==TRUE&&j==1)
              {
                fprintf(Outfile,"%s%s%s%s\n",Scoot,"strcat(",Arg,");");
                goto STRINGEXIT;
              }
            strcpy(lszTmp,ltrim(str(++j)));
            Use_Join=TRUE;
            if(str_cmp(Var,"BCX_RetStr")==0)
              {
                fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"BCX_RetStr=join(",lszTmp,",",Arg,");");
              }
            else
              {
                fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"strcpy(",Var,", join(",lszTmp,",",Arg,"));");
              }

STRINGEXIT:;
            break;
          }
        else
          {

PROCESSNUMERIC:;
            for(i=2; i<=B; i+=1)
              {
                *Stk[i]=0;
              }
            strcpy(Stk[B],"=");
            if(str_cmp(Stk[B+1],Stk[1])==0 && Ndx==5)
              {
                if(Inset(Stk[B+2],"+-*/")&&str_cmp(Stk[B+3],">")!=0)
                  {
                    strcpy(Stk[B], join(2,Stk[B+2],Stk[B]));
                    *Stk[B+1]=0;
                    *Stk[B+2]=0;
                  }
              }
            fprintf(Outfile,"%s%s",Scoot,Clean(Stk[1]));
            for(A=2; A<=Ndx; A+=1)
              {
                if(str_cmp(Stk[A],"!")==0)
                  {
                    fprintf(Outfile,"%s","!");
                  }
                else
                  {
                    fprintf(Outfile,"%s",Clean(Stk[A]));
                  }
              }
            fprintf(Outfile,"%s\n",";");
          }
      }
    break;
  }
  if(FuncRetnFlag==1)
    {
      if(LocalDynaCnt!=0)
        {
          for(j=1; j<=LocalDynaCnt; j+=1)
            {
              fprintf(Outfile,"%s%s\n",Scoot,DynaStr[j]);
            }
        }
      fprintf(Outfile,"%s%s\n",Scoot,"return BCX_RetStr;");
    }
  if(ZZ)free(ZZ);
}


void Abort (char *Z)
{
  int     i=0;
  int     j=0;
  int     k=0;
  int     varnum=0;
  char t[2048];
  char frmt[2048];
  *WarnMsg=0;
  if(str_cmp(left(AbortSrc,11),"$BCXVERSION")==0)
    {
      strcat(WarnMsg,Z);
    }
  else
    {
      strcpy(WarnMsg, join(7,WarnMsg,Z," at line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx]),CRLF));
      strcpy(WarnMsg, join(3,WarnMsg,"Original line",CRLF));
      strcpy(WarnMsg, join(3,WarnMsg,AbortSrc,CRLF));
      strcpy(WarnMsg, join(3,WarnMsg,"==============",CRLF));
      strcpy(WarnMsg, join(3,WarnMsg,"Current Tokens",CRLF));
      strcpy(WarnMsg, join(3,WarnMsg,"==============",CRLF));
      for(k=1; k<=Ndx; k+=1)
        {
          j=strlen(Stk[k]);
          if(j<40)
            {
              j=40-j;
            }
          else
            {
              j=8-imod(j,8);
            }
          strcpy(frmt,lpad(str(k),3));
          strcpy(WarnMsg, join(6,WarnMsg,frmt," ",Stk[k],stringx(j,32),CRLF));
          strcpy(t,Clean(Stk[k]));
          i=CheckLocal(t, &varnum);
          if(i!=vt_UNKNOWN)
            {
              strcpy(WarnMsg, join(3,WarnMsg,"is a LOCAL defined at line",str(LocalVars[varnum].VarLine)));
              strcpy(WarnMsg, join(4,WarnMsg," in Module: ",LocalVars[varnum].VarModule,CRLF));
            }
          else
            {
              i=CheckGlobal(t, &varnum);
              if(i!=vt_UNKNOWN)
                {
                  strcpy(WarnMsg, join(3,WarnMsg,"is a GLOBAL defined at line",str(GlobalVars[varnum].VarLine)));
                  strcpy(WarnMsg, join(4,WarnMsg," in Module: ",GlobalVars[varnum].VarModule,CRLF));
                  strcpy(WarnMsg, join(5,WarnMsg," ",Stk[k],GlobalVars[varnum].VarDim," as "));
                  if(GlobalVars[varnum].VarDef)
                    {
                      strcpy(WarnMsg, join(3,WarnMsg,trim(TypeDefs[GlobalVars[varnum].VarDef].VarName),CRLF));
                    }
                  else
                    {
                      strcpy(WarnMsg, join(3,WarnMsg,trim(GetVarTypeName(GlobalVars[varnum].VarType)),CRLF));
                    }
                }
              else
                {
                  if(Stk[k][0]==34)
                    {
                      strcpy(WarnMsg, join(3,WarnMsg,"is a STRING LITERAL",CRLF));
                    }
                }
            }
        }
      strcpy(WarnMsg, join(3,WarnMsg,"===============",CRLF));
      strcpy(WarnMsg, join(3,WarnMsg,"Original Tokens",CRLF));
      strcpy(WarnMsg, join(3,WarnMsg,"===============",CRLF));
      XParse(AbortSrc);
      for(k=1; k<=Ndx; k+=1)
        {
          j=strlen(Stk[k]);
          if(j<40)
            {
              j=40-j;
            }
          else
            {
              j=8-imod(j,8);
            }
          strcpy(frmt,lpad(str(k),3));
          strcpy(WarnMsg, join(6,WarnMsg,frmt," ",Stk[k],stringx(j,32),CRLF));
          strcpy(t,Clean(Stk[k]));
          i=CheckLocal(t, &varnum);
          if(i!=vt_UNKNOWN)
            {
              strcpy(WarnMsg, join(3,WarnMsg,"is a LOCAL defined at line",str(LocalVars[varnum].VarLine)));
              strcpy(WarnMsg, join(4,WarnMsg," in Module: ",LocalVars[varnum].VarModule,CRLF));
            }
          else
            {
              i=CheckGlobal(t, &varnum);
              if(i!=vt_UNKNOWN)
                {
                  strcpy(WarnMsg, join(3,WarnMsg,"is a GLOBAL defined at line",str(GlobalVars[varnum].VarLine)));
                  strcpy(WarnMsg, join(4,WarnMsg," in Module: ",GlobalVars[varnum].VarModule,CRLF));
                  strcpy(WarnMsg, join(5,WarnMsg," ",Stk[k],GlobalVars[varnum].VarDim," as "));
                  if(GlobalVars[varnum].VarDef)
                    {
                      strcpy(WarnMsg, join(3,WarnMsg,TypeDefs[GlobalVars[varnum].VarDef].VarName,CRLF));
                    }
                  else
                    {
                      strcpy(WarnMsg, join(3,WarnMsg,GetVarTypeName(GlobalVars[varnum].VarType),CRLF));
                    }
                }
              else
                {
                  if(Stk[k][0]==34)
                    {
                      strcpy(WarnMsg, join(3,WarnMsg,"is a string literal",CRLF));
                    }
                }
            }
        }
    }
  strcat(WarnMsg,CRLF);
  CloseAll();
  remove (ovrFile);
  remove (FileOut);
  remove (prcFile);
  remove (udtFile);
  remove (hdrFile);
  remove (cstFile);
  remove (datFile);
  remove (setFile);
  remove (enuFile);
  remove ("$t$e$m$p");
  if(ErrFile)
    {
      if((fpErr=fopen(FileErr,"a"))==0)
       {
         fprintf(stderr,"Can't open file %s\n",FileErr);
         exit(1);
       }
      fprintf(fpErr,"%s%s%d%s%s\n",Z," at line",(int)ModuleLineNos[ModuleNdx]," in Module: ",trim(Modules[ModuleNdx]));
      if(fpErr)
       {
         fclose(fpErr);
         fpErr=NULL;
       }
    }
  printf("%s%s%s%s%s\n","Error!",CRLF,FileIn,CRLF,WarnMsg);
  FreeGlobals();
  fflush(stdout);
  exit(1);
}


void BumpDown (void)
{
  Indent--;
  Indent--;
  if(Indent<0)
    {
      Indent=0;
    }
  strcpy(Scoot,space(Indent));
}


void BumpUp (void)
{
  if(Indent<0)
    {
      Indent=0;
    }
  Indent++;
  Indent++;
  strcpy(Scoot,space(Indent));
}


int BraceCount (char *Arg)
{
   char*  p;
  int     braces;
  p=Arg;
  braces=0;
  while(*p)
    {
      if(*p==c_DblQt)
        {
          p++;
          while(*p!=c_DblQt)
            {
              if(*p==0)
                {
                  return braces;
                }
              p++;
            }
        }
      if(*p==125)
        {
          braces--;
        }
      if(*p==123)
        {
          braces++;
        }
      p++;
    }
  return braces;
}


char* BracketHandler (char *Src, int l)
{
   char*  s;
  s=Src;
  for(;;)
  {
    if(l==0)
      {
        for(;;)
          {
            if(*s==0)
              {
                break;
              }
            if(*s==c_DblQt)
              {
                s++;
                while(*s!=c_DblQt)
                  {
                    if(*s==0)
                      {
                        break;
                      }
                    s++;
                  }
              }
            if(*s==c_LtBkt)
              {
                s++;
                s=BracketHandler(s,1);
              }
            if(*s==c_LPar)
              {
                s++;
                s=BracketHandler(s,2);
              }
            s++;
          }
        break;
      }
    if(l==1)
      {
        while(*s!=c_RtBkt)
          {
            if(*s==c_DblQt)
              {
                s++;
                while(*s!=c_DblQt)
                  {
                    if(*s==0)
                      {
                        break;
                      }
                    s++;
                  }
              }
            if(*s==c_LtBkt)
              {
                s++;
                s=BracketHandler(s,1);
              }
            if(*s==c_LPar)
              {
                s++;
                s=BracketHandler(s,2);
              }
            if(*s==c_Komma)
              {
                *s=1;
              }
            if(*s==0)
              {
                break;
              }
            s++;
          }
        break;
      }
    if(l==2)
      {
        while(*s!=c_RPar)
          {
            if(*s==c_DblQt)
              {
                s++;
                while(*s!=c_DblQt)
                  {
                    if(*s==0)
                      {
                        break;
                      }
                    s++;
                  }
              }
            if(*s==c_LtBkt)
              {
                s++;
                s=BracketHandler(s,1);
              }
            if(*s==c_LPar)
              {
                s++;
                s=BracketHandler(s,2);
              }
            if(*s==0)
              {
                break;
              }
            s++;
          }
      }
    break;
  }
  if(l==0)
    {
      strcpy(Src,replace(Src,chr(1),"]["));
      return Src;
    }
  return s;
}


void Push (char *Z)
{
  strcpy(CaseStk[++Pusher],Z);
}


void Pop (char *Z)
{
  strcpy(Z,CaseStk[--Pusher]);
}


void EmitEpilog (void)
{
  if(NoMain+EndOfProgram==0)
    {
      fprintf(Outfile,"%s\n","return 0;   //  End of main program");
      BumpDown();
      fprintf(Outfile,"%s\n","}");
      fflush(Outfile);
    }
}


void EmitProlog (void)
{
  fprintf(Outfile,"%s\n","");
  fprintf(Outfile,"%s\n","int main(int argc, char *argv[])");
  fflush(Outfile);
}


void DeclareVariables (void)
{
  int     i;
  int     A;
  char P[2048];
  char VarName[2048];
  char VarDim[2048];
  char Storage[2048];
  if((FP1=fopen(FileOut,"r"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",FileOut);
     exit(1);
   }
  if((Outfile=fopen("$t$e$m$p","w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n","$t$e$m$p");
     exit(1);
   }
  if((FP3=fopen(cstFile,"r"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",cstFile);
     exit(1);
   }
  if(lof(cstFile)>0)
    {
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s%s\n","//            ",BCX_STR_USR_CONST);
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","");
    }
  while(!EoF(FP3))
    {
      Z[0]=0;
      AR_fgets_retval=fgets(Z,65535,FP3);
      if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
      fprintf(Outfile,"%s\n",ltrim(Z));
    }
  if(FP3)
   {
     fclose(FP3);
     FP3=NULL;
   }
  if(Use_EnumFile)
    {
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","//        User's GLOBAL ENUM blocks");
      fprintf(Outfile,"%s\n","// *************************************************");
      if((FP8=fopen(enuFile,"r"))==0)
       {
         fprintf(stderr,"Can't open file %s\n",enuFile);
         exit(1);
       }
      while(!EoF(FP8))
        {
          Z[0]=0;
          AR_fgets_retval=fgets(Z,65535,FP8);
          if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
          fprintf(Outfile,"%s\n",Z);
        }
      if(FP8)
       {
         fclose(FP8);
         FP8=NULL;
       }
      fprintf(Outfile,"%s\n","");
    }
  if((FP3=fopen(udtFile,"r"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",udtFile);
     exit(1);
   }
  if(lof(udtFile)>0)
    {
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s%s\n","//   ",BCX_STR_USR_TYPES);
      fprintf(Outfile,"%s\n","// *************************************************");
      while(!EoF(FP3))
        {
          Z[0]=0;
          AR_fgets_retval=fgets(Z,65535,FP3);
          if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
          fprintf(Outfile,"%s%s\n",Scoot,Z);
        }
    }
  if(FP3)
   {
     fclose(FP3);
     FP3=NULL;
   }
  if(HFileCnt>0)
    {
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","//                User Include Files");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","");
      A=0;
      while(A<HFileCnt)
        {
          fprintf(Outfile,"%s\n",HFiles[A]);
          A++;
        }
      fprintf(Outfile,"%s\n","#include <term.h>");
    }
  if(Use_SingleFile==TRUE)
    {
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s%s\n","//                ",BCX_STR_SYS_VARS);
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","");
      if(Use_RegEx)
        {
          fprintf(Outfile,"%s\n","typedef struct _REGEX");
          fprintf(Outfile,"%s\n","{");
          fprintf(Outfile,"%s\n","   int         count;");
          fprintf(Outfile,"%s\n","   regmatch_t  matches[1024];");
          fprintf(Outfile,"%s\n","   PCHAR       results[1024];");
          fprintf(Outfile,"%s\n","}REGEX, *LPREGEX;\n");
        }
      if(Use_Time)
        {
          fprintf(Outfile,"%s\n","enum TIME_OPTIONS");
          fprintf(Outfile,"%s\n","{");
          fprintf(Outfile,"%s\n","  TIME,");
          fprintf(Outfile,"%s\n","  HOUR,");
          fprintf(Outfile,"%s\n","  MINUTE,");
          fprintf(Outfile,"%s\n","  SECOND,");
          fprintf(Outfile,"%s\n","  APM,");
          fprintf(Outfile,"%s\n","  YEAR,");
          fprintf(Outfile,"%s\n","  MONTH,");
          fprintf(Outfile,"%s\n","  DAY,");
          fprintf(Outfile,"%s\n","  DAYNAME,");
          fprintf(Outfile,"%s\n","  WEEKDAY,");
          fprintf(Outfile,"%s\n","  YEARDAY,");
          fprintf(Outfile,"%s\n","  WEEKNUMBER,");
          fprintf(Outfile,"%s\n","  DATE,");
          fprintf(Outfile,"%s\n","  FULLDATE");
          fprintf(Outfile,"%s\n"," };\n");
        }
      if(Use_Findfirst||Use_Findnext)
        {
          fprintf(Outfile,"%s\n","typedef struct _FILE_FIND_DATA");
          fprintf(Outfile,"%s\n","{");
          fprintf(Outfile,"%s\n","  DWORD  dwFileAttributes;");
          fprintf(Outfile,"%s\n","  DWORD  ftCreationTime;");
          fprintf(Outfile,"%s\n","  DWORD  ftLastAccessTime;");
          fprintf(Outfile,"%s\n","  DWORD  ftLastWriteTime;");
          fprintf(Outfile,"%s\n","  DWORD  nFileSizeHigh;");
          fprintf(Outfile,"%s\n","  DWORD  nFileSizeLow;");
          fprintf(Outfile,"%s\n","  char   cFileSpec[MAX_PATH];");
          fprintf(Outfile,"%s\n","  char   cFileName[MAX_PATH];");
          fprintf(Outfile,"%s\n","  char   path[MAX_PATH];");
          fprintf(Outfile,"%s\n","  DIR   *FileHandle;");
          fprintf(Outfile,"%s\n","}FILE_FIND_DATA, *LPFILE_FIND_DATA;\n");
        }
      if(Use_Ldouble)
        {
          fprintf(Outfile,"%s\n","#define LDOUBLE long double");
        }
      if(Use_Idxqsort)
        {
          fprintf(Outfile,"%s\n","char*** pppStr;");
        }
      if(Use_Idxqsort||Use_IdxqsortSt||Use_PtrqsortSt)
        {
          fprintf(Outfile,"%s\n","int     Key;");
        }
      if(Use_IdxqsortSt)
        {
          fprintf(Outfile,"%s\n","char*   cmp1;");
          fprintf(Outfile,"%s\n","int     StructSize;");
        }
      if(Use_PtrqsortSt)
        {
          fprintf(Outfile,"%s\n","int     OffSet;");
        }
      if(Use_NUL)
        {
          fprintf(Outfile,"%s\n","char    NUL [1]={0};     // Null");
        }
      if(Use_BEL)
        {
          fprintf(Outfile,"%s\n","char    BEL [2]={7,0};   // Bell");
        }
      if(Use_BS)
        {
          fprintf(Outfile,"%s\n","char    BS  [2]={8,0};   // Back Space");
        }
      if(Use_TAB)
        {
          fprintf(Outfile,"%s\n","char    TAB [2]={9,0};   // Horz Tab");
        }
      if(Use_LF)
        {
          fprintf(Outfile,"%s\n","char    LF  [2]={10,0};  // Line Feed");
        }
      if(Use_VT)
        {
          fprintf(Outfile,"%s\n","char    VT  [2]={11,0};  // Vert Tab");
        }
      if(Use_FF)
        {
          fprintf(Outfile,"%s\n","char    FF  [2]={12,0};  // Form Feed");
        }
      if(Use_CR)
        {
          fprintf(Outfile,"%s\n","char    CR  [2]={13,0};  // Carr Rtn");
        }
      if(Use_EOF)
        {
          fprintf(Outfile,"%s\n","char    EF  [2]={26,0};  // End-of-File");
        }
      if(Use_ESC)
        {
          fprintf(Outfile,"%s\n","char    ESC [2]={27,0};  // Escape");
        }
      if(Use_SPC)
        {
          fprintf(Outfile,"%s\n","char    SPC [2]={32,0};  // Space");
        }
      if(Use_DQ)
        {
          fprintf(Outfile,"%s\n","char    DQ  [2]={34,0};  // Double-Quote");
        }
      if(Use_DDQ)
        {
          fprintf(Outfile,"%s\n","char    DDQ [3]={34,34,0}; // Double-Double-Quote");
        }
      if(Use_Crlf)
        {
          fprintf(Outfile,"%s\n","char    CRLF[3]={13,10,0}; // Carr Rtn & Line Feed");
        }
      if(Use_Console)
        {
          fprintf(Outfile,"%s\n","int     color_fg = 7;");
          fprintf(Outfile,"%s\n","int     color_bg = 0;");
        }
      if(Use_Lineinput)
        {
          fprintf(Outfile,"%s\n","char    *AR_fgets_retval;");
        }
      if(Use_Scan)
        {
          fprintf(Outfile,"%s\n","int     ScanError;");
        }
      if(Use_Inputbuffer==TRUE)
        {
          fprintf(Outfile,"%s\n","char    InputBuffer[65535];");
        }
      if(Use_Findfirst||Use_Findnext)
        {
          fprintf(Outfile,"%s\n","FILE_FIND_DATA FindData;");
        }
      if(Use_Gosub)
        {
          fprintf(Outfile,"%s\n","jmp_buf GosubStack[32];");
          fprintf(Outfile,"%s\n","int     GosubNdx;");
        }
      if(Use_Dynacall)
        {
          fprintf(Outfile,"%s\n","HINSTANCE BCX_DllStore[256];");
        }
    }
  if(GlobalVarCnt)
    {
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s%s\n","//            ",BCX_STR_USR_VARS);
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","");
    }
  for(i=1; i<=GlobalVarCnt; i+=1)
    {
      if(GlobalVars[i].VarEmitFlag)
        {
          continue;
        }
      if(str_cmp("",GlobalVars[i].VarDim)==0 && GlobalVars[i].VarCondLevel==0)
        {
          *P=0;
          if(GlobalVars[i].VarPntr)
            {
              strcpy(P,stringx(GlobalVars[i].VarPntr,42));
            }
          A=GlobalVars[i].VarType;
          if(GlobalVars[i].VarSF)
            {
              strcpy(VarName, join(3,"(*",GlobalVars[i].VarName,")"));
            }
          else
            {
              strcpy(VarName,GlobalVars[i].VarName);
            }
          strcpy(Storage, join(2,VarStorage[GlobalVars[i].VarExtn],VarConst[GlobalVars[i].VarConstant]));
          strcpy(VarDim,GlobalVars[i].VarDim);
          PrintGlobal(A,i,Storage,P,VarName,VarDim);
        }
    }
  for(i=1; i<=GlobalVarCnt; i+=1)
    {
      if(GlobalVars[i].VarEmitFlag)
        {
          continue;
        }
      if(str_cmp("",GlobalVars[i].VarDim)!=0 && GlobalVars[i].VarCondLevel==0)
        {
          if(instr_b(GlobalVars[i].VarDim,"{")==0)
            {
              *P=0;
              if(GlobalVars[i].VarPntr)
                {
                  strcpy(P,stringx(GlobalVars[i].VarPntr,42));
                }
              A=GlobalVars[i].VarType;
              if(GlobalVars[i].VarSF)
                {
                  strcpy(VarName, join(4,"(*",GlobalVars[i].VarName,extract(GlobalVars[i].VarDim,"("),")"));
                  strcpy(VarDim,mid(GlobalVars[i].VarDim,instr_b(GlobalVars[i].VarDim,"(")));
                }
              else
                {
                  strcpy(VarName,GlobalVars[i].VarName);
                  strcpy(VarDim,GlobalVars[i].VarDim);
                }
              strcpy(Storage, join(2,VarStorage[GlobalVars[i].VarExtn],VarConst[GlobalVars[i].VarConstant]));
              PrintGlobal(A,i,Storage,P,VarName,VarDim);
            }
        }
    }
  char LastDef[2048];
  int     LastLevel;
  *LastDef=0;
  LastLevel=1;
  for(i=1; i<=GlobalVarCnt; i+=1)
    {
      if(GlobalVars[i].VarEmitFlag)
        {
          continue;
        }
      if(GlobalVars[i].VarCondLevel)
        {
          if(LastDef[0]==0)
            {
              strcpy(LastDef,GlobalVars[i].VarCondDef);
              LastLevel=GlobalVars[i].VarCondLevel;
              fprintf(Outfile,"%s\n",LastDef);
            }
          if(str_cmp(LastDef,GlobalVars[i].VarCondDef)!=0)
            {
              if(str_cmp(GlobalVars[i].VarCondDef,"#else")==0)
                {
                  while(LastLevel>GlobalVars[i].VarCondLevel)
                    {
                      fprintf(Outfile,"%s\n","#endif");
                      LastLevel--;
                    }
                  fprintf(Outfile,"%s\n","#else");
                  strcpy(LastDef,GlobalVars[i].VarCondDef);
                }
              else
                {
                  while(LastLevel>=GlobalVars[i].VarCondLevel)
                    {
                      fprintf(Outfile,"%s\n","#endif");
                      LastLevel--;
                    }
                  strcpy(LastDef,GlobalVars[i].VarCondDef);
                  LastLevel=GlobalVars[i].VarCondLevel;
                  fprintf(Outfile,"%s\n",LastDef);
                }
            }
          *P=0;
          if(GlobalVars[i].VarPntr)
            {
              strcpy(P,stringx(GlobalVars[i].VarPntr,42));
            }
          A=GlobalVars[i].VarType;
          if(GlobalVars[i].VarSF)
            {
              strcpy(VarName, join(3,"(*",GlobalVars[i].VarName,")"));
            }
          else
            {
              strcpy(VarName,GlobalVars[i].VarName);
            }
          strcpy(VarDim,GlobalVars[i].VarDim);
          strcpy(Storage, join(2,VarStorage[GlobalVars[i].VarExtn],VarConst[GlobalVars[i].VarConstant]));
          PrintGlobal(A,i,Storage,P,VarName,VarDim);
        }
    }
  if(*LastDef)
    {
      while(LastLevel)
        {
          fprintf(Outfile,"%s\n","#endif");
          LastLevel--;
        }
    }
  fprintf(Outfile,"%s\n","");
  if(DllCnt)
    {
      int     i;
      char AR_DllName[2048];
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// **********[ DLL Declarations ]**********");
      fprintf(Outfile,"%s\n","");
      for(i=0; i<=LoadLibsCnt-1; i+=1)
        {
          if(inchr(Loadlibs[i],"-"))
            {
              strcpy(AR_DllName,extract(Loadlibs[i],"-"));
            }
          else if(inchr(Loadlibs[i],"."))
            {
              strcpy(AR_DllName,extract(Loadlibs[i],"."));
            }
          fprintf(Outfile,"%s%s%s%s%s\n","void  *H_",ucase(AR_DllName)," = dlopen(",enc(Loadlibs[i]),", RTLD_LAZY);");
        }
      for(i=1; i<=DllCnt; i+=1)
        {
          fprintf(Outfile,"%s\n",DllDecl[i]);
        }
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// ****************************************");
      fprintf(Outfile,"%s\n","");
    }
  if((FP5=fopen(datFile,"r"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",datFile);
     exit(1);
   }
  if(lof(datFile)>0)
    {
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","//              User Data Statements");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","char * DATA [] =");
      fprintf(Outfile,"%s\n","{");
      while(!EoF(FP5))
        {
          Z[0]=0;
          AR_fgets_retval=fgets(Z,65535,FP5);
          if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
          fprintf(Outfile,"%s\n",Z);
        }
      fprintf(Outfile,"%s\n","};");
    }
  if(FP5)
   {
     fclose(FP5);
     FP5=NULL;
   }
  while(!EoF(FP1))
    {
      Z[0]=0;
      AR_fgets_retval=fgets(Z,65535,FP1);
      if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
      fprintf(Outfile,"%s\n",Z);
    }
  CloseAll();
  remove (FileOut);
  rename ("$t$e$m$p",FileOut);
}


int GetNumArgs (int Strt,int* NdxPos)
{
  int     CountR=0;
  int     CountS=0;
  int     i;
  int     j=0;
  int     k=1;
  for(i=Strt; i<=Ndx; i+=1)
    {
      if(str_cmp(Stk[i],"(")==0)
        {
          CountR++;
          k++;
        }
      else if(str_cmp(Stk[i],")")==0)
        {
          CountR--;
          k--;
          if(k==0)
            {
              break;
            }
        }
      else if(str_cmp(Stk[i],"[")==0)
        {
          CountS++;
        }
      else if(str_cmp(Stk[i],"]")==0)
        {
          CountS--;
        }
      else if(str_cmp(Stk[i],",")==0 && CountR==0&&CountS==0)
        {
          j++;
          if(NdxPos)
            {
              *NdxPos=i;
            }
        }
    }
  return j;
}


void GetVarCode (VARCODE* varcode)
{
  char CB[2048];
  char PT[2048];
  char PTH[2048];
  char VAR[2048];
  int     vn;
  char RF[2048];
  if(varcode->Method==mt_Opts3)
    {
      strcat(varcode->Proto,varcode->Token);
      if(str_cmp(varcode->Token,",")==0)
        {
          strcat(varcode->Header,varcode->Token);
        }
      return;
    }
  if(varcode->Method==mt_FuncSubx1)
    {
      strcpy(varcode->Proto, join(3,varcode->Proto,varcode->AsToken,"(*)("));
      strcpy(varcode->Header, join(5,varcode->Header,varcode->AsToken," (*",varcode->Token,")("));
      return;
    }
  if(varcode->Method==mt_FuncSubx2)
    {
      strcat(varcode->Proto,varcode->AsToken);
      strcpy(varcode->Header, join(4,varcode->Header,varcode->AsToken," ",varcode->Token));
      return;
    }
  if(IsCallBack)
    {
      strcpy(CB,"CALLBACK ");
    }
  else
    {
      *CB=0;
    }
  if(inchr(varcode->Token,"*")||inchr(varcode->AsToken,"*")||varcode->IsPtrFlag)
    {
      RemoveAll(varcode->Token,"*");
      RemoveAll(varcode->AsToken,"*");
      strcpy(PT, join(2,stringx(varcode->IsPtrFlag,42)," "));
      strcpy(PTH,PT);
    }
  else
    {
      strcpy(PTH," ");
      *PT=0;
    }
  if(inchr(varcode->Token,"&"))
    {
      strcpy(RF," &");
    }
  else
    {
      *RF=0;
    }
  vn=varcode->VarNo;
  strcpy(VAR,GetVarTypeName(vn));
  for(;;)
  {
    if(vn==vt_STRVAR)
      {
        for(;;)
        {
          if(varcode->Method==mt_ProcessSetCommand)
            {
              strcpy(varcode->StaticOut, join(2,"static char   ",Clean(varcode->Token)));
              break;
            }
          if(varcode->Method==mt_FuncSubDecC_Dec)
            {
              strcpy(varcode->Functype, join(2,"char * ",CB));
              break;
            }
          if(varcode->Method==mt_FuncSubDecC_Dec2)
            {
              if(!inchr(varcode->Token,"["))
                {
                  strcpy(varcode->Header, join(4,varcode->Header,"char *",Clean(varcode->Token),", "));
                  strcat(varcode->Proto,"char *, ");
                }
              else
                {
                  strcpy(varcode->Header, join(4,varcode->Header,"char ",RemoveStr(Clean(varcode->Token),"*"),", "));
                  strcat(varcode->Proto,"char [][65535], ");
                }
              break;
            }
          if(varcode->Method==mt_Opts)
            {
              strcpy(varcode->Functype,"char *");
              break;
            }
          if(varcode->Method==mt_Opts2)
            {
              strcpy(varcode->Header, join(3,varcode->Header,"char * ",Clean(varcode->Token)));
              strcat(varcode->Proto,"char* ");
              break;
            }
          if(varcode->Method==mt_OverLoad)
            {
              strcpy(varcode->Functype,"char *");
              break;
            }
          if(varcode->Method==mt_OverLoad2)
            {
              strcpy(varcode->Header, join(4,varcode->Header,"char *",Clean(varcode->Token),", "));
            }
          break;
        }
        break;
      }
    if(vn==vt_BOOL||vn==vt_BYTE||vn==vt_COLORREF||vn==vt_DOUBLE||vn==vt_DWORD||vn==vt_FARPROC||vn==vt_HDC||vn==vt_HANDLE||vn==vt_HINSTANCE||vn==vt_HWND||vn==vt_INTEGER||vn==vt_LONG||vn==vt_LPBYTE||vn==vt_LRESULT||vn==vt_SHORT||vn==vt_SINGLE||vn==vt_UINT||vn==vt_ULONG||vn==vt_USHORT||vn==vt_VARIANT||vn==vt_VOID||vn==vt_LDOUBLE)
      {
        for(;;)
        {
          if(varcode->Method==mt_ProcessSetCommand)
            {
              strcpy(varcode->StaticOut, join(4,"static ",VAR," ",Clean(varcode->Token)));
              break;
            }
          if(varcode->Method==mt_FuncSubDecC_Dec)
            {
              strcpy(varcode->Functype, join(3,VAR,PTH,CB));
              break;
            }
          if(varcode->Method==mt_FuncSubDecC_Dec2)
            {
              strcpy(varcode->Header, join(5,varcode->Header,VAR,PTH,Clean(varcode->Token),", "));
              strcpy(varcode->Proto, join(5,varcode->Proto,VAR,RF,PT,", "));
              break;
            }
          if(varcode->Method==mt_Opts)
            {
              strcpy(varcode->Functype, join(2,VAR,PTH));
              break;
            }
          if(varcode->Method==mt_Opts2)
            {
              strcpy(varcode->Header, join(4,varcode->Header,VAR,PTH,Clean(varcode->Token)));
              strcpy(varcode->Proto, join(4,varcode->Proto,VAR,RF,PT));
              break;
            }
          if(varcode->Method==mt_OverLoad)
            {
              strcpy(varcode->Functype, join(2,VAR," "));
              break;
            }
          if(varcode->Method==mt_OverLoad2)
            {
              strcpy(varcode->Header, join(5,varcode->Header,VAR,PTH,Clean(varcode->Token),", "));
            }
          break;
        }
        break;
      }
    if(vn==vt_FILEPTR||vn==vt_CHAR)
      {
        for(;;)
        {
          if(varcode->Method==mt_FuncSubDecC_Dec)
            {
              strcpy(varcode->Functype, join(3,VAR,PTH,CB));
              break;
            }
          if(varcode->Method==mt_FuncSubDecC_Dec2)
            {
              strcpy(varcode->Header, join(5,varcode->Header,VAR,PTH,Clean(varcode->Token),", "));
              strcpy(varcode->Proto, join(4,varcode->Proto,VAR,PT,", "));
              break;
            }
          if(varcode->Method==mt_Opts)
            {
              strcpy(varcode->Functype, join(2,VAR,PTH));
              break;
            }
          if(varcode->Method==mt_Opts2)
            {
              strcpy(varcode->Header, join(4,varcode->Header,VAR,PTH,Clean(varcode->Token)));
              strcpy(varcode->Proto, join(3,varcode->Proto,VAR,PT));
              break;
            }
          if(varcode->Method==mt_OverLoad)
            {
              strcpy(varcode->Functype, join(2,VAR," "));
              break;
            }
          if(varcode->Method==mt_OverLoad2)
            {
              strcpy(varcode->Header, join(5,varcode->Header,VAR,PTH,Clean(varcode->Token),", "));
            }
          break;
        }
        break;
      }
    if(vn==vt_UDT||vn==vt_STRUCT||vn==vt_UNION)
      {
        for(;;)
        {
          if(varcode->Method==mt_ProcessSetCommand)
            {
              if(vn==vt_UNION)
                {
                  strcpy(varcode->StaticOut, join(2,"static union  ",Clean(varcode->Token)));
                }
              else
                {
                  strcpy(varcode->StaticOut, join(3,"static struct _",Clean(varcode->Token)," "));
                }
              break;
            }
          if(varcode->Method==mt_FuncSubDecC_Dec)
            {
              strcpy(varcode->Functype, join(3,varcode->AsToken,PTH,CB));
              break;
            }
          if(varcode->Method==mt_FuncSubDecC_Dec2)
            {
              strcpy(varcode->Header, join(5,varcode->Header,varcode->AsToken,PTH,Clean(varcode->Token),", "));
              strcpy(varcode->Proto, join(5,varcode->Proto,varcode->AsToken,RF,PT,", "));
              break;
            }
          if(varcode->Method==mt_Opts)
            {
              strcpy(varcode->Functype, join(2,varcode->AsToken,PTH));
              break;
            }
          if(varcode->Method==mt_Opts2)
            {
              strcpy(varcode->Header, join(5,varcode->Header,Clean(varcode->AsToken),PTH," ",Clean(varcode->Token)));
              strcpy(varcode->Proto, join(4,varcode->Proto,Clean(varcode->AsToken),RF,PT));
              break;
            }
          if(varcode->Method==mt_OverLoad)
            {
              strcpy(varcode->Functype, join(2,VAR," "));
              break;
            }
          if(varcode->Method==mt_OverLoad2)
            {
              strcpy(varcode->Header, join(5,varcode->Header,varcode->AsToken,PTH,Clean(varcode->Token),", "));
            }
          break;
        }
        break;
      }
      // case else
      {
        for(;;)
        {
          if(varcode->Method==mt_FuncSubDecC_Dec)
            {
              strcpy(varcode->Functype, join(3,varcode->AsToken,PTH,CB));
              break;
            }
          if(varcode->Method==mt_FuncSubDecC_Dec2)
            {
              strcpy(varcode->Header, join(5,varcode->Header,varcode->AsToken,PTH,Clean(varcode->Token),", "));
              strcpy(varcode->Proto, join(5,varcode->Proto,varcode->AsToken,RF,PT,", "));
              break;
            }
          if(varcode->Method==mt_Opts)
            {
              strcpy(varcode->Functype, join(2,varcode->AsToken,PTH));
              break;
            }
          if(varcode->Method==mt_Opts2)
            {
              strcpy(varcode->Header, join(4,varcode->Header,Clean(varcode->AsToken)," ",Clean(varcode->Token)));
              strcat(varcode->Proto,Clean(varcode->AsToken));
            }
          break;
        }
      }
    break;
  }
}


void AddProtos (void)
{
  char SaveMain[2048];
  char *ZZ;
  ZZ=(char*)calloc(256+65535,1);
  int     A;
  *SaveMain=0;
  if((FP1=fopen(FileOut,"r"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",FileOut);
     exit(1);
   }
  if((Outfile=fopen("$t$e$m$p","w"))==0)
   {
     fprintf(stderr,"Can't open file %s\n","$t$e$m$p");
     exit(1);
   }
  while(!EoF(FP1))
    {
      ZZ[0]=0;
      AR_fgets_retval=fgets(ZZ,65535,FP1);
      if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
      if(instr_b(ZZ,"int main"))
        {
          strcpy(SaveMain,ZZ);
          break;
        }
      fprintf(Outfile,"%s\n",ZZ);
    }
  fprintf(Outfile,"%s\n","");
  fprintf(Outfile,"%s\n","// *************************************************");
  fprintf(Outfile,"%s%s\n","//               ",BCX_STR_STD_MACROS);
  fprintf(Outfile,"%s\n","// *************************************************");
  fprintf(Outfile,"%s\n","");
  if(Use_BcxSplitPath)
    {
      fprintf(Outfile,"%s\n","#define FDRV   2");
      fprintf(Outfile,"%s\n","#define FPATH  4");
      fprintf(Outfile,"%s\n","#define FNAME  8");
      fprintf(Outfile,"%s\n","#define FEXT  16");
    }
  if(Use_Cbool)
    {
      fprintf(Outfile,"%s\n","#define CBOOL(A)(A!=0)?1:0");
    }
  if(Use_Isptr)
    {
      fprintf(Outfile,"%s\n","#define IsPtr(a)((DWORD)a)");
    }
  if(Use_Band)
    {
      fprintf(Outfile,"%s\n","#define BAND &");
    }
  if(Use_Bor)
    {
      fprintf(Outfile,"%s\n","#define BOR |");
    }
  if(Use_Bnot)
    {
      fprintf(Outfile,"%s\n","#define BNOT ~(int)");
    }
  if(Use_Ubound)
    {
      fprintf(Outfile,"%s\n","#define ubound(T)(sizeof((T))/sizeof((T[0]))-1)");
    }
  if(Use_Clear)
    {
      fprintf(Outfile,"%s\n","#define Clear(arg)memset(&arg,0,sizeof(arg))");
    }
  if(Use_Imod)
    {
      fprintf(Outfile,"%s\n","#define imod(a,b)((a)%(b))");
    }
  if(Use_Get)
    {
      fprintf(Outfile,"%s\n","#define GET(A,B,C) F_GetVal=fread(B,1,C,A)");
      AddGlobal("F_GetVal",vt_INTEGER,0,"",0,0,0,0);
    }
  if(Use_Put)
    {
      fprintf(Outfile,"%s\n","#define PUT(A,B,C) F_PutVal=fwrite(B,1,C,A)");
      AddGlobal("F_PutVal",vt_INTEGER,0,"",0,0,0,0);
    }
  if(Use_Strptr)
    {
      fprintf(Outfile,"%s\n","#define STRPTR(A)((char*)&(A))");
    }
  if(Use_Val)
    {
      fprintf(Outfile,"%s\n","#define VAL(a)(double)atof(a)");
    }
  if(Use_Vall)
    {
      fprintf(Outfile,"%s\n","#define VALL(a) (long double)strtold(a,(char**)NULL)");
    }
  if(Use_Fint)
    {
      fprintf(Outfile,"%s\n","#define FINT(a)floor(a)");
    }
  if(Use_Frac)
    {
      fprintf(Outfile,"%s\n","#define FRAC(a)(double)(a-FIX(a))");
      Use_Fix=TRUE;
    }
  if(Use_Fracl)
    {
      fprintf(Outfile,"%s\n","#define FRACL(a)(long double)(a-FIX(a))");
      Use_Fix=TRUE;
    }
  if(Use_Fix)
    {
      fprintf(Outfile,"%s\n","#define FIX(a)(int)((a))");
    }
  if(Use_Csng)
    {
      fprintf(Outfile,"%s\n","#define CSNG(a)((float)(a))");
    }
  if(Use_Cdbl)
    {
      fprintf(Outfile,"%s\n","#define CDBL(a)((double)(a))");
    }
  if(Use_Cldbl)
    {
      fprintf(Outfile,"%s\n","#define CLDBL(a)((long double)(a))");
    }
  if(Use_Threads)
    {
      fprintf(Outfile,"%s\n","#define BCX_THREAD(fn,arg)   ({ pthread_t tid; pthread_create(&tid, NULL, (void*(*)(void*))fn, arg); tid;})");
      fprintf(Outfile,"%s\n","#define BCX_THREADWAIT(a)    pthread_join(a, NULL)");
      fprintf(Outfile,"%s\n","#define BCX_INITLOCK(a)      pthread_mutex_init(a, NULL)");
      fprintf(Outfile,"%s\n","#define BCX_THREADLOCK(a)    pthread_mutex_lock (a)");
      fprintf(Outfile,"%s\n","#define BCX_THREADUNLOCK(a)  pthread_mutex_unlock (a)");
      fprintf(Outfile,"%s\n","#define BCX_THREADKILL(t)    pthread_cancel(t)");
      fprintf(Outfile,"%s\n","#define BCX_THREADEND        pthread_exit(0)");
    }
  fprintf(Outfile,"%s\n","");
  fprintf(Outfile,"%s\n","");
  fprintf(Outfile,"%s\n","// *************************************************");
  fprintf(Outfile,"%s%s\n","//               ",BCX_STR_STD_PROTOS);
  fprintf(Outfile,"%s\n","// *************************************************");
  fprintf(Outfile,"%s\n","");
  if(NoRT==FALSE)
    {
      if(Use_Clng)
        {
          fprintf(Outfile,"%s\n","long    CLNG(double);");
        }
      if(Use_Cint)
        {
          fprintf(Outfile,"%s\n","int     Cint(double);");
        }
      if(Use_StartupCode)
        {
          fprintf(Outfile,"%s\n","int     BCX_StartupCode_(void);");
        }
      if(Use_ExitCode)
        {
          fprintf(Outfile,"%s\n","int     BCX_ExitCode_(void);");
        }
      if(Use_Str_Cmp)
        {
          fprintf(Outfile,"%s\n","int     str_cmp(char*, char*);");
        }
      if(Use_Eof)
        {
          fprintf(Outfile,"%s\n","int     EoF (FILE*);");
        }
      if(Use_CopyFile)
        {
          fprintf(Outfile,"%s\n","void    CopyFile (char *,char *,int=FALSE);");
        }
      if(Use_QBColor)
        {
          fprintf(Outfile,"%s\n","int     qbcolor (int);");
        }
      if(Use_Cls)
        {
          fprintf(Outfile,"%s\n","void    cls(void);");
        }
      if(Use_Color)
        {
          fprintf(Outfile,"%s\n","void    color (int,int);");
        }
      if(Use_Locate)
        {
          fprintf(Outfile,"%s\n","void    locate (int,int,int=1,int=12);");
        }
      if(Use_Run)
        {
          fprintf(Outfile,"%s\n","int     Run (char*, int =1, int =0);");
        }
      if(Use_Randomize)
        {
          fprintf(Outfile,"%s\n","void    randomize (unsigned int);");
        }
      if(Use_Midstr)
        {
          fprintf(Outfile,"%s\n","void    midstr (char*, int, int, char *);");
        }
      if(Use_Swap)
        {
          fprintf(Outfile,"%s\n","void    swap (UCHAR*,UCHAR*,int);");
        }
      if(UseFlag)
        {
          fprintf(Outfile,"%s\n","char*   BCX_TmpStr(size_t);");
        }
      if(Use_sziif)
        {
          fprintf(Outfile,"%s\n","char*   sziif (bool,char*,char*);");
        }
      if(Use_Using)
        {
          fprintf(Outfile,"%s\n","char*   Using (char*,double);");
        }
      if(Use_TempFileName)
        {
          fprintf(Outfile,"%s\n","char*   TempFileName (char*,char*);");
        }
      if(Use_AppExePath)
        {
          fprintf(Outfile,"%s\n","char*   AppExePath (void);");
        }
      if(Use_AppExeName)
        {
          fprintf(Outfile,"%s\n","char*   AppExeName (void);");
        }
      if(Use_Lcase)
        {
          fprintf(Outfile,"%s\n","char*   lcase (char*);");
        }
      if(Use_Ucase)
        {
          fprintf(Outfile,"%s\n","char*   ucase (char*);");
        }
      if(Use_Mid)
        {
          fprintf(Outfile,"%s\n","char*   mid (char*, int, int=-1);");
        }
      if(Use_Ltrim)
        {
          fprintf(Outfile,"%s\n","char*   ltrim (char*,char=32);");
        }
      if(Use_Rtrim)
        {
          fprintf(Outfile,"%s\n","char*   rtrim (char*,char=32);");
        }
      if(Use_Trim)
        {
          fprintf(Outfile,"%s\n","char*   trim (char*);");
        }
      if(Use_Strim)
        {
          fprintf(Outfile,"%s\n","char*   strim   (char*);");
        }
      if(Use_Left)
        {
          fprintf(Outfile,"%s\n","char*   left (char*,int);");
        }
      if(Use_Right)
        {
          fprintf(Outfile,"%s\n","char*   right (char*,int);");
        }
      if(Use_Rpad)
        {
          fprintf(Outfile,"%s\n","char*   rpad (char*,int,int=32);");
        }
      if(Use_Lpad)
        {
          fprintf(Outfile,"%s\n","char*   lpad (char*,int,int=32);");
        }
      if(Use_String)
        {
          fprintf(Outfile,"%s\n","char*   stringx (int,int);");
        }
      if(Use_Repeat)
        {
          fprintf(Outfile,"%s\n","char*   repeat (int,char*);");
        }
      if(Use_Extract)
        {
          fprintf(Outfile,"%s\n","char*   extract (char*,char*);");
        }
      if(Use_Remain)
        {
          fprintf(Outfile,"%s\n","char*   remain (char*,char*);");
        }
      if(Use_Reverse)
        {
          fprintf(Outfile,"%s\n","char*   reverse (char*);");
        }
      if(Use_Command)
        {
          fprintf(Outfile,"%s\n","char*   command (int=-1);");
        }
      if(Use_Mcase)
        {
          fprintf(Outfile,"%s\n","char*   mcase (char*);");
        }
      if(Use_Replace)
        {
          fprintf(Outfile,"%s\n","char*   replace (char*,char*,char*);");
        }
      if(Use_iReplace)
        {
          fprintf(Outfile,"%s\n","char*   iReplace (char*,char*,char*);");
        }
      if(Use_Shell)
        {
          fprintf(Outfile,"%s\n","void    Shell (char *);");
        }
      if(Use_Space)
        {
          fprintf(Outfile,"%s\n","char*   space (int a);");
        }
      if(Use_Str)
        {
          fprintf(Outfile,"%s\n","char*   str (double);");
        }
      if(Use_Strl)
        {
          fprintf(Outfile,"%s\n","char*   strl (long double);");
        }
      if(Use_Findfirst)
        {
          fprintf(Outfile,"%s\n","char*   findfirst (char*, FILE_FIND_DATA*);");
        }
      if(Use_Findnext)
        {
          fprintf(Outfile,"%s\n","char*   findnext (FILE_FIND_DATA*);");
        }
      if(Use_Curdir)
        {
          fprintf(Outfile,"%s\n","char*   curdir (void);");
        }
      if(Use_Sysdir)
        {
          fprintf(Outfile,"%s\n","char*   sysdir (void);");
        }
      if(Use_Tempdir)
        {
          fprintf(Outfile,"%s\n","char*   tempdir (void);");
        }
      if(Use_Environ)
        {
          fprintf(Outfile,"%s\n","char*   Environ (char*);");
        }
      if(Use_Boolstr)
        {
          fprintf(Outfile,"%s\n","char*   BoolStr (int);");
        }
      if(Use_Hex)
        {
          fprintf(Outfile,"%s\n","char*   hex (int);");
        }
      if(Use_Bin)
        {
          fprintf(Outfile,"%s\n","char*   Bin (int);");
        }
      if(Use_Oct)
        {
          fprintf(Outfile,"%s\n","char*   oct (int);");
        }
      if(Use_Now)
        {
          fprintf(Outfile,"%s\n","char*   now (void);");
        }
      if(Use_SearchPath)
        {
          fprintf(Outfile,"%s\n","char*   SEARCHPATH (char *);");
        }
      if(Use_StrUpLow)
        {
          fprintf(Outfile,"%s\n","char*   _strupr_(char *);");
          fprintf(Outfile,"%s\n","char*   _strlwr_(char *);");
        }
      if(Use_BcxSplitPath)
        {
          fprintf(Outfile,"%s\n","char*   BcxSplitPath (char *, int);");
          fprintf(Outfile,"%s\n","void    _splitpath_(const char* path, char* drv, char* dir, char* name, char* ext);");
        }
      if(Use_Strtoken)
        {
          fprintf(Outfile,"%s\n","char*   StrToken (char*,char*,int);");
        }
      if(Use_FileLocked)
        {
          fprintf(Outfile,"%s\n","int    FileLocked (char*);");
        }
      if(Use_FillArray)
        {
          fprintf(Outfile,"%s\n","int     fillarray (char *, int, int, void *);");
        }
      if(Use_Remove)
        {
          fprintf(Outfile,"%s\n","char*   RemoveStr (char*,char*);");
        }
      if(Use_IRemove)
        {
          fprintf(Outfile,"%s\n","char*   IRemoveStr (char*,char*);");
        }
      if(Use_Time)
        {
          fprintf(Outfile,"%s\n","char*   timef (int i=0);");
        }
      if(Use_Join)
        {
          fprintf(Outfile,"%s\n","char*   join (int, ... );");
        }
      if(Use_Enclose)
        {
          fprintf(Outfile,"%s\n","char*   enc (char*, int=0, int=0);");
        }
      if(Use_Chr)
        {
          fprintf(Outfile,"%s","char*   chr");
          fprintf(Outfile,"%s\n","(int,int=0,int=0,int=0,int=0,int=0,int=0,int=0,int=0,int=0);");
        }
      if(Use_VChr)
        {
          fprintf(Outfile,"%s\n","char*   vchr (int,...);");
        }
      if(Use_Freefile)
        {
          fprintf(Outfile,"%s\n","FILE*   FreeFile (void);");
        }
      if(Use_PeekStr)
        {
          fprintf(Outfile,"%s\n","char*   peekstr (LPVOID,int);");
        }
      if(Use_Asc)
        {
          fprintf(Outfile,"%s\n","int     asc (char*,int=0);");
        }
      if(Use_Instrrev)
        {
          fprintf(Outfile,"%s\n","int     InstrRev (char*,char*,int=0,int=0);");
        }
      if(Use_Instr)
        {
          fprintf(Outfile,"%s\n","int     instr_b(char*,char*,int=0,int=0);");
        }
      if(UseLCaseTbl)
        {
          fprintf(Outfile,"%s\n","char    *MakeLCaseTbl(void);");
        }
      if(Use_Stristr)
        {
          fprintf(Outfile,"%s\n","char    *_stristr_(char*,char*);");
        }
      if(Use_StrStr)
        {
          fprintf(Outfile,"%s\n","char    *_strstr_(char*,char*);");
        }
      if(Use_Verify)
        {
          fprintf(Outfile,"%s\n","int     Verify (char *, char *);");
          fprintf(Outfile,"%s\n","int     VerifyInstr(char*,char*,int=0);");
        }
      if(Use_Retain)
        {
          fprintf(Outfile,"%s\n","char*   Retain (char*,char *);");
        }
      if(Use_LoadFile)
        {
          fprintf(Outfile,"%s\n","char*   LoadFile (char*);");
        }
      if(Use_Inchr)
        {
          fprintf(Outfile,"%s\n","int     inchr (char*,char*);");
        }
      if(Use_Idxqsort)
        {
          fprintf(Outfile,"%s\n","int     IdxCompare (const void *,const void *);");
        }
      if(Use_IdxqsortSt)
        {
          fprintf(Outfile,"%s\n","int     IdxCompareSt (const void *,const void *);");
        }
      if(Use_PtrqsortSt)
        {
          fprintf(Outfile,"%s\n","int     PtrCompareSt (const void *,const void *);");
        }
      if(Use_Strqsorta)
        {
          fprintf(Outfile,"%s\n","int     StrCompareA (const void *,const void *);");
        }
      if(Use_Strqsortd)
        {
          fprintf(Outfile,"%s\n","int     StrCompareD (const void *,const void *);");
        }
      if(Use_DynStrqsorta)
        {
          fprintf(Outfile,"%s\n","int     DynStrCompareA (const void *,const void *);");
        }
      if(Use_DynStrqsortd)
        {
          fprintf(Outfile,"%s\n","int     DynStrCompareD (const void *,const void *);");
        }
      if(Use_Numqsortaint)
        {
          fprintf(Outfile,"%s\n","int     NumCompareAint (const void *,const void *);");
        }
      if(Use_Numqsortdint)
        {
          fprintf(Outfile,"%s\n","int     NumCompareDint (const void *,const void *);");
        }
      if(Use_Numqsortafloat)
        {
          fprintf(Outfile,"%s\n","int     NumCompareAfloat (const void *,const void *);");
        }
      if(Use_Numqsortdfloat)
        {
          fprintf(Outfile,"%s\n","int     NumCompareDfloat (const void *,const void *);");
        }
      if(Use_Numqsortadouble)
        {
          fprintf(Outfile,"%s\n","int     NumCompareAdouble (const void *,const void *);");
        }
      if(Use_Numqsortddouble)
        {
          fprintf(Outfile,"%s\n","int     NumCompareDdouble (const void *,const void *);");
        }
      if(Use_Like)
        {
          fprintf(Outfile,"%s\n","int     like (char*,char*);");
        }
      if(Use_Tally)
        {
          fprintf(Outfile,"%s\n","int     tally (char*,char*,int=0);");
        }
      if(Use_Inkey)
        {
          fprintf(Outfile,"%s\n","char*   inkey (void);");
        }
      if(Use_InkeyD)
        {
          fprintf(Outfile,"%s\n","int     inkeyd (void);");
        }
      if(Use_Instat)
        {
          fprintf(Outfile,"%s\n","int		kbhit(void);");
        }
      if(Use_GetCh)
        {
          fprintf(Outfile,"%s\n","int     _getch_(int);");
        }
      if(Use_Bin2dec)
        {
          fprintf(Outfile,"%s\n","int     Bin2Dec (char*);");
        }
      if(Use_Hex2Dec)
        {
          fprintf(Outfile,"%s\n","int     Hex2Dec (char*);");
        }
      if(Use_Download)
        {
          fprintf(Outfile,"%s\n","int     Download (char*,char*);");
        }
      if(Use_Embed)
        {
          fprintf(Outfile,"%s\n","char*   GetResource (int* );");
        }
      if(Use_Exist)
        {
          if(Use_Osx)
            {
              fprintf(Outfile,"%s\n","bool    Exist   (char*);");
            }
          else
            {
              fprintf(Outfile,"%s\n","BOOL    Exist   (char*);");
            }
        }
      if(Use_Ins)
        {
          fprintf(Outfile,"%s\n","char*   ins (char *S, int i, char *a);");
        }
      if(Use_Del)
        {
          fprintf(Outfile,"%s\n","char*   del (char*,int,int);");
        }
      if(Use_Pause)
        {
          fprintf(Outfile,"%s\n","void    Pause (void);");
        }
      if(Use_Keypress)
        {
          fprintf(Outfile,"%s\n","int     keypress (void);");
        }
      if(Use_Lof)
        {
          fprintf(Outfile,"%s\n","DWORD   lof (char*);");
        }
      if(Use_Sgn)
        {
          fprintf(Outfile,"%s\n","double  sgn (double);");
        }
      if(Use_Round)
        {
          fprintf(Outfile,"%s\n","double  Round (double,int);");
        }
      if(Use_Rnd)
        {
          fprintf(Outfile,"%s\n","float   rnd (void);");
        }
      if(Use_Exp)
        {
          fprintf(Outfile,"%s\n","double  Exp (double);");
        }
      if(Use_Min)
        {
          fprintf(Outfile,"%s\n","double  _MIN_ (double,double);");
        }
      if(Use_Max)
        {
          fprintf(Outfile,"%s\n","double  _MAX_ (double,double);");
        }
      if(Use_Timer)
        {
          fprintf(Outfile,"%s\n","float   timer (void);");
        }
      if(Use_Iif)
        {
          fprintf(Outfile,"%s\n","double  iif (bool,double,double);");
        }
      if(Use_Loc)
        {
          fprintf(Outfile,"%s\n","int     loc (FILE *fp, int fplen);");
        }
      if(Use_Rec)
        {
          fprintf(Outfile,"%s\n","int     rec (FILE *fp, int fplen);");
        }
      if(Use_RecCount)
        {
          fprintf(Outfile,"%s\n","int     reccount (FILE *fp, int fplen);");
        }
      if(Use_Scan)
        {
          fprintf(Outfile,"%s\n","int     scan (char *input, char *format, ... );");
        }
      if(Use_Split)
        {
          fprintf(Outfile,"%s\n","int     Split (char [][65535], char*, char*, int=0);");
        }
      if(Use_DSplit)
        {
          fprintf(Outfile,"%s\n","int     DSplit (PCHAR *, char*, char*, int=0);");
        }
      if(Use_SysStr)
        {
          fprintf(Outfile,"%s\n","BSTR    SysStr (char * szIn, int=0, int=0);");
        }
      if(Use_WideToAnsi)
        {
          fprintf(Outfile,"%s\n","char*   WideToAnsi (wchar_t *, UINT=0, DWORD=0);");
        }
      if(Use_AnsiToWide)
        {
          fprintf(Outfile,"%s\n","wchar_t* AnsiToWide (char*,UINT=0,DWORD=0);");
        }
      if(Use_Cvi)
        {
          fprintf(Outfile,"%s\n","short   CVI (char*);");
        }
      if(Use_Mki)
        {
          fprintf(Outfile,"%s\n","char*   MKI (short);");
        }
      if(Use_Cvl)
        {
          fprintf(Outfile,"%s\n","long    CVL (char*);");
        }
      if(Use_Mkl)
        {
          fprintf(Outfile,"%s\n","char*   MKL (int);");
        }
      if(Use_Cvs)
        {
          fprintf(Outfile,"%s\n","float   CVS (char*);");
        }
      if(Use_Mks)
        {
          fprintf(Outfile,"%s\n","char*   MKS (float);");
        }
      if(Use_Cvd)
        {
          fprintf(Outfile,"%s\n","double  CVD (char*);");
        }
      if(Use_Cvld)
        {
          fprintf(Outfile,"%s\n","long double  CVLD (char*);");
        }
      if(Use_Mkd)
        {
          fprintf(Outfile,"%s\n","char*   MKD (double);");
        }
      if(Use_Mkld)
        {
          fprintf(Outfile,"%s\n","char*   MKLD (long double);");
        }
      if(Use_OSVersion)
        {
          fprintf(Outfile,"%s\n","int     OSVersion (void);");
        }
      if(Use_Dynacall)
        {
          fprintf(Outfile,"%s\n","HINSTANCE BCX_LoadDll(char *);");
          fprintf(Outfile,"%s\n","void    BCX_UnloadDll(void);");
          fprintf(Outfile,"%s\n","typedef int (CALLBACK *DYNACALL1)(void);");
          fprintf(Outfile,"%s\n","int     BCX_DynaCall(char *, char *, int, ...);");
        }
      if(Use_DynamicA)
        {
          fprintf(Outfile,"%s\n","void*   CreateArr (void*,int,int,int,...);");
          fprintf(Outfile,"%s\n","void*   CreateArr_internal(void*, int, int, int, va_list);");
          fprintf(Outfile,"%s\n","void    DestroyArr (void**,int,int);");
        }
      if(Use_ContainedIn)
        {
          fprintf(Outfile,"%s\n","int     containedin(char * ,char **,int=0);");
        }
      if(Use_FindInType)
        {
          fprintf(Outfile,"%s\n","int     FindInType(char *,char *,int,int,int,int=0,int* =0);");
        }
      if(Use_SingleFile==FALSE)
        {
          if((fpHFile=fopen(HFile,"w"))==0)
           {
             fprintf(stderr,"Can't open file %s\n",HFile);
             exit(1);
           }
        }
      /*****2010-11-24ChangeTOemitwxAppCLASSDefinitionFORWXCONSOLEApps-AIR*****/;
      if(Use_Wx)
        {
          fprintf(Outfile,"%s\n","");
          fprintf(Outfile,"%s%s%s\n","class ",BcxSplitPath(FileIn,FNAME),": public wxApp {");
          fprintf(Outfile,"%s\n","  public:");
          fprintf(Outfile,"%s\n","	virtual bool OnInit();");
          fprintf(Outfile,"%s\n","};");
          fprintf(Outfile,"%s\n","");
          fprintf(Outfile,"%s%s%s\n","IMPLEMENT_APP(",BcxSplitPath(FileIn,FNAME),")");
          fprintf(Outfile,"%s\n","");
        }
      if(Use_Socket)
        {
          fprintf(Outfile,"%s\n","");
          fprintf(Outfile,"%s\n","sockaddr_in sock_addr (char* ,int=80);");
          fprintf(Outfile,"%s\n","int     connect_socket (sockaddr_in);");
          fprintf(Outfile,"%s\n","int     BcxSocket (char* ,int=80);");
          fprintf(Outfile,"%s\n","int     BcxSocketSend (int, char *);");
          fprintf(Outfile,"%s\n","int     BcxSocketRead (int, char *);");
          fprintf(Outfile,"%s\n","void    BcxSocketClose(int);");
          fprintf(Outfile,"%s\n","");
        }
      if(Use_RegEx)
        {
          fprintf(Outfile,"%s\n","bool    regmatch (char *, char *, REGEX* );");
        }
    }
  if(ProtoCnt)
    {
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s%s\n","//               ",BCX_STR_USR_PROTOS);
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","");
      char LastDef[2048];
      int     LastLevel;
      *LastDef=0;
      LastLevel=1;
      for(A=1; A<=ProtoCnt; A+=1)
        {
          if(LastDef[0]==0)
            {
              strcpy(LastDef,ProtoType[A].Condition);
              LastLevel=ProtoType[A].CondLevel;
              if(Use_SingleFile==FALSE)
                {
                  if(LastDef[0]>0)
                    {
                      fprintf(fpHFile,"%s\n",LastDef);
                    }
                }
              if(LastDef[0]>0)
                {
                  fprintf(Outfile,"%s\n",LastDef);
                }
            }
          if(str_cmp(LastDef,ProtoType[A].Condition)!=0)
            {
              if(str_cmp(ProtoType[A].Condition,"#else")==0)
                {
                  while(LastLevel>ProtoType[A].CondLevel)
                    {
                      if(Use_SingleFile==FALSE)
                        {
                          fprintf(fpHFile,"%s\n","#endif");
                        }
                      fprintf(Outfile,"%s\n","#endif");
                      LastLevel--;
                    }
                  if(Use_SingleFile==FALSE)
                    {
                      fprintf(fpHFile,"%s\n","#else");
                    }
                  fprintf(Outfile,"%s\n","#else");
                  strcpy(LastDef,ProtoType[A].Condition);
                  LastLevel=ProtoType[A].CondLevel;
                }
              else
                {
                  while(LastLevel>ProtoType[A].CondLevel)
                    {
                      if(Use_SingleFile==FALSE)
                        {
                          fprintf(fpHFile,"%s\n","#endif");
                        }
                      fprintf(Outfile,"%s\n","#endif");
                      LastLevel--;
                    }
                  strcpy(LastDef,ProtoType[A].Condition);
                  LastLevel=ProtoType[A].CondLevel;
                  if(Use_SingleFile==FALSE)
                    {
                      if(LastDef[0]>0)
                        {
                          fprintf(fpHFile,"%s\n",LastDef);
                        }
                    }
                  if(LastDef[0]>0)
                    {
                      fprintf(Outfile,"%s\n",LastDef);
                    }
                }
            }
          if(UseStdCall&&UseCpp)
            {
              if(str_cmp(left(ProtoType[A].Prototype,9),"C_EXPORT ")==0)
                {
                  EmitExportDef(ProtoType[A].Prototype);
                }
            }
          strcpy(T,extract(ProtoType[A].Prototype,SPC));
          strcpy(T, join(2,rpad(T,7),SPC));
          strcpy(ProtoType[A].Prototype, join(2,T,remain(ProtoType[A].Prototype,SPC)));
          if(Use_SingleFile==FALSE)
            {
              fprintf(fpHFile,"%s\n",ProtoType[A].Prototype);
            }
          if(UseCpp==FALSE&&!instr_b(ProtoType[A].Prototype,"::"))
            {
              fprintf(Outfile,"%s\n",ProtoType[A].Prototype);
            }
        }
      if(*LastDef)
        {
          while(LastLevel>0)
            {
              if(Use_SingleFile==FALSE)
                {
                  fprintf(fpHFile,"%s\n","#endif");
                }
              fprintf(Outfile,"%s\n","#endif");
              LastLevel--;
            }
        }
    }
  fprintf(Outfile,"%s\n","");
  char P[2048];
  int     i;
  char VarName[2048];
  char VarDim[2048];
  char Storage[2048];
  char VAR[2048];
  if(GlobalVarCnt>0)
    {
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","//            User Global Initialized Arrays");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","");
      for(i=1; i<=GlobalVarCnt; i+=1)
        {
          if(GlobalVars[i].VarEmitFlag)
            {
              continue;
            }
          if(str_cmp("",GlobalVars[i].VarDim)!=0 && GlobalVars[i].VarCondLevel==0)
            {
              if(instr_b(GlobalVars[i].VarDim,"{"))
                {
                  *P=0;
                  if(GlobalVars[i].VarPntr)
                    {
                      strcpy(P,stringx(GlobalVars[i].VarPntr,42));
                    }
                  A=GlobalVars[i].VarType;
                  if(GlobalVars[i].VarSF)
                    {
                      strcpy(VarName, join(4,"(*",GlobalVars[i].VarName,extract(GlobalVars[i].VarDim,"("),")"));
                      strcpy(VarDim,mid(GlobalVars[i].VarDim,instr_b(GlobalVars[i].VarDim,"(")));
                    }
                  else
                    {
                      strcpy(VarName,GlobalVars[i].VarName);
                      strcpy(VarDim,GlobalVars[i].VarDim);
                    }
                  strcpy(Storage, join(2,VarStorage[GlobalVars[i].VarExtn],VarConst[GlobalVars[i].VarConstant]));
                  for(;;)
                  {
                    if(A==vt_STRVAR)
                      {
                        fprintf(Outfile,"%s%s%s%s%s\n",Storage,"char    ",VarName,VarDim,";");
                        break;
                      }
                    if(A==vt_FILEPTR)
                      {
                        strcpy(GlobalVars[i].VarName,RemoveStr(GlobalVars[i].VarName,"@"));
                        fprintf(Outfile,"%s%s%s%s%s\n",Storage,"FILE   *",VarName,VarDim,";");
                        break;
                      }
                    if(A==vt_BOOL)
                      {
                        fprintf(Outfile,"%s%s%s%s%s\n",Storage,"bool    ",VarName,VarDim,";");
                        break;
                      }
                    if(A==vt_UDT||A==vt_STRUCT||A==vt_UNION)
                      {
                        strcpy(VAR,TypeDefs[GlobalVars[i].VarDef].VarName);
                        strcpy(VAR,rpad(VAR,7));
                        fprintf(Outfile,"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
                        break;
                      }
                    if(A>=vt_VarMin&&A<=vt_VarMax)
                      {
                        strcpy(VAR,GetVarTypeName(GlobalVars[i].VarType));
                        strcpy(VAR,rpad(VAR,7));
                        fprintf(Outfile,"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
                      }
                    break;
                  }
                }
            }
        }
      fprintf(Outfile,"%s\n","");
    }
  if(Use_Overloaded)
    {
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","//        User's Overloaded Subs/Functions          ");
      fprintf(Outfile,"%s\n","// *************************************************");
      if((FP8=fopen(ovrFile,"r"))==0)
       {
         fprintf(stderr,"Can't open file %s\n",ovrFile);
         exit(1);
       }
      while(!EoF(FP8))
        {
          ZZ[0]=0;
          AR_fgets_retval=fgets(ZZ,65535,FP8);
          if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
          if(instr_b(ZZ,"overloaded"))
            {
              fprintf(Outfile,"%s\n","\n");
            }
          fprintf(Outfile,"%s\n",ZZ);
        }
      if(FP8)
       {
         fclose(FP8);
         FP8=NULL;
       }
      fprintf(Outfile,"%s\n","\n\n");
    }
  if((FP5=fopen(setFile,"r"))==0)
   {
     fprintf(stderr,"Can't open file %s\n",setFile);
     exit(1);
   }
  if(lof(setFile)>0)
    {
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","//              User GLOBAL SET Statements");
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","");
      while(!EoF(FP5))
        {
          Z[0]=0;
          AR_fgets_retval=fgets(Z,65535,FP5);
          if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
          fprintf(Outfile,"%s\n",Z);
        }
      fprintf(Outfile,"%s\n","");
    }
  if(FP5)
   {
     fclose(FP5);
     FP5=NULL;
   }
  if(Use_SingleFile==FALSE)
    {
      if(fpHFile)
       {
         fclose(fpHFile);
         fpHFile=NULL;
       }
    }
  if(NoMain==0)
    {
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s%s\n","//                  ",BCX_STR_MAIN_PROG);
      fprintf(Outfile,"%s\n","// *************************************************");
      fprintf(Outfile,"%s\n","");
    }
  if(NoMain==FALSE)
    {
      fprintf(Outfile,"%s\n",SaveMain);
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  G_argc = argc;");
      fprintf(Outfile,"%s\n","  G_argv = argv;");
      BumpUp();
    }
  while(!EoF(FP1))
    {
      ZZ[0]=0;
      AR_fgets_retval=fgets(ZZ,65535,FP1);
      if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
      fprintf(Outfile,"%s%s\n",Scoot,ZZ);
    }
  if(Use_SingleFile==TRUE)
    {
      RunTimeFunctions();
    }
  fflush(Outfile);
  CloseAll();
  remove (FileOut);
  rename ("$t$e$m$p",FileOut);
  if(ZZ)free(ZZ);
}


void RunTimeFunctions (void)
{
  static char X1[2048];
  memset(&X1,0,sizeof(X1));
  static char O1[2048];
  memset(&O1,0,sizeof(O1));
  static char D1[2048];
  memset(&D1,0,sizeof(D1));
  static char D2[2048];
  memset(&D2,0,sizeof(D2));
  static char T0[2048];
  memset(&T0,0,sizeof(T0));
  static char T1[2048];
  memset(&T1,0,sizeof(T1));
  static char T2[2048];
  memset(&T2,0,sizeof(T2));
  static char T3[2048];
  memset(&T3,0,sizeof(T3));
  static char T4[2048];
  memset(&T4,0,sizeof(T4));
  static char T5[2048];
  memset(&T5,0,sizeof(T5));
  static char T6[2048];
  memset(&T6,0,sizeof(T6));
  static char T7[2048];
  memset(&T7,0,sizeof(T7));
  static char T8[2048];
  memset(&T8,0,sizeof(T8));
  static char T9[2048];
  memset(&T9,0,sizeof(T9));
  static char T10[2048];
  memset(&T10,0,sizeof(T10));
  static char T11[2048];
  memset(&T11,0,sizeof(T11));
  static char T12[2048];
  memset(&T12,0,sizeof(T12));
  static char T13[2048];
  memset(&T13,0,sizeof(T13));
  static char TDIR[2048];
  memset(&TDIR,0,sizeof(TDIR));
  strcpy(D1,vchr(8,34,37,32,46,49,53,71,34));
  strcpy(D2,vchr(9,34,37,32,46,49,57,76,71,34));
  strcpy(O1,vchr(4,34,37,111,34));
  strcpy(T0,vchr(10,34,37,72,58,37,77,58,37,83,34));
  strcpy(T1,vchr(4,34,37,72,34));
  strcpy(T2,vchr(4,34,37,77,34));
  strcpy(T3,vchr(4,34,37,83,34));
  strcpy(T4,vchr(4,34,37,112,34));
  strcpy(T5,vchr(4,34,37,89,34));
  strcpy(T6,vchr(4,34,37,109,34));
  strcpy(T7,vchr(4,34,37,100,34));
  strcpy(T8,vchr(4,34,37,65,34));
  strcpy(T9,vchr(4,34,37,119,34));
  strcpy(T10,vchr(4,34,37,106,34));
  strcpy(T11,vchr(4,34,37,86,34));
  strcpy(T12,vchr(10,34,37,109,47,37,100,47,37,121,34));
  strcpy(T13,vchr(15,34,37,65,44,32,37,66,32,37,100,44,32,37,89,34));
  strcpy(X1,vchr(4,34,37,88,34));
  strcpy(TDIR,enc("/tmp/mbc.XXXXXXXX"));
  fprintf(Outfile,"%s\n","");
  fprintf(Outfile,"%s\n","// *************************************************");
  fprintf(Outfile,"%s%s\n","//                 ",BCX_STR_RUNTIME);
  fprintf(Outfile,"%s\n","// *************************************************");
  fprintf(Outfile,"%s\n","");
  if(NoRT==TRUE)
    {
      return;
    }
  if(UseFlag)
    {
      if(Use_Turbo)
        {
          fprintf(Outfile,"%s\n","char *BCX_TmpStr (size_t Bites)");
          fprintf(Outfile,"%s\n","{");
          fprintf(Outfile,"%s\n","  static int   StrCnt;");
          fprintf(Outfile,"%s%d%s\n","  static char *StrFunc[",(int)TurboSize,"];");
          fprintf(Outfile,"%s%d%s\n","  StrCnt=((StrCnt+1) &",(int)TurboSize-1,");");
          fprintf(Outfile,"%s\n","    #if defined BCX_MAX_VAR_SIZE");
          fprintf(Outfile,"%s\n","  if(Bites*sizeof(char)>BCX_MAX_VAR_SIZE)");
          fprintf(Outfile,"%s\n","  {");
          fprintf(Outfile,"%s%s%s\n","  printf(",enc("Buffer Overflow caught in BCX_TmpStr - requested space of %d EXCEEDS %d\\n"),",(int)(Bites*sizeof(char)),BCX_MAX_VAR_SIZE);");
          fprintf(Outfile,"%s\n","  abort();");
          fprintf(Outfile,"%s\n","  }");
          fprintf(Outfile,"%s\n","  #endif");
          fprintf(Outfile,"%s\n","  StrFunc[StrCnt]=(char*)realloc(StrFunc[StrCnt],Bites + 128);");
          fprintf(Outfile,"%s\n","  return (char*)memset(StrFunc[StrCnt],0,Bites+128);");
          fprintf(Outfile,"%s\n","}\n\n");
        }
      else
        {
          fprintf(Outfile,"%s\n","char *BCX_TmpStr (size_t Bites)");
          fprintf(Outfile,"%s\n","{");
          fprintf(Outfile,"%s\n","  static int   StrCnt;");
          fprintf(Outfile,"%s\n","  static char *StrFunc[65535];");
          fprintf(Outfile,"%s\n","  StrCnt=(StrCnt + 1) & 65535;");
          fprintf(Outfile,"%s\n","  if(StrFunc[StrCnt]) free (StrFunc[StrCnt]);");
          fprintf(Outfile,"%s\n","    #if defined BCX_MAX_VAR_SIZE");
          fprintf(Outfile,"%s\n","  if(Bites*sizeof(char)>BCX_MAX_VAR_SIZE)");
          fprintf(Outfile,"%s\n","  {");
          fprintf(Outfile,"%s%s%s\n","  printf(",enc("Buffer Overflow caught in BCX_TmpStr - requested space of %d EXCEEDS %d\\n"),",(int)(Bites*sizeof(char)),BCX_MAX_VAR_SIZE);");
          fprintf(Outfile,"%s\n","  abort();");
          fprintf(Outfile,"%s\n","  }");
          fprintf(Outfile,"%s\n","  #endif");
          fprintf(Outfile,"%s\n","  return StrFunc[StrCnt]=(char*)calloc(Bites+128,sizeof(char));");
          fprintf(Outfile,"%s\n","}\n\n");
        }
    }
  if(Use_CopyFile)
    {
      fprintf(Outfile,"%s\n","void CopyFile (char *InFile,char *TmpFile,int OverWrite)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  #define BLOCKCOPYSIZE (10 * 1000*1024)");
      fprintf(Outfile,"%s\n","  char*  tmp=0;");
      fprintf(Outfile,"%s\n","  UINT   blocks=1;");
      fprintf(Outfile,"%s\n","  UINT   overage=0;");
      fprintf(Outfile,"%s\n","  UINT   i;");
      fprintf(Outfile,"%s\n","  FILE   *FP1,*FP2;");
      fprintf(Outfile,"%s\n","  if(!OverWrite)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      if(Exist(TmpFile)) return;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  if(Exist(InFile))");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      UINT length = lof(InFile);");
      fprintf(Outfile,"%s\n","      if(length > BLOCKCOPYSIZE)");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","          blocks = length/BLOCKCOPYSIZE;");
      fprintf(Outfile,"%s\n","          overage= length % BLOCKCOPYSIZE;");
      fprintf(Outfile,"%s\n","          length = BLOCKCOPYSIZE;");
      fprintf(Outfile,"%s\n","        }");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","      tmp=(char*)calloc(16+length,1);");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s%s%s\n","      if((FP1=fopen(InFile,",enc("rb"),"))==0)");
      fprintf(Outfile,"%s\n","       {");
      fprintf(Outfile,"%s%s%s\n","         fprintf(stderr,",enc("Can't open file %s\\n"),",InFile);");
      fprintf(Outfile,"%s\n","         exit(1);");
      fprintf(Outfile,"%s\n","       }");
      fprintf(Outfile,"%s%s%s\n","      if((FP2=fopen(TmpFile,",enc("wb+"),"))==0)");
      fprintf(Outfile,"%s\n","       {");
      fprintf(Outfile,"%s%s%s\n","         fprintf(stderr,",enc("Can't open file %s\\n"),",TmpFile);");
      fprintf(Outfile,"%s\n","         exit(1);");
      fprintf(Outfile,"%s\n","       }");
      fprintf(Outfile,"%s\n","      for(i=0; i<blocks; i+=1)");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","          fread(tmp,1,length,FP1);");
      fprintf(Outfile,"%s\n","          fwrite(tmp,1,length,FP2);");
      fprintf(Outfile,"%s\n","        }");
      fprintf(Outfile,"%s\n","      if(overage>0)");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","          fread(tmp,1,overage,FP1);");
      fprintf(Outfile,"%s\n","          fwrite(tmp,1,overage,FP2);");
      fprintf(Outfile,"%s\n","        }");
      fprintf(Outfile,"%s\n","      fclose(FP2); fclose(FP1);");
      fprintf(Outfile,"%s\n","      if(tmp) free(tmp);");
      fprintf(Outfile,"%s\n","      struct stat st;");
      fprintf(Outfile,"%s\n","      if(stat(InFile, &st) != -1)");
      fprintf(Outfile,"%s\n","        chmod(TmpFile,st.st_mode);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Str_Cmp)
    {
      fprintf(Outfile,"%s\n","int str_cmp (char *a, char *b)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int counter=0;");
      fprintf(Outfile,"%s\n","  for(;;)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","    if((a[counter]^b[counter]))");
      fprintf(Outfile,"%s\n","     {");
      fprintf(Outfile,"%s\n","      if((UINT) a[counter]>= (UINT) b[counter])");
      fprintf(Outfile,"%s\n","      return  1;");
      fprintf(Outfile,"%s\n","      return -1;");
      fprintf(Outfile,"%s\n","     }");
      fprintf(Outfile,"%s\n","    if(!a[counter]) return 0;");
      fprintf(Outfile,"%s\n","    counter++;");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Eof)
    {
      fprintf(Outfile,"%s\n","int EoF (FILE* stream)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int c, status = ((c = fgetc(stream)) == EOF);");
      fprintf(Outfile,"%s\n","  ungetc(c,stream);");
      fprintf(Outfile,"%s\n","  return status;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Cint)
    {
      fprintf(Outfile,"%s\n","int Cint (double A)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  return (A >=0 ? (int)(A+0.5) : (int)(A-0.5));");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Clng)
    {
      fprintf(Outfile,"%s\n","long CLNG (double A)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  float   r=.5;");
      fprintf(Outfile,"%s\n","  double  a=A-(long)A;");
      fprintf(Outfile,"%s\n","  if(A<0) { r=-.5; a=-a; }");
      fprintf(Outfile,"%s\n","  if(((long)A % 2)==0&&a<=.5)");
      fprintf(Outfile,"%s\n","    return (long)A;");
      fprintf(Outfile,"%s\n","  else");
      fprintf(Outfile,"%s\n","    return (long)(A+r);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Left)
    {
      fprintf(Outfile,"%s\n","char *left (char *S, int length)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int tmplen = strlen(S);");
      fprintf(Outfile,"%s\n","  if(length<1) return BCX_TmpStr(1);");
      fprintf(Outfile,"%s\n","  if(length<tmplen) tmplen=length;");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(tmplen);");
      fprintf(Outfile,"%s\n","  return (char*)memcpy(strtmp,S,tmplen);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Right)
    {
      fprintf(Outfile,"%s\n","char *right (char *S, int length)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int tmplen = strlen(S);");
      fprintf(Outfile,"%s\n","  char *BCX_RetStr = BCX_TmpStr(tmplen);");
      fprintf(Outfile,"%s\n","  tmplen -= length;");
      fprintf(Outfile,"%s\n","  if (tmplen<0) tmplen = 0;");
      fprintf(Outfile,"%s\n","  return strcpy(BCX_RetStr, &S[tmplen]);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Rpad)
    {
      fprintf(Outfile,"%s\n","char *rpad (char *a, int L, int c)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp;");
      fprintf(Outfile,"%s\n","  int s = strlen(a);");
      fprintf(Outfile,"%s\n","  if((L-s)<1) return a;");
      fprintf(Outfile,"%s\n","  strtmp=BCX_TmpStr(L);");
      fprintf(Outfile,"%s\n","  strcpy(strtmp,a);");
      fprintf(Outfile,"%s\n","  memset(&strtmp[s],c,(L-s));");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Lpad)
    {
      fprintf(Outfile,"%s\n","char *lpad (char *a, int L, int c)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp;");
      fprintf(Outfile,"%s\n","  L=L-strlen(a);");
      fprintf(Outfile,"%s\n","  if(L<1) return a;");
      fprintf(Outfile,"%s\n","  strtmp = BCX_TmpStr(L);");
      fprintf(Outfile,"%s\n","  memset(strtmp,c,L);");
      fprintf(Outfile,"%s\n","  return strcat(strtmp,a);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Mid)
    {
      fprintf(Outfile,"%s\n","char *mid (char *S, int start, int length)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp;");
      fprintf(Outfile,"%s\n","  int tmplen = strlen(S);");
      fprintf(Outfile,"%s\n","  if(start>tmplen||start<1) return BCX_TmpStr(1);");
      fprintf(Outfile,"%s\n","  if (length<0 || length>(tmplen-start)+1)");
      fprintf(Outfile,"%s\n","    length = (tmplen-start)+1;");
      fprintf(Outfile,"%s\n","  strtmp = BCX_TmpStr(length);");
      fprintf(Outfile,"%s\n","  return (char*)memcpy(strtmp,&S[start-1],length);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Trim)
    {
      fprintf(Outfile,"%s\n","char *trim (char *S)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  while(*S==32 || *S==9 || *S==10 || *S==11 || *S==13)");
      fprintf(Outfile,"%s\n","    S++;");
      fprintf(Outfile,"%s\n","  int i = strlen(S);");
      fprintf(Outfile,"%s\n","  while( i>0 && (S[i-1]==32 || S[i-1]==9 || S[i-1]==10");
      fprintf(Outfile,"%s\n","             || S[i-1]==11 || S[i-1]==13))");
      fprintf(Outfile,"%s\n","    i--;");
      fprintf(Outfile,"%s\n","  char *strtmp=BCX_TmpStr(i);");
      fprintf(Outfile,"%s\n","  return (char*)memcpy(strtmp,S,i);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Ltrim)
    {
      fprintf(Outfile,"%s\n","char *ltrim (char *S, char c)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(S[0]==0) return S;");
      fprintf(Outfile,"%s\n","  while((*S==32 || *S==c) && *S !=0) S++;");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(strlen(S));");
      fprintf(Outfile,"%s\n","  return strcpy(strtmp,S);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Rtrim)
    {
      fprintf(Outfile,"%s\n","char *rtrim (char *S,char c)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(S[0]==0) return S;");
      fprintf(Outfile,"%s\n","  int i = strlen(S);");
      fprintf(Outfile,"%s\n","  while(i>0 && (S[i-1]==c || S[i-1]==32))");
      fprintf(Outfile,"%s\n","    i--;");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(i);");
      fprintf(Outfile,"%s\n","  return (char*)memcpy(strtmp,S,i);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Strim)
    {
      fprintf(Outfile,"%s\n","char *strim (char *src)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(strlen(src));");
      fprintf(Outfile,"%s\n","  char *dst = strtmp;");
      fprintf(Outfile,"%s\n","  while (isspace((unsigned char)*src)) src++;");
      fprintf(Outfile,"%s\n","  do");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    while (*src && !isspace((unsigned char)*src)) *dst++ = *src++;");
      fprintf(Outfile,"%s\n","    if (*src)");
      fprintf(Outfile,"%s\n","      {");
      fprintf(Outfile,"%s\n","        *dst++ = *src++;");
      fprintf(Outfile,"%s\n","        while (isspace((unsigned char)*src)) src++;");
      fprintf(Outfile,"%s\n","      }");
      fprintf(Outfile,"%s\n","  } while (*src);");
      fprintf(Outfile,"%s\n","  if (isspace((unsigned char)*(--dst))) *dst = 0;");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Command)
    {
      fprintf(Outfile,"%s\n","char *command (int nArg)");
      fprintf(Outfile,"%s\n"," {");
      fprintf(Outfile,"%s\n"," int i = 0;");
      fprintf(Outfile,"%s\n"," char *retstr=BCX_TmpStr(1);");
      fprintf(Outfile,"%s\n"," if(nArg < i) // return entire commandline");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      retstr = BCX_TmpStr(G_argc * 2048);");
      fprintf(Outfile,"%s\n","      for(i=1; i < G_argc; i++)");
      fprintf(Outfile,"%s\n","         {");
      fprintf(Outfile,"%s\n","         strcat(retstr, G_argv[i]);");
      fprintf(Outfile,"%s\n","         strcat(retstr, SPC);");
      fprintf(Outfile,"%s\n","         }");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n"," else if(nArg < G_argc)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      retstr = BCX_TmpStr(strlen(G_argv[nArg]) + 1);");
      fprintf(Outfile,"%s\n","      strcpy(retstr, G_argv[nArg]);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n"," return retstr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Extract)
    {
      fprintf(Outfile,"%s\n","char *extract (char *mane, char *match)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *a;");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(strlen(mane));");
      fprintf(Outfile,"%s\n","  if(*match!=0)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      a=_strstr_(mane,match);");
      fprintf(Outfile,"%s\n","      if(a) return (char*)memcpy(strtmp,mane,a-mane);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  return strcpy(strtmp,mane);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Remain)
    {
      fprintf(Outfile,"%s\n","char *remain (char *mane, char *mat)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *p = strstr(mane,mat);");
      fprintf(Outfile,"%s\n","  if(p)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    p+=(strlen(mat));");
      fprintf(Outfile,"%s\n","    return p;");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s\n","  return mane;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Replace)
    {
      fprintf(Outfile,"%s\n","char *replace (char *src, char *pat, char *rep)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  size_t patsz, repsz, tmpsz, delta;");
      fprintf(Outfile,"%s\n","  char *strtmp, *p, *q, *r;");
      fprintf(Outfile,"%s\n","  if (!pat || !*pat)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     strtmp = BCX_TmpStr(strlen(src));");
      fprintf(Outfile,"%s\n","     if (!strtmp) return NULL;");
      fprintf(Outfile,"%s\n","     return strcpy(strtmp, src);");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  repsz = strlen(rep);");
      fprintf(Outfile,"%s\n","  patsz = strlen(pat);");
      fprintf(Outfile,"%s\n","  for (tmpsz=0, p=src; (q=_strstr_(p,pat))!=0; p=q+patsz)");
      fprintf(Outfile,"%s\n","   tmpsz += (size_t) (q - p) + repsz;");
      fprintf(Outfile,"%s\n","   tmpsz += strlen(p);");
      fprintf(Outfile,"%s\n","   strtmp = BCX_TmpStr(tmpsz);");
      fprintf(Outfile,"%s\n","   if (!strtmp) return NULL;");
      fprintf(Outfile,"%s\n","    for (r=strtmp,p=src; (q=_strstr_(p,pat))!=0;p=q+patsz)");
      fprintf(Outfile,"%s\n","     {");
      fprintf(Outfile,"%s\n","       delta = (size_t) (q-p);");
      fprintf(Outfile,"%s\n","       memcpy(r,p,delta); r += delta;");
      fprintf(Outfile,"%s\n","       strcpy(r,rep);      r += repsz;");
      fprintf(Outfile,"%s\n","     }");
      fprintf(Outfile,"%s\n","  strcpy(r,p);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Reverse)
    {
      fprintf(Outfile,"%s\n","char *reverse (char *s)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int j=strlen(s);");
      fprintf(Outfile,"%s\n","  char *rstr = BCX_TmpStr(j);");
      fprintf(Outfile,"%s\n","  while(j)  rstr[--j] = *(s++);");
      fprintf(Outfile,"%s\n","  return rstr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Findfirst)
    {
      fprintf(Outfile,"%s\n","char *findfirst (char *filespec, FILE_FIND_DATA *FindData)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  struct dirent *dp;");
      fprintf(Outfile,"%s\n","  struct stat st;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  if(FindData->FileHandle)");
      fprintf(Outfile,"%s\n","    closedir(FindData->FileHandle);");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  strcpy(FindData->path, BcxSplitPath(filespec, FDRV|FPATH));");
      fprintf(Outfile,"%s\n","  strcpy(FindData->cFileSpec,BcxSplitPath(filespec, FNAME|FEXT));");
      fprintf(Outfile,"%s%s%s\n","  if(*FindData->path==0) strcpy(FindData->path, ",enc("."),");");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  FindData->FileHandle=opendir(FindData->path);");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  while(FindData->FileHandle)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      dp=readdir(FindData->FileHandle);");
      fprintf(Outfile,"%s\n","      if(dp==NULL) break;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","      if(like(dp->d_name,FindData->cFileSpec))");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","          strcpy(FindData->cFileName,dp->d_name);");
      fprintf(Outfile,"%s\n","          lstat(join(2,FindData->path,dp->d_name), &st);");
      fprintf(Outfile,"%s\n","          FindData->dwFileAttributes = st.st_mode;");
      fprintf(Outfile,"%s\n","          return FindData->cFileName;");
      fprintf(Outfile,"%s\n","        }");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  *FindData->cFileName=0;");
      fprintf(Outfile,"%s\n","  return FindData->cFileName;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Findnext)
    {
      fprintf(Outfile,"%s\n","char *findnext (FILE_FIND_DATA *FindData)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  struct dirent *dp;");
      fprintf(Outfile,"%s\n","  struct stat st;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  while(FindData->FileHandle)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      dp=readdir(FindData->FileHandle);");
      fprintf(Outfile,"%s\n","      if(dp==NULL) break;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","      if(like(dp->d_name,FindData->cFileSpec))");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","          strcpy(FindData->cFileName,dp->d_name);");
      fprintf(Outfile,"%s\n","          lstat(join(2,FindData->path,dp->d_name), &st);");
      fprintf(Outfile,"%s\n","          FindData->dwFileAttributes = st.st_mode;");
      fprintf(Outfile,"%s\n","          return FindData->cFileName;");
      fprintf(Outfile,"%s\n","        }");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  *FindData->cFileName=0;");
      fprintf(Outfile,"%s\n","  return FindData->cFileName;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Ucase)
    {
      fprintf(Outfile,"%s\n","char *ucase (char *S)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(strlen(S));");
      fprintf(Outfile,"%s\n","  return _strupr_(strcpy(strtmp,S));");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Lcase)
    {
      fprintf(Outfile,"%s\n","char *lcase (char *S)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(strlen(S));");
      fprintf(Outfile,"%s\n","  return _strlwr_(strcpy(strtmp,S));");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Mcase)
    {
      fprintf(Outfile,"%s\n","char *mcase (char *S)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(strlen(S)+1);");
      fprintf(Outfile,"%s\n","  char *s = strtmp;");
      fprintf(Outfile,"%s\n","  _strlwr_(strcpy(strtmp,S));");
      fprintf(Outfile,"%s\n","  while(*s)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    if(islower(*s))");
      fprintf(Outfile,"%s\n","      {");
      fprintf(Outfile,"%s\n","        *s-=32;");
      fprintf(Outfile,"%s\n","        while(isalpha(*++s));");
      fprintf(Outfile,"%s\n","      }");
      fprintf(Outfile,"%s\n","     s++;");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Remove)
    {
      fprintf(Outfile,"%s\n","char *RemoveStr (char *a, char *b)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp, *p, *d;");
      fprintf(Outfile,"%s\n","  int  tmplen;");
      fprintf(Outfile,"%s\n","  strtmp = d = BCX_TmpStr(strlen(a));");
      fprintf(Outfile,"%s\n","  if(!b || !*b) return strcpy(strtmp,a);");
      fprintf(Outfile,"%s\n","  p=_strstr_(a,b); tmplen = strlen(b);");
      fprintf(Outfile,"%s\n","  while(p)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     memcpy(d,a,p-a);");
      fprintf(Outfile,"%s\n","     d+= (p-a);");
      fprintf(Outfile,"%s\n","     a=p+tmplen;");
      fprintf(Outfile,"%s\n","     p=_strstr_(a,b);");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  strcpy(d,a);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_IRemove)
    {
      fprintf(Outfile,"%s\n","char *IRemoveStr (char *a, char *b)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp, *p, *d;");
      fprintf(Outfile,"%s\n","  int  tmplen;");
      fprintf(Outfile,"%s\n","  strtmp = d = BCX_TmpStr(strlen(a));");
      fprintf(Outfile,"%s\n","  if(!b || !*b) return strcpy(strtmp,a);");
      fprintf(Outfile,"%s\n","  p=_stristr_(a,b); tmplen = strlen(b);");
      fprintf(Outfile,"%s\n","  while(p)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     memcpy(d,a,p-a);");
      fprintf(Outfile,"%s\n","     d+= (p-a);");
      fprintf(Outfile,"%s\n","     a=p+tmplen;");
      fprintf(Outfile,"%s\n","     p=_stristr_(a,b);");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  strcpy(d,a);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Ins)
    {
      fprintf(Outfile,"%s\n","char *ins (char *S, int i, char *a)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int j = strlen(S);");
      fprintf(Outfile,"%s\n","  if(i<1 || i>j+1) return S;");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(j + strlen(a));");
      fprintf(Outfile,"%s\n","  memcpy(strtmp,S,--i);");
      fprintf(Outfile,"%s\n","  strcpy(&strtmp[i],a);");
      fprintf(Outfile,"%s\n","  return strcat(strtmp,&S[i]);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Del)
    {
      fprintf(Outfile,"%s\n","char *del (char *S, int i, int j)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int ln = strlen(S);");
      fprintf(Outfile,"%s\n","  if(i<1 || i>ln) return S;");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(ln);");
      fprintf(Outfile,"%s\n","  memcpy(strtmp,S,--i);");
      fprintf(Outfile,"%s\n","  return strcat(strtmp,&S[i+j]);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Str)
    {
      fprintf(Outfile,"%s\n","char *str (double d)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(16);");
      fprintf(Outfile,"%s%s%s\n","  sprintf(strtmp,",D1,",d);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Strl)
    {
      fprintf(Outfile,"%s\n","char *strl (long double d)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(27);");
      fprintf(Outfile,"%s%s%s\n","  sprintf(strtmp,",D2,",d);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Curdir)
    {
      fprintf(Outfile,"%s\n","char *curdir (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(2048);");
      fprintf(Outfile,"%s\n","  char *res=getcwd(strtmp, 1024);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Hex)
    {
      fprintf(Outfile,"%s\n","char *hex (int a)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(16);");
      fprintf(Outfile,"%s%s%s\n","  sprintf(strtmp,",enc("%02X"),",a);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Tempdir)
    {
      fprintf(Outfile,"%s\n","char *tempdir (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(2048);");
      fprintf(Outfile,"%s%s%s\n","  if(!Exist(",enc("/tmp/mbc.compiler"),")) {");
      fprintf(Outfile,"%s%s%s\n","    mkdir (",enc("/tmp/mbc.compiler"),",0755);");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s%s%s\n","  strcpy(strtmp,",enc("/tmp/mbc.compiler"),");");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Sysdir)
    {
      fprintf(Outfile,"%s\n","char *sysdir (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(2048);");
      fprintf(Outfile,"%s\n","  GetSystemDirectory (strtmp,2048);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Repeat)
    {
      fprintf(Outfile,"%s\n","char *repeat (int count, char *a)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr((1+count)*strlen(a));");
      fprintf(Outfile,"%s\n","  while(count-->0) strtmp = strcat(strtmp, a);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_String)
    {
      fprintf(Outfile,"%s\n","char *stringx (int count, int a)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(count<1) return BCX_TmpStr(1);");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(count);");
      fprintf(Outfile,"%s\n","  return (char*)memset(strtmp,a,count);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Shell)
    {
      fprintf(Outfile,"%s\n","void Shell (char *cmd)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int res=system(cmd);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Space)
    {
      fprintf(Outfile,"%s\n","char *space (int count)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(count<1) return BCX_TmpStr(1);");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(count);");
      fprintf(Outfile,"%s\n","  return (char*)memset(strtmp,32,count);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Time)
    {
      fprintf(Outfile,"%s\n","char *timef (int t)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  time_t elapse_time;");
      fprintf(Outfile,"%s\n","  struct tm *tp;");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(256);");
      fprintf(Outfile,"%s\n","  time (&elapse_time);");
      fprintf(Outfile,"%s\n","  tp = localtime(&elapse_time);");
      fprintf(Outfile,"%s\n","  switch (t)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","   case 0:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T0,",tp); break;");
      fprintf(Outfile,"%s\n","   case 1:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T1,",tp); break;");
      fprintf(Outfile,"%s\n","   case 2:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T2,",tp); break;");
      fprintf(Outfile,"%s\n","   case 3:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T3,",tp); break;");
      fprintf(Outfile,"%s\n","   case 4:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T4,",tp); break;");
      fprintf(Outfile,"%s\n","   case 5:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T5,",tp); break;");
      fprintf(Outfile,"%s\n","   case 6:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T6,",tp); break;");
      fprintf(Outfile,"%s\n","   case 7:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T7,",tp); break;");
      fprintf(Outfile,"%s\n","   case 8:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T8,",tp); break;");
      fprintf(Outfile,"%s\n","   case 9:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T9,",tp); break;");
      fprintf(Outfile,"%s\n","   case 10:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T10,",tp); break;");
      fprintf(Outfile,"%s\n","   case 11:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T11,",tp); break;");
      fprintf(Outfile,"%s\n","   case 12:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T12,",tp); break;");
      fprintf(Outfile,"%s\n","   case 13:");
      fprintf(Outfile,"%s%s%s\n","   strftime(strtmp,256,",T13,",tp); break;");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Enclose)
    {
      fprintf(Outfile,"%s\n","char *enc (char *A, int L, int R)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *BCX_RetStr = BCX_TmpStr(strlen(A)+3);");
      fprintf(Outfile,"%s\n","  if(L==0) L=34;");
      fprintf(Outfile,"%s\n","  if(R==0) R=L;");
      fprintf(Outfile,"%s%s%s%s%s\n","  sprintf(BCX_RetStr,",enc("%c%s%c%s"),",L,A,R,",enc("\0"),");");
      fprintf(Outfile,"%s\n","  return BCX_RetStr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Chr)
    {
      fprintf(Outfile,"%s\n","char *chr (int a,int b,int c,int d,int e,int f,int g,int h,int i,int j)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(11);");
      fprintf(Outfile,"%s\n","  strtmp[0]  = a;");
      fprintf(Outfile,"%s\n","  strtmp[1]  = b;");
      fprintf(Outfile,"%s\n","  strtmp[2]  = c;");
      fprintf(Outfile,"%s\n","  strtmp[3]  = d;");
      fprintf(Outfile,"%s\n","  strtmp[4]  = e;");
      fprintf(Outfile,"%s\n","  strtmp[5]  = f;");
      fprintf(Outfile,"%s\n","  strtmp[6]  = g;");
      fprintf(Outfile,"%s\n","  strtmp[7]  = h;");
      fprintf(Outfile,"%s\n","  strtmp[8]  = i;");
      fprintf(Outfile,"%s\n","  strtmp[9]  = j;");
      fprintf(Outfile,"%s\n","  strtmp[10] = 0;");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_VChr)
    {
      fprintf(Outfile,"%s\n","char *vchr(int charcount, ...)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int c = 0, i = charcount;");
      fprintf(Outfile,"%s\n","  char *s_ = BCX_TmpStr(charcount + 1);");
      fprintf(Outfile,"%s\n","  va_list marker;");
      fprintf(Outfile,"%s\n","  s_[i] = 0;");
      fprintf(Outfile,"%s\n","  va_start(marker, charcount);");
      fprintf(Outfile,"%s\n","  while(i-- > 0) s_[c++] = va_arg(marker,int);");
      fprintf(Outfile,"%s\n","  va_end(marker);");
      fprintf(Outfile,"%s\n","  return s_;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Join)
    {
      fprintf(Outfile,"%s\n","char * join(int n, ...)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int i = n, tmplen = 0;");
      fprintf(Outfile,"%s\n","  char *strtmp, *s_;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  va_list marker;");
      fprintf(Outfile,"%s\n","  va_start(marker, n); // Initialize variable arguments");
      fprintf(Outfile,"%s\n","  while(i-- > 0)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    s_ = va_arg(marker, char *);");
      fprintf(Outfile,"%s\n","    if(s_) tmplen += strlen(s_);");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s\n","  strtmp = BCX_TmpStr(tmplen);");
      fprintf(Outfile,"%s\n","  va_end(marker); // Reset variable arguments");
      fprintf(Outfile,"%s\n","  i = n;");
      fprintf(Outfile,"%s\n","  va_start(marker, n); // Initialize variable arguments");
      fprintf(Outfile,"%s\n","  while(i-- > 0)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    s_ = va_arg(marker, char *);");
      fprintf(Outfile,"%s\n","    if(s_) strcat(strtmp, s_);");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s\n","  va_end(marker); // Reset variable arguments");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Environ)
    {
      fprintf(Outfile,"%s\n","char* Environ(char *S)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp, *tmp;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  tmp = getenv(S);");
      fprintf(Outfile,"%s\n","  if(tmp != NULL) {");
      fprintf(Outfile,"%s\n","    strtmp = BCX_TmpStr(strlen(tmp)+1);");
      fprintf(Outfile,"%s\n","    return strcpy(strtmp, tmp);");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s\n","  return BCX_TmpStr(1);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Oct)
    {
      fprintf(Outfile,"%s\n","char *oct (int a)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(2048);");
      fprintf(Outfile,"%s%s%s\n","  sprintf(strtmp,",O1,",a);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Bin)
    {
      fprintf(Outfile,"%s\n","char* Bin(int number)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(2048);");
      fprintf(Outfile,"%s\n","   itoa(number,strtmp,2);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Pause)
    {
      fprintf(Outfile,"%s\n","void Pause(void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s%s%s%s%s\n","  printf(",enc("\\n%s\\n"),",",enc("Press any key to continue . . ."),");");
      fprintf(Outfile,"%s\n","  _getch_(TRUE);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Keypress)
    {
      fprintf(Outfile,"%s\n","int keypress(void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  return _getch_(TRUE);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Inkey)
    {
      fprintf(Outfile,"%s\n","char* inkey(void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(2);");
      fprintf(Outfile,"%s\n","  strtmp[0] = _getch_(FALSE);");
      fprintf(Outfile,"%s\n","  if(strtmp[0] == -1) strtmp[0] = 0;");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_InkeyD)
    {
      fprintf(Outfile,"%s\n","int inkeyd(void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  return _getch_(TRUE);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Instat)
    {
      fprintf(Outfile,"%s\n","int kbhit(void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  struct termios oldt, newt;");
      fprintf(Outfile,"%s\n","  int ch;");
      fprintf(Outfile,"%s\n","	int oldf;");
      fprintf(Outfile,"%s\n","  tcgetattr(STDIN_FILENO, &oldt);");
      fprintf(Outfile,"%s\n","  newt = oldt;");
      fprintf(Outfile,"%s\n","  newt.c_lflag &= ~(ICANON | ECHO);");
      fprintf(Outfile,"%s\n","  tcsetattr(STDIN_FILENO, TCSANOW, &newt);");
      fprintf(Outfile,"%s\n","  oldf = fcntl(STDIN_FILENO, F_GETFL, 0);");
      fprintf(Outfile,"%s\n","  fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);");
      fprintf(Outfile,"%s\n","  ch = getchar();");
      fprintf(Outfile,"%s\n","  tcsetattr(STDIN_FILENO, TCSANOW, &oldt);");
      fprintf(Outfile,"%s\n","  fcntl(STDIN_FILENO, F_SETFL, oldf);");
      fprintf(Outfile,"%s\n","  if(ch != EOF)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    ungetc(ch, stdin);");
      fprintf(Outfile,"%s\n","    return 1;");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s\n","  return 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_GetCh)
    {
      fprintf(Outfile,"%s\n","int _getch_(int waitkey)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  struct termios initial_settings, new_settings;");
      fprintf(Outfile,"%s\n","  unsigned char ch;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  tcgetattr(0,&initial_settings);");
      fprintf(Outfile,"%s\n","  new_settings = initial_settings;");
      fprintf(Outfile,"%s\n","  new_settings.c_lflag &= ~ICANON;");
      fprintf(Outfile,"%s\n","  new_settings.c_lflag &= ~ECHO;");
      fprintf(Outfile,"%s\n","  new_settings.c_lflag &= ~ISIG;");
      fprintf(Outfile,"%s\n","  new_settings.c_cc[VMIN] = waitkey;");
      fprintf(Outfile,"%s\n","  new_settings.c_cc[VTIME] = 0;");
      fprintf(Outfile,"%s\n","  tcsetattr(0, TCSANOW, &new_settings);");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","    //read(0,&ch,1);");
      fprintf(Outfile,"%s\n","    ch = getchar();");
      fprintf(Outfile,"%s\n","  tcsetattr(0, TCSANOW, &initial_settings);");
      fprintf(Outfile,"%s\n","  return ch;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Now)
    {
      fprintf(Outfile,"%s\n","char *now (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  time_t elapse_time;");
      fprintf(Outfile,"%s\n","  struct tm *tp;");
      fprintf(Outfile,"%s\n","  char *strtmp = BCX_TmpStr(2048);");
      fprintf(Outfile,"%s\n","  time(&elapse_time);");
      fprintf(Outfile,"%s\n","  tp=localtime(&elapse_time);");
      fprintf(Outfile,"%s%s%s\n","  strftime(strtmp,256,",enc("%m/%d/%y %I:%M:%S: %p"),",tp);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}");
    }
  if(Use_AppExePath)
    {
      fprintf(Outfile,"%s\n","char *AppExePath (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char fullpath[MAX_PATH];");
      fprintf(Outfile,"%s\n","  int length;");
 #if defined (__APPLE__)
      fprintf(Outfile,"%s\n","  pid_t pid = getpid();");
      fprintf(Outfile,"%s\n","  length = proc_pidpath (pid, fullpath, sizeof(fullpath));");
 #else
      fprintf(Outfile,"%s%s%s\n","  length = readlink(",enc("/proc/self/exe"),", fullpath, MAX_PATH);");
 #endif
      fprintf(Outfile,"%s\n","  if(length < 1) return BCX_TmpStr(1);");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  fullpath[length] = 0;");
      fprintf(Outfile,"%s\n","  return BcxSplitPath(fullpath, FDRV|FPATH);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_AppExeName)
    {
      fprintf(Outfile,"%s\n","char *AppExeName (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  return BcxSplitPath(G_argv[0], FNAME|FEXT);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_TempFileName)
    {
      fprintf(Outfile,"%s\n","char * TempFileName (char *dr, char *prefix)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static unsigned int count;");
      fprintf(Outfile,"%s\n","  char *f, *tmpstr = BCX_TmpStr(MAX_PATH);");
      fprintf(Outfile,"%s\n","  int  i, length;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  if(!count) srand(time(0));");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  if(dr) strcpy(tmpstr, dr);");
      fprintf(Outfile,"%s\n","  length = strlen(tmpstr);");
      fprintf(Outfile,"%s\n","  if(length && (tmpstr[length-1] != '\\\\' && tmpstr[length-1] != '/'))");
      fprintf(Outfile,"%s\n","      tmpstr[length++] = '/';");
      fprintf(Outfile,"%s\n","  if(prefix) strcpy(&tmpstr[length], prefix);");
      fprintf(Outfile,"%s\n","  f = &tmpstr[strlen(tmpstr)];");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  do {");
      fprintf(Outfile,"%s\n","      count++;");
      fprintf(Outfile,"%s\n","      for(i=0; i<5; i+=1)");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","          do {");
      fprintf(Outfile,"%s\n","            f[i]=(char)(rnd()*122);");
      fprintf(Outfile,"%s\n","          }while((f[i]<65)||(f[i]>90&&f[i]<97));");
      fprintf(Outfile,"%s\n","        }");
      fprintf(Outfile,"%s%s%s\n","        snprintf(&f[5],3,",enc("%x"),", count);");
      fprintf(Outfile,"%s\n","    } while (Exist(tmpstr));");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  return tmpstr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Boolstr)
    {
      fprintf(Outfile,"%s\n","char * BoolStr (int a)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *BCX_RetStr=BCX_TmpStr(5);");
      fprintf(Outfile,"%s%s%s\n","  if(a) return strcpy(BCX_RetStr,",enc("True"),");");
      fprintf(Outfile,"%s%s%s\n","  return strcpy(BCX_RetStr,",enc("False"),");");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Using)
    {
      fprintf(Outfile,"%s\n","char *Using (char *Mask, double Num)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int Spaces = 0;");
      fprintf(Outfile,"%s\n","  int CntDec = 0;");
      fprintf(Outfile,"%s\n","  int Decimals = 0;");
      fprintf(Outfile,"%s\n","  int Dollar = 0;");
      fprintf(Outfile,"%s\n","  char* BCX_RetStr = BCX_TmpStr(512);");
      fprintf(Outfile,"%s\n","  char Buf_1[512]={0};");
      fprintf(Outfile,"%s\n","  char* p = Mask;");
      fprintf(Outfile,"%s\n","  char* r;");
      fprintf(Outfile,"%s\n","  int  len;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  while (*p)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    if (*p == 36) Dollar++;");
      fprintf(Outfile,"%s\n","    if (*p == 32) Spaces++;");
      fprintf(Outfile,"%s\n","    if ((*p == 32 || *p == 35)&& CntDec) Decimals++;");
      fprintf(Outfile,"%s\n","    if (*p == 46) CntDec = 1;");
      fprintf(Outfile,"%s\n","    p++;");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s%s%s\n","  sprintf(Buf_1,",enc("%1.*f"),",Decimals,Num);");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  len = strlen(Buf_1)-Decimals-(Decimals>0?1:0);");
      fprintf(Outfile,"%s\n","  r = BCX_RetStr+Dollar+Spaces;");
      fprintf(Outfile,"%s\n","  p = Buf_1;");
      fprintf(Outfile,"%s\n","  while (*p)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     *r++ = *p++;");
      fprintf(Outfile,"%s\n","     if (--len>2 && *(p-1) != '-' && len % 3 == 0)");
      fprintf(Outfile,"%s\n","       {");
      fprintf(Outfile,"%s\n","         *r++ = ',';");
      fprintf(Outfile,"%s\n","       }");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  if(Dollar) BCX_RetStr[Spaces]=36;");
      fprintf(Outfile,"%s\n","  if(Spaces) memset(BCX_RetStr,32,Spaces);");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  return BCX_RetStr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_SearchPath)
    {
      fprintf(Outfile,"%s\n","char *SEARCHPATH (char *szFile)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *BCX_RetStr=BCX_TmpStr(MAX_PATH+1);");
      fprintf(Outfile,"%s\n","  PCHAR lpbs=0;");
      fprintf(Outfile,"%s\n","  SearchPath(0,szFile,0,MAX_PATH,BCX_RetStr,&lpbs);");
      fprintf(Outfile,"%s\n","  if(lpbs) *lpbs=0;");
      fprintf(Outfile,"%s\n","  return BCX_RetStr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Instrrev)
    {
      fprintf(Outfile,"%s\n","int InstrRev (char *s, char *p, int os, int sens)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n"," int sl, pl, ox;");
      fprintf(Outfile,"%s\n"," int (*cmp)(const char *, const char *, size_t );");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," if (!s || !p)  return 0;");
      fprintf(Outfile,"%s\n"," sl  = strlen(s); pl  = strlen(p);");
      fprintf(Outfile,"%s\n"," if (os > sl || sl == 0 || pl == 0 || (ox = sl - pl) < 0)");
      fprintf(Outfile,"%s\n","   return 0;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," if (os <= 0)  ");
      fprintf(Outfile,"%s\n","   os = ox ;");
      fprintf(Outfile,"%s\n"," else if(os >= pl)");
      fprintf(Outfile,"%s\n","   os = os - pl ;");
      fprintf(Outfile,"%s\n"," else");
      fprintf(Outfile,"%s\n","   return 0;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," cmp = (sens ? strncasecmp : strncmp);");
      fprintf(Outfile,"%s\n"," do { if (cmp(s + os , p, pl) == 0)");
      fprintf(Outfile,"%s\n","       return os+1;");
      fprintf(Outfile,"%s\n","    } while (os--);");
      fprintf(Outfile,"%s\n"," return 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Instr)
    {
      fprintf(Outfile,"%s\n","int instr_b(char* mane,char* match,int offset,int sensflag)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *s;");
      fprintf(Outfile,"%s\n","  if (!mane || !match || ! *match || offset>(int)strlen(mane)) return 0;");
      fprintf(Outfile,"%s\n","  if (sensflag)");
      fprintf(Outfile,"%s\n","    s = _stristr_(offset>0 ? mane+offset-1 : mane,match);");
      fprintf(Outfile,"%s\n","  else");
      fprintf(Outfile,"%s\n","    s = _strstr_(offset>0 ? mane+offset-1 : mane,match);");
      fprintf(Outfile,"%s\n","  return s ? (int)(s-mane)+1 : 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(UseLCaseTbl)
    {
      fprintf(Outfile,"%s\n","char  *MakeLCaseTbl (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static char tbl[256];");
      fprintf(Outfile,"%s\n","  if(!tbl['a'])");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      int i; for (i=0; i < 256; i++)");
      fprintf(Outfile,"%s\n","        tbl[i] = (char)(int)tolower(i);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  return tbl;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Stristr)
    {
      fprintf(Outfile,"%s\n","char *_stristr_(char *String, char *Pattern)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int   mi=-1;");
      fprintf(Outfile,"%s\n","  char *LowCase = MakeLCaseTbl();");
      fprintf(Outfile,"%s\n","  while(Pattern[++mi])");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     if(String[mi]==0) return 0;");
      fprintf(Outfile,"%s\n","     if(LowCase[(unsigned char)String[mi]]!=LowCase[(unsigned char)Pattern[mi]])");
      fprintf(Outfile,"%s\n","       { String++; mi=-1; }");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  return String;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_StrStr)
    {
      fprintf(Outfile,"%s\n","char *_strstr_(char *String, char *Pattern)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int   mi=-1;");
      fprintf(Outfile,"%s\n","  while(Pattern[++mi])");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     if(String[mi]==0) return 0;");
      fprintf(Outfile,"%s\n","     if(String[mi]!=Pattern[mi])");
      fprintf(Outfile,"%s\n","       { String++; mi=-1; }");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  return String;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Inchr)
    {
      fprintf(Outfile,"%s\n","int inchr (char *A, char *B)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char* C=A;");
      fprintf(Outfile,"%s\n","  while(*C)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      if(*C==*B) return C-A+1;");
      fprintf(Outfile,"%s\n","      C++;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  return 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Asc)
    {
      fprintf(Outfile,"%s\n","extern int asc (char *z,int index)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  return (unsigned char) z[index];");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Sgn)
    {
      fprintf(Outfile,"%s\n","double sgn (double a)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(a<0) return -1;");
      fprintf(Outfile,"%s\n","  if(a>0) return  1;");
      fprintf(Outfile,"%s\n","  return  0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Round)
    {
      fprintf(Outfile,"%s\n","double Round (double n, int d)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  return (floor((n)*pow(10.0,(d))+0.5)/pow(10.0,(d)));");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Embed)
    {
      fprintf(Outfile,"%s\n","char* GetResource (int *resource)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *BCX_RetStr={0};");
      fprintf(Outfile,"%s\n","  static  char*  dat;");
      fprintf(Outfile,"%s\n","  memset(&dat,0,sizeof(char *));");
      fprintf(Outfile,"%s\n","  dat=(char*)resource;");
      fprintf(Outfile,"%s\n","  BCX_RetStr=BCX_TmpStr(strlen(dat));");
      fprintf(Outfile,"%s\n","  strcpy(BCX_RetStr,dat);");
      fprintf(Outfile,"%s\n","  return BCX_RetStr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Exist)
    {
      fprintf(Outfile,"%s\n","bool Exist (char *szFilePath)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int retstat;");
      fprintf(Outfile,"%s\n","  struct stat sb;");
      fprintf(Outfile,"%s\n","  retstat = stat(szFilePath, &sb);");
      fprintf(Outfile,"%s\n","  if(retstat != -1)");
      fprintf(Outfile,"%s\n","    return TRUE;");
      fprintf(Outfile,"%s\n","  return FALSE;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Tally)
    {
      fprintf(Outfile,"%s\n","int tally (char *szLine, char *szChar, int sensflag)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(!*szChar) return 0;");
      fprintf(Outfile,"%s\n","  int   mlen = strlen(szChar);");
      fprintf(Outfile,"%s\n","  int  iCount = 0;");
      fprintf(Outfile,"%s\n","  char *p = (sensflag == 0 ? _strstr_(szLine, szChar) : _stristr_(szLine, szChar));");
      fprintf(Outfile,"%s\n","  while (p)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    iCount++;");
      fprintf(Outfile,"%s\n","    p+=mlen;");
      fprintf(Outfile,"%s\n"," p = (sensflag == 0 ? _strstr_(p, szChar) : _stristr_(p, szChar));");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s\n","  return iCount;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Timer)
    {
      fprintf(Outfile,"%s\n","float timer (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  return ((double)clock()/CLOCKS_PER_SEC);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Rnd)
    {
      fprintf(Outfile,"%s\n","float rnd (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  return (float)rand()/RAND_MAX;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Exp)
    {
      fprintf(Outfile,"%s\n","double Exp (double arg)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  return pow(2.718281828459045,arg);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Randomize)
    {
      fprintf(Outfile,"%s\n","void randomize (unsigned int seed)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  srand(seed);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Max)
    {
      fprintf(Outfile,"%s\n","double _MAX_ (double a, double b)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(a>b)");
      fprintf(Outfile,"%s\n","  return a;");
      fprintf(Outfile,"%s\n","  return b;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Min)
    {
      fprintf(Outfile,"%s\n","double _MIN_ (double a, double b)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(a<b)");
      fprintf(Outfile,"%s\n","  return a;");
      fprintf(Outfile,"%s\n","  return b;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Locate)
    {
      fprintf(Outfile,"%s\n","void locate (int row,int col,int show,int shape)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s%s%s%s%s%s%s%s%s\n","  printf(",enc("%c%s%u%s%u%s"),",27,",enc("["),",row,",enc(";"),",col,",enc("H"),");");
      fprintf(Outfile,"%s\n","  // find cursor size/shape function!");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Cls)
    {
      fprintf(Outfile,"%s\n","void cls (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s%s%s%s%s%s%s\n","  printf(",enc("%s%s%s%s"),",ESC,",enc("[2J"),",ESC,",enc("[H"),");");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Color)
    {
      fprintf(Outfile,"%s\n","void color (int fg,int bg)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s%s%s%s%s%s%s%s%s\n","  printf(",enc("%c%s%u%s%u%s"),",27,",enc("["),",30+(fg&7),",enc(";"),",40+(bg&7),",enc("m"),");");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Midstr)
    {
      fprintf(Outfile,"%s\n","void midstr (char *src, int st, int length, char *rep)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int srclen = strlen(src);");
      fprintf(Outfile,"%s\n","  if(st>srclen++ || st<1) return;");
      fprintf(Outfile,"%s\n","  int replen = strlen(rep);");
      fprintf(Outfile,"%s\n","  if(replen < length || length==-1) length=replen;");
      fprintf(Outfile,"%s\n","  if((st+length) > srclen) length=srclen-st;");
      fprintf(Outfile,"%s\n","  memcpy(&src[st-1],rep,length);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Swap)
    {
      fprintf(Outfile,"%s\n","void swap ( UCHAR* A, UCHAR* B, int length)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  UCHAR t;");
      fprintf(Outfile,"%s\n","  while(length--)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    t = *A;");
      fprintf(Outfile,"%s\n","    *(A++) = *B;");
      fprintf(Outfile,"%s\n","    *(B++) = t;");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Like)
    {
      fprintf(Outfile,"%s\n","int like (char *raw, char *pat)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n"," char a, b, d;");
      fprintf(Outfile,"%s\n"," char *r, *p;");
      fprintf(Outfile,"%s\n"," int star = 0;");
      fprintf(Outfile,"%s\n"," for(;;) {");
      fprintf(Outfile,"%s\n","   if ((d = *pat++)==0) return (star || !*raw);");
      fprintf(Outfile,"%s\n","   else if (d == '*') star = 1;");
      fprintf(Outfile,"%s\n","   else if (d == '?') { if (!*raw++) return 0; }");
      fprintf(Outfile,"%s\n","   else break;");
      fprintf(Outfile,"%s\n"," }");
      fprintf(Outfile,"%s\n"," b = d;");
      fprintf(Outfile,"%s\n"," do if ((a = *raw++) == b) {");
      fprintf(Outfile,"%s\n","   r = raw;");
      fprintf(Outfile,"%s\n","   p = pat;");
      fprintf(Outfile,"%s\n","   do {");
      fprintf(Outfile,"%s\n","     if ((d = *p++) == '*')");
      fprintf(Outfile,"%s\n","       if (like(r, p - 1)) return 1;");
      fprintf(Outfile,"%s\n","       else break;");
      fprintf(Outfile,"%s\n","     else if (!d) {");
      fprintf(Outfile,"%s\n","       if (!*r) return 1;");
      fprintf(Outfile,"%s\n","       else break;");
      fprintf(Outfile,"%s\n","     }");
      fprintf(Outfile,"%s\n","   } while (*r++ == d || d == '?');");
      fprintf(Outfile,"%s\n"," } while (star && a);");
      fprintf(Outfile,"%s\n"," return 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Lof)
    {
      fprintf(Outfile,"%s\n","DWORD lof (char *FileName)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  int retstat;");
      fprintf(Outfile,"%s\n","  struct stat sb;");
      fprintf(Outfile,"%s\n","  retstat = stat(FileName, &sb);");
      fprintf(Outfile,"%s\n","  if(retstat != -1)");
      fprintf(Outfile,"%s\n","    return sb.st_size;");
      fprintf(Outfile,"%s\n","  return 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Iif)
    {
      fprintf(Outfile,"%s\n","double iif (bool cond, double tp, double fp)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(cond) return tp;");
      fprintf(Outfile,"%s\n","  return fp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_sziif)
    {
      fprintf(Outfile,"%s\n","char * sziif (bool i, char *a, char *b)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(i) return a;");
      fprintf(Outfile,"%s\n","  return b;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_DynamicA)
    {
      fprintf(Outfile,"%s\n","void *CreateArr(void *a, int elem_size, int update, int num_dims, ... )");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  va_list ap;");
      fprintf(Outfile,"%s\n","  void   *RetPtr;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  va_start(ap, num_dims);");
      fprintf(Outfile,"%s\n","  RetPtr = CreateArr_internal(a, elem_size, update, num_dims, ap);");
      fprintf(Outfile,"%s\n","  va_end(ap);");
      fprintf(Outfile,"%s\n","  return (RetPtr);");
      fprintf(Outfile,"%s\n","}\n\n");
      fprintf(Outfile,"%s\n","void *CreateArr_internal(void *a, int elem_size, int update, int num_dims, va_list ap)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  size_t s, s1, s2;");
      fprintf(Outfile,"%s\n","  void **vp;");
      fprintf(Outfile,"%s\n","  va_list marker;");
      fprintf(Outfile,"%s\n"," ");
      fprintf(Outfile,"%s\n","#ifdef va_copy");
      fprintf(Outfile,"%s\n","  va_copy(marker, ap);");
      fprintf(Outfile,"%s\n","#else");
      fprintf(Outfile,"%s\n","  marker = ap;");
      fprintf(Outfile,"%s\n","#endif");
      fprintf(Outfile,"%s\n","  s = va_arg(marker, size_t);");
      fprintf(Outfile,"%s\n","  s2 = s + 2;");
      fprintf(Outfile,"%s\n","  if(num_dims == 1)");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","    if(update && a)");
      fprintf(Outfile,"%s\n","        a=realloc(a,s2*elem_size);");
      fprintf(Outfile,"%s\n","     else");
      fprintf(Outfile,"%s\n","        a=calloc(s2,elem_size);");
      fprintf(Outfile,"%s\n","    return a;");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n"," else");
      fprintf(Outfile,"%s\n","    if(update && a)");
      fprintf(Outfile,"%s\n","     {");
      fprintf(Outfile,"%s\n","     s1 = 0;");
      fprintf(Outfile,"%s\n","     vp = (void**)a;");
      fprintf(Outfile,"%s\n","     while(*vp && s1 <= s)");
      fprintf(Outfile,"%s\n","       {");
      fprintf(Outfile,"%s\n","       vp++;");
      fprintf(Outfile,"%s\n","       s1++;");
      fprintf(Outfile,"%s\n","       }");
      fprintf(Outfile,"%s\n","     if(s1 > s)");
      fprintf(Outfile,"%s\n","       {");
      fprintf(Outfile,"%s\n","       vp--;");
      fprintf(Outfile,"%s\n","        DestroyArr(vp, num_dims, 0);");
      fprintf(Outfile,"%s\n","       }");
      fprintf(Outfile,"%s\n","      a=realloc(a,s2*sizeof(int));");
      fprintf(Outfile,"%s\n","     s1 = 0;");
      fprintf(Outfile,"%s\n","     vp = (void**)a;");
      fprintf(Outfile,"%s\n","     while(*vp && s1 <= s)");
      fprintf(Outfile,"%s\n","       {");
      fprintf(Outfile,"%s\n","       vp++;");
      fprintf(Outfile,"%s\n","       s1++;");
      fprintf(Outfile,"%s\n","       }");
      fprintf(Outfile,"%s\n","     while(s1 < s2)");
      fprintf(Outfile,"%s\n","       {");
      fprintf(Outfile,"%s\n","       *(((int *)vp)) = 0;");
      fprintf(Outfile,"%s\n","       vp++;");
      fprintf(Outfile,"%s\n","       s1++;");
      fprintf(Outfile,"%s\n","       }");
      fprintf(Outfile,"%s\n","     }");
      fprintf(Outfile,"%s\n","   else");
      fprintf(Outfile,"%s\n","      a=calloc(s2*sizeof(int),1);");
      fprintf(Outfile,"%s\n"," vp = (void**)a;");
      fprintf(Outfile,"%s\n"," if(--num_dims > 0)");
      fprintf(Outfile,"%s\n"," {");
      fprintf(Outfile,"%s\n"," for(s1 = 0; s1 < s; s1++)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     vp[s1] = CreateArr_internal(vp[s1], elem_size, update, num_dims, marker);");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n"," }");
      fprintf(Outfile,"%s\n"," return a;");
      fprintf(Outfile,"%s\n","}\n\n");
      fprintf(Outfile,"%s\n","void DestroyArr (void** a,int num_dims, int top_free)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n"," int i = 0;");
      fprintf(Outfile,"%s\n"," static int s = 0;");
      fprintf(Outfile,"%s\n"," if(num_dims == 1)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","   free(a);");
      fprintf(Outfile,"%s\n","   return;");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n"," s++;");
      fprintf(Outfile,"%s\n"," num_dims--;  ");
      fprintf(Outfile,"%s\n"," while(a[i])");
      fprintf(Outfile,"%s\n","     {");
      fprintf(Outfile,"%s\n","   DestroyArr((void**)a[i], num_dims, top_free);");
      fprintf(Outfile,"%s\n","   if(num_dims > 1)");
      fprintf(Outfile,"%s\n","         free(a[i]);");
      fprintf(Outfile,"%s\n","       a[i++]=NULL;");
      fprintf(Outfile,"%s\n","       }");
      fprintf(Outfile,"%s\n"," s--;");
      fprintf(Outfile,"%s\n"," if(s == 0 && top_free)");
      fprintf(Outfile,"%s\n","   free(a);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Idxqsort)
    {
      fprintf(Outfile,"%s\n","int IdxCompare (const void *one, const void *two)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int *ptr1 = (int *)(one);");
      fprintf(Outfile,"%s\n","  int *ptr2 = (int *)(two);");
      fprintf(Outfile,"%s\n","  return strcasecmp (pppStr[Key][*ptr1],pppStr[Key][*ptr2]);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_IdxqsortSt)
    {
      fprintf(Outfile,"%s\n","int IdxCompareSt (const void* one, const void* two)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","#define compare1 cmp1+(StructSize * (*(UINT *)(one)))");
      fprintf(Outfile,"%s\n","#define compare2 cmp1+(StructSize * (*(UINT *)(two)))");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," if (Key==0)");
      fprintf(Outfile,"%s\n","   return  strcasecmp(compare1, compare2);");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," if (Key==1)");
      fprintf(Outfile,"%s\n"," {");
      fprintf(Outfile,"%s\n","  if (*(int*)(compare1) < *(int*)(compare2)) return -1;");
      fprintf(Outfile,"%s\n","  if (*(int*)(compare1) > *(int*)(compare2)) return 1;");
      fprintf(Outfile,"%s\n","  return 0;");
      fprintf(Outfile,"%s\n"," }");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," if (Key==2)");
      fprintf(Outfile,"%s\n"," {");
      fprintf(Outfile,"%s\n","  if (*(double*)(compare1) < *(double*)(compare2)) return -1;");
      fprintf(Outfile,"%s\n","  if (*(double*)(compare1) > *(double*)(compare2)) return 1;");
      fprintf(Outfile,"%s\n","  return 0;");
      fprintf(Outfile,"%s\n"," }");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," if (Key==3)");
      fprintf(Outfile,"%s\n"," {");
      fprintf(Outfile,"%s\n","  if (*(UINT*)(compare1) < *(UINT*)(compare2)) return -1;");
      fprintf(Outfile,"%s\n","  if (*(UINT*)(compare1) > *(UINT*)(compare2)) return 1;");
      fprintf(Outfile,"%s\n"," }");
      fprintf(Outfile,"%s\n","return 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_PtrqsortSt)
    {
      fprintf(Outfile,"%s\n","int PtrCompareSt (const void* one, const void* two)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","#define pcompare1 ((char*)(one)+OffSet)");
      fprintf(Outfile,"%s\n","#define pcompare2 ((char*)(two)+OffSet)");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," if (Key==0)");
      fprintf(Outfile,"%s\n","   return  strcasecmp(pcompare1, pcompare2);");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," if (Key==1)");
      fprintf(Outfile,"%s\n"," {");
      fprintf(Outfile,"%s\n","  if (*(int*)(pcompare1) < *(int*)(pcompare2)) return -1;");
      fprintf(Outfile,"%s\n","  if (*(int*)(pcompare1) > *(int*)(pcompare2)) return 1;");
      fprintf(Outfile,"%s\n","  return 0;");
      fprintf(Outfile,"%s\n"," }");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," if (Key==2)");
      fprintf(Outfile,"%s\n"," {");
      fprintf(Outfile,"%s\n","  if (*(double*)(pcompare1) < *(double*)(pcompare2)) return -1;");
      fprintf(Outfile,"%s\n","  if (*(double*)(pcompare1) > *(double*)(pcompare2)) return 1;");
      fprintf(Outfile,"%s\n","  return 0;");
      fprintf(Outfile,"%s\n"," }");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n"," if (Key==3)");
      fprintf(Outfile,"%s\n"," {");
      fprintf(Outfile,"%s\n","  if (*(UINT*)(pcompare1) < *(UINT*)(pcompare2)) return -1;");
      fprintf(Outfile,"%s\n","  if (*(UINT*)(pcompare1) > *(UINT*)(pcompare2)) return 1;");
      fprintf(Outfile,"%s\n"," }");
      fprintf(Outfile,"%s\n","return 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Strqsorta)
    {
      fprintf(Outfile,"%s\n","int StrCompareA (const void *arg1, const void *arg2)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *v1 = (char*) arg1;");
      fprintf(Outfile,"%s\n","  char *v2 = (char*) arg2;");
      fprintf(Outfile,"%s\n","  return strcasecmp (v1,v2);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Strqsortd)
    {
      fprintf(Outfile,"%s\n","int StrCompareD (const void *arg1, const void *arg2)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *v1 = (char*) arg1;");
      fprintf(Outfile,"%s\n","  char *v2 = (char*) arg2;");
      fprintf(Outfile,"%s\n","  return strcasecmp (v2,v1);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_DynStrqsorta)
    {
      fprintf(Outfile,"%s\n","int DynStrCompareA (const void *arg1, const void *arg2)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *v1 = *(char **) arg1;");
      fprintf(Outfile,"%s\n","  char *v2 = *(char **) arg2;");
      fprintf(Outfile,"%s\n","  return strcasecmp(v1, v2);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_DynStrqsortd)
    {
      fprintf(Outfile,"%s\n","int DynStrCompareD (const void *arg1, const void *arg2)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *v1 = *(char **) arg1;");
      fprintf(Outfile,"%s\n","  char *v2 = *(char **) arg2;");
      fprintf(Outfile,"%s\n","  return strcasecmp(v2, v1);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Numqsortaint)
    {
      fprintf(Outfile,"%s\n","int NumCompareAint (const void *one, const void *two)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int *ptr1 = (int *)(one);");
      fprintf(Outfile,"%s\n","  int *ptr2 = (int *)(two);");
      fprintf(Outfile,"%s\n","  if (*ptr1 < *ptr2) return -1;");
      fprintf(Outfile,"%s\n","  else if (*ptr1 == *ptr2) return 0;");
      fprintf(Outfile,"%s\n","  else return 1;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Numqsortdint)
    {
      fprintf(Outfile,"%s\n","int NumCompareDint (const void *one, const void *two)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int *ptr1 = (int *)(one);");
      fprintf(Outfile,"%s\n","  int *ptr2 = (int *)(two);");
      fprintf(Outfile,"%s\n","  if (*ptr1 > *ptr2) return -1;");
      fprintf(Outfile,"%s\n","  else if (*ptr1 == *ptr2) return 0;");
      fprintf(Outfile,"%s\n","  else return 1;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Numqsortafloat)
    {
      fprintf(Outfile,"%s\n","int NumCompareAfloat (const void *one, const void *two)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  float *ptr1 = (float *)(one);");
      fprintf(Outfile,"%s\n","  float *ptr2 = (float *)(two);");
      fprintf(Outfile,"%s\n","  if (*ptr1 < *ptr2) return -1;");
      fprintf(Outfile,"%s\n","  else if (*ptr1 == *ptr2) return 0;");
      fprintf(Outfile,"%s\n","  else return 1;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Numqsortdfloat)
    {
      fprintf(Outfile,"%s\n","int NumCompareDfloat (const void *one, const void *two)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  float *ptr1 = (float *)(one);");
      fprintf(Outfile,"%s\n","  float *ptr2 = (float *)(two);");
      fprintf(Outfile,"%s\n","  if (*ptr1 > *ptr2) return -1;");
      fprintf(Outfile,"%s\n","  else if (*ptr1 == *ptr2) return 0;");
      fprintf(Outfile,"%s\n","  else return 1;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Numqsortadouble)
    {
      fprintf(Outfile,"%s\n","int NumCompareAdouble (const void *one, const void *two)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  double *ptr1 = (double *)(one);");
      fprintf(Outfile,"%s\n","  double *ptr2 = (double *)(two);");
      fprintf(Outfile,"%s\n","  if (*ptr1 < *ptr2) return -1;");
      fprintf(Outfile,"%s\n","  else if (*ptr1 == *ptr2) return 0;");
      fprintf(Outfile,"%s\n","  else return 1;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Numqsortddouble)
    {
      fprintf(Outfile,"%s\n","int NumCompareDdouble (const void *one, const void *two)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  double *ptr1 = (double *)(one);");
      fprintf(Outfile,"%s\n","  double *ptr2 = (double *)(two);");
      fprintf(Outfile,"%s\n","  if (*ptr1 > *ptr2) return -1;");
      fprintf(Outfile,"%s\n","  else if (*ptr1 == *ptr2) return 0;");
      fprintf(Outfile,"%s\n","  else return 1;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_FillArray)
    {
      fprintf(Outfile,"%s\n","int fillarray(char *input, int ArrayType, int MaxCnt, void *Array)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n"," if(MaxCnt < 1) return -1;");
      fprintf(Outfile,"%s\n"," int c = 0, cnt=-1, cnt2;");
      fprintf(Outfile,"%s\n"," char A[65535];");
      fprintf(Outfile,"%s\n"," int    *intptr    = (int *)Array;");
      fprintf(Outfile,"%s\n"," float  *floatptr  = (float *)Array;");
      fprintf(Outfile,"%s\n"," double *doubleptr = (double *)Array;");
      fprintf(Outfile,"%s\n"," long double *ldoubleptr = (long double *)Array;");
      fprintf(Outfile,"%s\n"," for(;;)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","     cnt2=0;");
      fprintf(Outfile,"%s\n","     while(input[++cnt]!=',')");
      fprintf(Outfile,"%s\n","      {");
      fprintf(Outfile,"%s\n","        if(input[cnt]==0) break;");
      fprintf(Outfile,"%s\n","        A[cnt2++]=input[cnt];");
      fprintf(Outfile,"%s\n","      }");
      fprintf(Outfile,"%s\n","     A[cnt2]=0;");
      fprintf(Outfile,"%s\n","     if(cnt2==0||c==MaxCnt) break;");
      fprintf(Outfile,"%s\n","     ");
      fprintf(Outfile,"%s\n","     if(ArrayType==2)");
      fprintf(Outfile,"%s\n","       intptr[c++] = atoi(A);");
      fprintf(Outfile,"%s\n","     else if(ArrayType==3)");
      fprintf(Outfile,"%s\n","       floatptr[c++] = atof(A);");
      fprintf(Outfile,"%s\n","     else if(ArrayType==4)");
      fprintf(Outfile,"%s\n","       doubleptr[c++] = atof(A);");
      fprintf(Outfile,"%s\n","     else if(ArrayType==5)");
      fprintf(Outfile,"%s\n","       ldoubleptr[c++] = atof(A);");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","     if(input[cnt]==0) break;");
      fprintf(Outfile,"%s\n","  } ");
      fprintf(Outfile,"%s\n"," return (c-1);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Loc)
    {
      fprintf(Outfile,"%s\n","int loc(FILE *fp, int fplen)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  fpos_t t;");
      fprintf(Outfile,"%s\n","  fgetpos(fp, &t);");
      fprintf(Outfile,"%s\n","#if defined( __POCC__ )");
      fprintf(Outfile,"%s\n","  t.off %= fplen;");
      fprintf(Outfile,"%s\n","  return (int)t.off;");
      fprintf(Outfile,"%s\n","#else");
      fprintf(Outfile,"%s\n","  t %= fplen;");
      fprintf(Outfile,"%s\n","  return (int)t;");
      fprintf(Outfile,"%s\n","#endif");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Rec)
    {
      fprintf(Outfile,"%s\n","int rec(FILE *fp, int fplen)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  fpos_t t;");
      fprintf(Outfile,"%s\n","  fgetpos(fp, &t);");
      fprintf(Outfile,"%s\n","#if defined( __POCC__ )");
      fprintf(Outfile,"%s\n","  t.off /= fplen;");
      fprintf(Outfile,"%s\n","  return (int)++t.off;");
      fprintf(Outfile,"%s\n","#else");
      fprintf(Outfile,"%s\n","  t /= fplen;");
      fprintf(Outfile,"%s\n","  return (int)++t;");
      fprintf(Outfile,"%s\n","#endif");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_RecCount)
    {
      fprintf(Outfile,"%s\n","int reccount(FILE *fp, int fplen)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  fpos_t t;");
      fprintf(Outfile,"%s\n","  fseek(fp,0,SEEK_END);");
      fprintf(Outfile,"%s\n","  fgetpos(fp, &t);");
      fprintf(Outfile,"%s\n","#if defined( __POCC__ )");
      fprintf(Outfile,"%s\n","  t.off /= fplen;");
      fprintf(Outfile,"%s\n","  return (int)t.off;");
      fprintf(Outfile,"%s\n","#else");
      fprintf(Outfile,"%s\n","  t /= fplen;");
      fprintf(Outfile,"%s\n","  return (int)t;");
      fprintf(Outfile,"%s\n","#endif");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Scan)
    {
      fprintf(Outfile,"%s\n","int scan(char *input, char *format, ... )");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int c,d ;");
      fprintf(Outfile,"%s\n","  char     *s_;");
      fprintf(Outfile,"%s\n","  int      *intptr;");
      fprintf(Outfile,"%s\n","  float    *floatptr;");
      fprintf(Outfile,"%s\n","  double   *doubleptr;");
      fprintf(Outfile,"%s\n","  char     A[50][65535];");
      fprintf(Outfile,"%s\n","  va_list  marker;");
      fprintf(Outfile,"%s\n","  c = 0;");
      fprintf(Outfile,"%s%s%s\n","  d = Split(A,input,",enc(","),");");
      fprintf(Outfile,"%s\n","  va_start(marker, format); //Initialize arguments");
      fprintf(Outfile,"%s\n","  while(d && *format)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     if(*format == '%') format++;");
      fprintf(Outfile,"%s\n","     if(*format == 's')");
      fprintf(Outfile,"%s\n","       {");
      fprintf(Outfile,"%s\n","         s_ = va_arg(marker, char *);");
      fprintf(Outfile,"%s\n","         strcpy(s_, A[c]);");
      fprintf(Outfile,"%s\n","         c++;");
      fprintf(Outfile,"%s\n","         d--;");
      fprintf(Outfile,"%s\n","       }");
      fprintf(Outfile,"%s\n","  if(*format == 'd')");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      intptr = va_arg(marker, int *);");
      fprintf(Outfile,"%s\n","      *intptr = atoi(A[c]);");
      fprintf(Outfile,"%s\n","      c++;");
      fprintf(Outfile,"%s\n","      d--;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  if(*format == 'g')");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      floatptr = va_arg(marker, float *);");
      fprintf(Outfile,"%s\n","      *floatptr = atof(A[c]);");
      fprintf(Outfile,"%s\n","      c++;");
      fprintf(Outfile,"%s\n","      d--;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n"," if(*format == 'l')");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      format++;");
      fprintf(Outfile,"%s\n","      doubleptr = va_arg(marker, double *);");
      fprintf(Outfile,"%s\n","      *doubleptr = atof(A[c]);");
      fprintf(Outfile,"%s\n","      c++;");
      fprintf(Outfile,"%s\n","      d--;");
      fprintf(Outfile,"%s\n","     }");
      fprintf(Outfile,"%s\n","  format++;");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  va_end(marker);              // Reset variable arguments");
      fprintf(Outfile,"%s\n","  if(d) return(1);             // More data than variables");
      fprintf(Outfile,"%s\n","  if(*format == 0) return(0);  // OK");
      fprintf(Outfile,"%s\n","  return(-1);                  // More variables than data");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Split)
    {
      fprintf(Outfile,"%s\n","int Split (char Buf[][65535], char *T, char *Delim, int Flg)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int  Begin = 0;");
      fprintf(Outfile,"%s\n","  int  Count = 0;");
      fprintf(Outfile,"%s\n","  int  Quote = 0;");
      fprintf(Outfile,"%s\n","  int  Index,i;");
      fprintf(Outfile,"%s\n","  int  lenT  = strlen(T);");
      fprintf(Outfile,"%s\n","  char Chr34[2]={34,0};");
      fprintf(Outfile,"%s\n","  for(Index=1;Index<=lenT;Index++)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      if(instr_b(Delim,mid(T,Index,1))&&!Quote)");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","          strcpy(Buf[Count],(char*)mid(T,Begin,Index-Begin));");
      fprintf(Outfile,"%s\n","          if ((Flg & 2) == 0)  // 0 if old version");
      fprintf(Outfile,"%s\n","           Count++;");
      fprintf(Outfile,"%s\n","          else");
      fprintf(Outfile,"%s\n","           if (Buf[Count][0] != 0) Count++;");
      fprintf(Outfile,"%s\n","           Begin=0;");
      fprintf(Outfile,"%s\n","           if((Flg & 1) == 1)   // 1 if true");
      fprintf(Outfile,"%s\n","              strcpy(Buf[Count++],(char*)mid(T,Index,1));");
      fprintf(Outfile,"%s\n","        }");
      fprintf(Outfile,"%s\n","   else");
      fprintf(Outfile,"%s\n","     {");
      fprintf(Outfile,"%s\n","       if(strcmp(mid(T,Index,1),Chr34)==0) Quote=!Quote;");
      fprintf(Outfile,"%s\n","       if(Begin==0) Begin=Index;");
      fprintf(Outfile,"%s\n","     }");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  if(Begin)");
      fprintf(Outfile,"%s\n","     strcpy(Buf[Count++],(char*)mid(T,Begin,Index-Begin));");
      fprintf(Outfile,"%s\n","  if((Flg & 1) == 0)   // 0 if false");
      fprintf(Outfile,"%s\n","      for(i=0;i<Count;i++) strcpy(Buf[i],(char*)RemoveStr(Buf[i],Chr34));");
      fprintf(Outfile,"%s\n","  return Count;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_DSplit)
    {
      fprintf(Outfile,"%s\n","int DSplit (PCHAR *Buf, char *T, char *Delim, int Flg)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int  Begin=0;");
      fprintf(Outfile,"%s\n","  int  Count=0;");
      fprintf(Outfile,"%s\n","  int  Quote=0;");
      fprintf(Outfile,"%s\n","  int  Index=0;");
      fprintf(Outfile,"%s\n","  int  lenT  = strlen(T);");
      fprintf(Outfile,"%s\n","  char Chr34[2]={34,0};");
      fprintf(Outfile,"%s\n","  for(Index=1;Index<=lenT;Index++)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     if(instr_b(Delim,mid(T,Index,1))&&!Quote)");
      fprintf(Outfile,"%s\n","       {");
      fprintf(Outfile,"%s\n","         strcpy(Buf[Count],(char*)mid(T,Begin,Index-Begin));");
      fprintf(Outfile,"%s\n","         if ((Flg & 2) == 0)  // 0 if old version");
      fprintf(Outfile,"%s\n","         Count++;");
      fprintf(Outfile,"%s\n","     else");
      fprintf(Outfile,"%s\n","         if (Buf[Count][0] != 0) Count++;");
      fprintf(Outfile,"%s\n","         Begin=0;");
      fprintf(Outfile,"%s\n","         if((Flg & 1) == 1)   // 1 if true");
      fprintf(Outfile,"%s\n","             strcpy(Buf[Count++],(char*)mid(T,Index,1));");
      fprintf(Outfile,"%s\n","       }");
      fprintf(Outfile,"%s\n","    else");
      fprintf(Outfile,"%s\n","      {");
      fprintf(Outfile,"%s\n","        if(strcmp(mid(T,Index,1),Chr34)==0) Quote=!Quote;");
      fprintf(Outfile,"%s\n","        if(Begin==0)  Begin=Index;");
      fprintf(Outfile,"%s\n","      }");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  if(Begin) strcpy(Buf[Count++],(char*)mid(T,Begin,Index-Begin));");
      fprintf(Outfile,"%s\n","  if((Flg & 1) == 0)   // 0 if false");
      fprintf(Outfile,"%s\n","     for(Index=0;Index<Count;Index++) strcpy(Buf[Index],(char*)RemoveStr(Buf[Index],Chr34));");
      fprintf(Outfile,"%s\n","  return Count;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Bin2dec)
    {
      fprintf(Outfile,"%s\n","int Bin2Dec (char *cptr)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int i, j = 0;");
      fprintf(Outfile,"%s%s%s\n","  while(cptr && *cptr && strchr(",enc("01"),", *cptr))");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    i = *cptr++ - '0';");
      fprintf(Outfile,"%s\n","    j <<= 1;");
      fprintf(Outfile,"%s\n","    j |= (i & 0x01);");
      fprintf(Outfile,"%s\n","  }");
      fprintf(Outfile,"%s\n"," return(j);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Hex2Dec)
    {
      fprintf(Outfile,"%s\n","int Hex2Dec (char *szInput)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char   ch;");
      fprintf(Outfile,"%s\n","  char  *dwLen   = szInput+strlen(szInput);");
      fprintf(Outfile,"%s\n","  char  *LowCase = MakeLCaseTbl();");
      fprintf(Outfile,"%s\n","  DWORD  dwOut   = 0;");
      fprintf(Outfile,"%s\n","  while(*szInput)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      ch = LowCase[(unsigned char)*szInput++];");
      fprintf(Outfile,"%s\n","      if((ch >= 'a' && ch <= 'f')  || (ch >= '0' && ch <= '9'))");
      fprintf(Outfile,"%s\n","        dwOut |=((int)ch - (ch>'9' ? 'a'-10 : '0')) << ((dwLen - szInput) << 2);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  return dwOut;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Verify)
    {
      fprintf(Outfile,"%s\n","int Verify (char *Src, char *Allowed)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int i, j;");
      fprintf(Outfile,"%s\n","  for (i=1; i<=strlen(Src); i++)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      j=VerifyInstr(Allowed,mid(Src,i,1));");
      fprintf(Outfile,"%s\n","      if (!j) return 0;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  return TRUE;");
      fprintf(Outfile,"%s\n","}\n\n");
      fprintf(Outfile,"%s\n","int VerifyInstr(char* mane,char* match,int offset)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *s;");
      fprintf(Outfile,"%s\n","  if (!mane || !match || !*match || offset>(int)strlen(mane)) return 0;");
      fprintf(Outfile,"%s\n","  s = strstr (offset>0 ? mane+offset-1 : mane,match);");
      fprintf(Outfile,"%s\n","  return s ? (int)(s-mane)+1 : 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Retain)
    {
      fprintf(Outfile,"%s\n","char *Retain (char *Text, char *ValidChars)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *BCX_RetStr=BCX_TmpStr(strlen(Text));");
      fprintf(Outfile,"%s\n","  char *temp=BCX_RetStr;");
      fprintf(Outfile,"%s\n","  while(*Text)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      if(strchr(ValidChars,*Text)) *(temp++) = *Text;");
      fprintf(Outfile,"%s\n","      Text++;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  return BCX_RetStr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_LoadFile)
    {
      fprintf(Outfile,"%s\n","char* LoadFile (char *N)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  FILE* FP1;");
      fprintf(Outfile,"%s\n","  char* BCX_RetStr;");
      fprintf(Outfile,"%s\n","  if(Exist(N))");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      BCX_RetStr=BCX_TmpStr(lof(N));");
      fprintf(Outfile,"%s%s%s\n","      if((FP1=fopen(N,",enc("rb"),"))!=0)");
      fprintf(Outfile,"%s\n","      GET(FP1,BCX_RetStr,lof(N));");
      fprintf(Outfile,"%s\n","      fclose(FP1);");
      fprintf(Outfile,"%s\n","      return BCX_RetStr;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  else");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      BCX_RetStr=BCX_TmpStr(64);");
      fprintf(Outfile,"%s%s%s\n","      return strcpy(BCX_RetStr,",enc("File Not Found"),");");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Freefile)
    {
      fprintf(Outfile,"%s\n","FILE* FreeFile (void)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static FILE *pf;");
      fprintf(Outfile,"%s\n","  if(pf){free(pf);pf=NULL;}");
      fprintf(Outfile,"%s\n","  pf = (FILE*)calloc(sizeof(FILE*),sizeof(FILE*));");
      fprintf(Outfile,"%s\n","  return pf;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Run)
    {
      fprintf(Outfile,"%s\n","int Run (char* Cmdline, int ShowHide, int WaitState)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","   int    processId;");
      fprintf(Outfile,"%s\n","   char  *s, *p, *cmd_line;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  cmd_line=(char*)malloc(strlen(Cmdline)+1);");
      fprintf(Outfile,"%s\n","  if(cmd_line==NULL) return -2;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","  strcpy(cmd_line, Cmdline);");
      fprintf(Outfile,"%s\n","  p = s = cmd_line;");
      fprintf(Outfile,"%s\n","  processId=fork();");
      fprintf(Outfile,"%s\n","  if(processId==0)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      PCHAR  argv[30];");
      fprintf(Outfile,"%s\n","      int     i=0;");
      fprintf(Outfile,"%s\n","      while(*p)");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","          if(*p==34)");
      fprintf(Outfile,"%s\n","            {");
      fprintf(Outfile,"%s\n","              while(*(++p)!=34) {}");
      fprintf(Outfile,"%s\n","            }");
      fprintf(Outfile,"%s\n","          if(*p==32)");
      fprintf(Outfile,"%s\n","            {");
      fprintf(Outfile,"%s\n","              while(*(p+1)==32) p++;");
      fprintf(Outfile,"%s\n","              argv[i++]=s;");
      fprintf(Outfile,"%s\n","              *p=0; s=p+1;");
      fprintf(Outfile,"%s\n","            }");
      fprintf(Outfile,"%s\n","          p++;");
      fprintf(Outfile,"%s\n","        }");
      fprintf(Outfile,"%s\n","      argv[i]  = s;");
      fprintf(Outfile,"%s\n","      argv[i+1]= 0;");
      fprintf(Outfile,"%s\n","      execvp(argv[0],argv);");
      fprintf(Outfile,"%s%s%s\n","      printf(",enc("Failed to run%s\\n"),",argv[0]);");
      fprintf(Outfile,"%s\n","      exit(-1);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  else if(processId!=-1)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      if(WaitState) waitpid(processId,NULL,0);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  waitpid(-1,NULL,WNOHANG);");
      fprintf(Outfile,"%s\n","  free(cmd_line), cmd_line=NULL;");
      fprintf(Outfile,"%s\n","  return processId;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Download)
    {
      fprintf(Outfile,"%s\n","int Download (char *URL,char *Localname)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int RetVal;");
      fprintf(Outfile,"%s\n","  return RetVal=!RetVal;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_PeekStr)
    {
      fprintf(Outfile,"%s\n","char *peekstr (LPVOID Src, int Count)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *Des=BCX_TmpStr(Count);");
      fprintf(Outfile,"%s\n","  memmove(Des,Src,Count);");
      fprintf(Outfile,"%s\n","  return Des;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_QBColor)
    {
      fprintf(Outfile,"%s\n","int qbcolor (int N)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n"," switch (N)");
      fprintf(Outfile,"%s\n"," {");
      fprintf(Outfile,"%s\n"," case  0 : return RGB(0,0,0);");
      fprintf(Outfile,"%s\n"," case  1 : return RGB(0,0,128);");
      fprintf(Outfile,"%s\n"," case  2 : return RGB(0,128,0);");
      fprintf(Outfile,"%s\n"," case  3 : return RGB(0,128,128);");
      fprintf(Outfile,"%s\n"," case  4 : return RGB(196,0,0);");
      fprintf(Outfile,"%s\n"," case  5 : return RGB(128,0,128);");
      fprintf(Outfile,"%s\n"," case  6 : return RGB(128,64,0);");
      fprintf(Outfile,"%s\n"," case  7 : return RGB(196,196,196);");
      fprintf(Outfile,"%s\n"," case  8 : return RGB(128,128,128);");
      fprintf(Outfile,"%s\n"," case  9 : return RGB(0,0, 255);");
      fprintf(Outfile,"%s\n"," case 10 : return RGB(0,255,0);");
      fprintf(Outfile,"%s\n"," case 11 : return RGB(0,255,255);");
      fprintf(Outfile,"%s\n"," case 12 : return RGB(255,0,0);");
      fprintf(Outfile,"%s\n"," case 13 : return RGB(255,0,255);");
      fprintf(Outfile,"%s\n"," case 14 : return RGB(255,255,0);");
      fprintf(Outfile,"%s\n"," case 15 : return RGB(255,255,255);");
      fprintf(Outfile,"%s\n"," case 16 : return RGB(164,164,164);");
      fprintf(Outfile,"%s\n"," case 17 : return RGB(128,160,255);");
      fprintf(Outfile,"%s\n"," case 18 : return RGB(160,255,160);");
      fprintf(Outfile,"%s\n"," case 19 : return RGB(160,255,255);");
      fprintf(Outfile,"%s\n"," case 20 : return RGB(255,160,160);");
      fprintf(Outfile,"%s\n"," case 21 : return RGB(255,160,255);");
      fprintf(Outfile,"%s\n"," case 22 : return RGB(255,255,160);");
      fprintf(Outfile,"%s\n"," case 23 : return RGB(212,212,212);");
      fprintf(Outfile,"%s\n"," case 24 : return RGB(180,180,180);");
      fprintf(Outfile,"%s\n"," case 25 : return RGB(188,220,255);");
      fprintf(Outfile,"%s\n"," case 26 : return RGB(220,255,220);");
      fprintf(Outfile,"%s\n"," case 27 : return RGB(220,255,255);");
      fprintf(Outfile,"%s\n"," case 28 : return RGB(255,220,220);");
      fprintf(Outfile,"%s\n"," case 29 : return RGB(255,220,255);");
      fprintf(Outfile,"%s\n"," case 30 : return RGB(255,255,220);");
      fprintf(Outfile,"%s\n"," case 31 : return RGB(228,228,228);");
      fprintf(Outfile,"%s\n"," }");
      fprintf(Outfile,"%s\n","return 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Cvi)
    {
      fprintf(Outfile,"%s\n","short CVI (char *s)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n"," return ((short*)s)[0];");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Mki)
    {
      fprintf(Outfile,"%s\n","char *MKI (short cvt)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static char temp[3];");
      fprintf(Outfile,"%s\n","  return (char *)memmove(temp,&cvt,2);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Cvl)
    {
      fprintf(Outfile,"%s\n","long CVL (char *s)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n"," return ((long*)s)[0];");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Mkl)
    {
      fprintf(Outfile,"%s\n","char *MKL (int cvt)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static char temp[5];");
      fprintf(Outfile,"%s\n","  return (char *) memmove(temp,&cvt,4);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Cvs)
    {
      fprintf(Outfile,"%s\n","float CVS (char *s)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n"," return ((float*)s)[0];");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Mks)
    {
      fprintf(Outfile,"%s\n","char *MKS (float cvt)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static char temp[5];");
      fprintf(Outfile,"%s\n","  return (char *) memmove(temp,&cvt,4);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Cvd)
    {
      fprintf(Outfile,"%s\n","double CVD (char *s)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n"," return ((double*)s)[0];");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Cvld)
    {
      fprintf(Outfile,"%s\n","long double CVLD (char *s)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n"," return ((long double*)s)[0];");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Mkd)
    {
      fprintf(Outfile,"%s\n","char *MKD (double cvt)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static char temp[9];");
      fprintf(Outfile,"%s\n","  return (char *) memmove(temp,&cvt,8);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Mkld)
    {
      fprintf(Outfile,"%s\n","char *MKLD (long double cvt)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static char temp[11];");
      fprintf(Outfile,"%s\n","  return (char *) memmove(temp,&cvt,10);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_BcxSplitPath)
    {
      fprintf(Outfile,"%s\n","char *BcxSplitPath (char *FPath, int mask)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  if(!FPath) return BCX_TmpStr(1);");
      fprintf(Outfile,"%s\n","  char *BCX_RetStr=BCX_TmpStr(strlen(FPath));");
      fprintf(Outfile,"%s\n","  char tmp[MAX_PATH*4];");
      fprintf(Outfile,"%s\n","  _splitpath_(FPath,tmp,&tmp[MAX_PATH],&tmp[MAX_PATH*2],&tmp[MAX_PATH*3]);");
      fprintf(Outfile,"%s\n","  if(mask & FDRV) strcat(BCX_RetStr,tmp);");
      fprintf(Outfile,"%s\n","  if(mask & FPATH)strcat(BCX_RetStr,&tmp[MAX_PATH]);");
      fprintf(Outfile,"%s\n","  if(mask & FNAME)strcat(BCX_RetStr,&tmp[MAX_PATH*2]);");
      fprintf(Outfile,"%s\n","  if(mask & FEXT) strcat(BCX_RetStr,&tmp[MAX_PATH*3]);");
      fprintf(Outfile,"%s\n","  return BCX_RetStr;");
      fprintf(Outfile,"%s\n","}\n\n");
      fprintf(Outfile,"%s\n"," void _splitpath_(const char* path, char* drv, char* dir, char* name, char* ext)");
      fprintf(Outfile,"%s\n"," {");
      fprintf(Outfile,"%s\n","     const char* pend; /* end of processed string */");
      fprintf(Outfile,"%s\n","     const char* p;   /* search pointer */");
      fprintf(Outfile,"%s\n","     const char* s;   /* copy pointer */");
      fprintf(Outfile,"%s\n"," ");
      fprintf(Outfile,"%s\n","     /* extract drive name */");
      fprintf(Outfile,"%s\n","     if (path[0] && path[1]==':') {");
      fprintf(Outfile,"%s\n","         if (drv) {");
      fprintf(Outfile,"%s\n","             *drv++ = *path++;");
      fprintf(Outfile,"%s\n","             *drv++ = *path++;");
      fprintf(Outfile,"%s\n","             *drv = 0;");
      fprintf(Outfile,"%s\n","         }");
      fprintf(Outfile,"%s\n","     } else if (drv)");
      fprintf(Outfile,"%s\n","         *drv = 0;");
      fprintf(Outfile,"%s\n"," ");
      fprintf(Outfile,"%s\n","     /* search for end of string or stream separator */");
      fprintf(Outfile,"%s\n","     for(pend=path; *pend && *pend!=':'; )");
      fprintf(Outfile,"%s\n","         pend++;");
      fprintf(Outfile,"%s\n"," ");
      fprintf(Outfile,"%s\n","     /* search for begin of file extension */");
      fprintf(Outfile,"%s\n","     for(p=pend; p > path && *--p != '\\\\' && *p!='/'; )");
      fprintf(Outfile,"%s\n","         if (*p == '.') {");
      fprintf(Outfile,"%s\n","             pend = p;");
      fprintf(Outfile,"%s\n","             break;");
      fprintf(Outfile,"%s\n","         }");
      fprintf(Outfile,"%s\n"," ");
      fprintf(Outfile,"%s\n","     if (ext)");
      fprintf(Outfile,"%s\n","     {");
      fprintf(Outfile,"%s\n","         s=pend;");
      fprintf(Outfile,"%s\n","         do{ *ext++ = *s; } while(*s++);");
      fprintf(Outfile,"%s\n","     }");
      fprintf(Outfile,"%s\n","     /* search for end of directory name */");
      fprintf(Outfile,"%s\n","     for(p=pend; p > path; )");
      fprintf(Outfile,"%s\n","         if (*--p == '\\\\' || *p == '/') {");
      fprintf(Outfile,"%s\n","             p++;");
      fprintf(Outfile,"%s\n","             break;");
      fprintf(Outfile,"%s\n","         }");
      fprintf(Outfile,"%s\n"," ");
      fprintf(Outfile,"%s\n","     if (name) {");
      fprintf(Outfile,"%s\n","         for(s=p; s<pend; )");
      fprintf(Outfile,"%s\n","             *name++ = *s++;");
      fprintf(Outfile,"%s\n"," ");
      fprintf(Outfile,"%s\n","         *name = 0;");
      fprintf(Outfile,"%s\n","     }");
      fprintf(Outfile,"%s\n"," ");
      fprintf(Outfile,"%s\n","     if (dir) {");
      fprintf(Outfile,"%s\n","         for(s=path; s<p; )");
      fprintf(Outfile,"%s\n","             *dir++ = *s++;");
      fprintf(Outfile,"%s\n"," ");
      fprintf(Outfile,"%s\n","         *dir = 0;");
      fprintf(Outfile,"%s\n","     }");
      fprintf(Outfile,"%s\n"," }\n");
    }
  if(Use_StrUpLow)
    {
      fprintf(Outfile,"%s\n","char *_strupr_(char *string)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","   char *s;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","   if (string)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","      for(s = string; *s; ++s)");
      fprintf(Outfile,"%s\n","         *s = toupper(*s);");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","   return string;");
      fprintf(Outfile,"%s\n","}\n");
      fprintf(Outfile,"%s\n","char *_strlwr_(char *string)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","    char *s;");
      fprintf(Outfile,"%s\n","");
      fprintf(Outfile,"%s\n","    if (string)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","       for (s = string; *s; ++s)");
      fprintf(Outfile,"%s\n","           *s = tolower(*s);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","    return string;");
      fprintf(Outfile,"%s\n","}\n");
    }
  if(Use_Strtoken)
    {
      fprintf(Outfile,"%s\n","char * StrToken (char *Source, char *TokenChar, int n)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *BCX_RetStr={0};");
      fprintf(Outfile,"%s\n","  char *RetVal;");
      fprintf(Outfile,"%s\n","  char *Copy;");
      fprintf(Outfile,"%s\n","  int   Posn=0;");
      fprintf(Outfile,"%s\n","  int   Find=0;");
      fprintf(Outfile,"%s\n","  int   LenSrc=strlen(Source);");
      fprintf(Outfile,"%s\n","  RetVal=(char*)calloc(LenSrc+1,1);");
      fprintf(Outfile,"%s\n","  Copy=Source;");
      fprintf(Outfile,"%s\n","  if(tally(Source,TokenChar)==0)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      BCX_RetStr=BCX_TmpStr(1);");
      fprintf(Outfile,"%s\n","      if(RetVal)free(RetVal);");
      fprintf(Outfile,"%s\n","      return BCX_RetStr;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  if(n==1)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      BCX_RetStr=BCX_TmpStr(LenSrc);");
      fprintf(Outfile,"%s\n","      strcpy(BCX_RetStr,(char*)extract(Source,TokenChar));");
      fprintf(Outfile,"%s\n","      if(RetVal)free(RetVal);");
      fprintf(Outfile,"%s\n","      return BCX_RetStr;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  if(n>tally(Source,TokenChar)+1)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      BCX_RetStr=BCX_TmpStr(1);");
      fprintf(Outfile,"%s\n","      if(RetVal)free(RetVal);");
      fprintf(Outfile,"%s\n","      return BCX_RetStr;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  while(*Copy)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      if(*Copy==TokenChar[0]) Find++;");
      fprintf(Outfile,"%s\n","      if(Find==n) break;");
      fprintf(Outfile,"%s\n","      Copy++;");
      fprintf(Outfile,"%s\n","      Posn++;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  if(n==tally(Source,TokenChar)+1)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      Posn=LenSrc;");
      fprintf(Outfile,"%s\n","      Copy=Source+Posn;");
      fprintf(Outfile,"%s\n","      while(*Copy&&Source[Posn]!=TokenChar[0])");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","          Posn--;");
      fprintf(Outfile,"%s\n","          Copy--;");
      fprintf(Outfile,"%s\n","        }");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  strcpy(RetVal,(char*)mid(Source,1,Posn));");
      fprintf(Outfile,"%s\n","  strcpy(RetVal,(char*)mid(RetVal,InstrRev(RetVal,TokenChar)));");
      fprintf(Outfile,"%s\n","  BCX_RetStr=BCX_TmpStr(LenSrc);");
      fprintf(Outfile,"%s\n","  strcpy(BCX_RetStr,(char*)RemoveStr(RetVal,TokenChar));");
      fprintf(Outfile,"%s\n","  if(RetVal)free(RetVal);");
      fprintf(Outfile,"%s\n","  return BCX_RetStr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_iReplace)
    {
      fprintf(Outfile,"%s\n","char *iReplace (char *src, char *pat, char *rep)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  size_t patsz, repsz, tmpsz, delta;");
      fprintf(Outfile,"%s\n","  char *strtmp, *p, *q, *r;");
      fprintf(Outfile,"%s\n","  if (!pat || !*pat)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     strtmp = BCX_TmpStr(strlen(src));");
      fprintf(Outfile,"%s\n","     if (!strtmp) return NULL;");
      fprintf(Outfile,"%s\n","     return strcpy(strtmp, src);");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  repsz = strlen(rep);");
      fprintf(Outfile,"%s\n","  patsz = strlen(pat);");
      fprintf(Outfile,"%s\n","  for (tmpsz=0, p=src;(q=_stristr_(p,pat))!=0; p=q+patsz)");
      fprintf(Outfile,"%s\n","    tmpsz += (size_t) (q - p) + repsz;");
      fprintf(Outfile,"%s\n","    tmpsz += strlen(p);");
      fprintf(Outfile,"%s\n","    strtmp = BCX_TmpStr(tmpsz);");
      fprintf(Outfile,"%s\n","    if (!strtmp) return NULL;");
      fprintf(Outfile,"%s\n","    for (r=strtmp,p=src;(q=_stristr_(p,pat))!=0;p=q+patsz)");
      fprintf(Outfile,"%s\n","     {");
      fprintf(Outfile,"%s\n","       delta = (size_t) (q-p);");
      fprintf(Outfile,"%s\n","       memcpy(r,p,delta); r += delta;");
      fprintf(Outfile,"%s\n","       strcpy(r,rep);      r += repsz;");
      fprintf(Outfile,"%s\n","     }");
      fprintf(Outfile,"%s\n","  strcpy(r,p);");
      fprintf(Outfile,"%s\n","  return strtmp;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_WideToAnsi)
    {
      fprintf(Outfile,"%s\n","char* WideToAnsi (wchar_t *WideStr, UINT CodePage,DWORD dwFlags)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  char *BCX_RetStr={0};");
      fprintf(Outfile,"%s\n","  UINT uLen;");
      fprintf(Outfile,"%s\n","  uLen=wcstombs(NULL, WideStr, 0); //WideCharToMultiByte(CodePage,dwFlags,WideStr,-1,0,0,0,0);");
      fprintf(Outfile,"%s\n","  BCX_RetStr=(char*)BCX_TmpStr(uLen);");
      fprintf(Outfile,"%s\n","  wcstombs(BCX_RetStr, WideStr, uLen); //WideCharToMultiByte(CodePage,dwFlags,WideStr,-1,BCX_RetStr,uLen,0,0);");
      fprintf(Outfile,"%s\n","  return BCX_RetStr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_SysStr)
    {
      fprintf(Outfile,"%s\n","BSTR SysStr (char * szIn, int widstr, int bfree)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static  BSTR  bStr[32];");
      fprintf(Outfile,"%s\n","  static  int   index;");
      fprintf(Outfile,"%s\n","  if(bfree)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      for(index=0; index<32; index+=1) ");
      fprintf(Outfile,"%s\n","        SysFreeString(bStr[index]);");
      fprintf(Outfile,"%s\n","      return 0;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  index=(++index & 31);");
      fprintf(Outfile,"%s\n","  SysFreeString(bStr[index]);");
      fprintf(Outfile,"%s\n","  int   length=strlen(szIn);");
      fprintf(Outfile,"%s\n","  if(widstr)");
      fprintf(Outfile,"%s\n","   {");
      fprintf(Outfile,"%s\n","     bStr[index]=SysAllocStringLen(NULL, (2*length));");
      fprintf(Outfile,"%s\n","     MultiByteToWideChar(CP_ACP,0,szIn,-1,bStr[index],(2*length+1));");
      fprintf(Outfile,"%s\n","   }else{");
      fprintf(Outfile,"%s\n","     bStr[index]=SysAllocStringByteLen(szIn, length);");
      fprintf(Outfile,"%s\n","   }");
      fprintf(Outfile,"%s\n","  return bStr[index];");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_AnsiToWide)
    {
      fprintf(Outfile,"%s\n","wchar_t *AnsiToWide (char *AnsiStr, UINT CodePage,DWORD dwFlags)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  UINT uLen;");
      fprintf(Outfile,"%s\n","  wchar_t *WideStr;");
      fprintf(Outfile,"%s\n","  uLen=mbstowcs(NULL, AnsiStr, 0); //MultiByteToWideChar(CodePage,dwFlags,AnsiStr,-1,0,0);");
      fprintf(Outfile,"%s\n","  if(uLen<=1) return (wchar_t*)BCX_TmpStr(2);");
      fprintf(Outfile,"%s\n","  WideStr = (wchar_t*)BCX_TmpStr(2*uLen);");
      fprintf(Outfile,"%s\n","  mbstowcs(WideStr, AnsiStr, uLen); //MultiByteToWideChar(CodePage,dwFlags,AnsiStr,uLen,WideStr,uLen);");
      fprintf(Outfile,"%s\n","  return WideStr;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_FileLocked)
    {
      fprintf(Outfile,"%s\n","int FileLocked (char *Filename)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s%s%s\n","  FILE *FP=fopen(Filename,",enc("rb+"),");");
      fprintf(Outfile,"%s\n","  if(FP==0) return 1;");
      fprintf(Outfile,"%s\n","  fclose(FP);");
      fprintf(Outfile,"%s\n","  return 0;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_ContainedIn)
    {
      fprintf(Outfile,"%s\n","int containedin(char * Token,char **Contain ,int c)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    int i=0;");
      fprintf(Outfile,"%s\n","    while(Contain[i][0])");
      fprintf(Outfile,"%s\n","      {");
      fprintf(Outfile,"%s\n","        if(0 == ((c == 0 || c == 2) ? strcmp(Contain[i],Token) : strcasecmp(Contain[i],Token)))");
      fprintf(Outfile,"%s\n","          {");
      fprintf(Outfile,"%s\n","            return ((c < 2) ? 0 : i);");
      fprintf(Outfile,"%s\n","          }");
      fprintf(Outfile,"%s\n","        i++;");
      fprintf(Outfile,"%s\n","      }");
      fprintf(Outfile,"%s\n","    return -1;");
      fprintf(Outfile,"%s\n","  }\n\n");
    }
  if(Use_FindInType)
    {
      fprintf(Outfile,"%s\n","int FindInType(char *Token,char *StOffset,int StSize,int start,int finish,int c,int *idx)");
      fprintf(Outfile,"%s\n","  {");
      fprintf(Outfile,"%s\n","    int j;");
      fprintf(Outfile,"%s\n","    char *Srch;");
      fprintf(Outfile,"%s\n","    int (*cmp)(const char*,const char*);");
      fprintf(Outfile,"%s\n","    cmp = ((c == 0 || c == 2) ? strcmp : strcasecmp);");
      fprintf(Outfile,"%s\n","    for(j=start; j<=finish; j++)");
      fprintf(Outfile,"%s\n","      {");
      fprintf(Outfile,"%s\n","        Srch = StOffset + ((idx==0) ? j*StSize : idx[j]*StSize);");
      fprintf(Outfile,"%s\n","        if(cmp(Srch,Token)==0)");
      fprintf(Outfile,"%s\n","          {");
      fprintf(Outfile,"%s\n","            return ((c < 2) ? 0 : j);");
      fprintf(Outfile,"%s\n","          }");
      fprintf(Outfile,"%s\n","      }");
      fprintf(Outfile,"%s\n","    return -1;");
      fprintf(Outfile,"%s\n","  }\n\n");
    }
  if(Use_StartupCode)
    {
      fprintf(Outfile,"%s\n","int BCX_StartupCode_(void)");
      fprintf(Outfile,"%s\n","{");
        {int i;
      for(i=1; i<=StartNdx; i+=1)
        {
          fprintf(Outfile,"%s%s%s\n","  ",StartSub[i],"();");
        }
        }
      fprintf(Outfile,"%s\n","  return 1;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_ExitCode)
    {
      fprintf(Outfile,"%s\n","int BCX_ExitCode_(void)");
      fprintf(Outfile,"%s\n","{");
        {int i;
      for(i=1; i<=ExitNdx; i+=1)
        {
          fprintf(Outfile,"%s%s%s\n","  atexit(",ExitSub[i],");");
        }
        }
      fprintf(Outfile,"%s\n","  return 1;");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_Socket)
    {
      fprintf(Outfile,"%s\n","sockaddr_in sock_addr (char *ServerName,int port)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  in_addr  iaHost;");
      fprintf(Outfile,"%s\n","  hostent*  lpHostEntry;");
      fprintf(Outfile,"%s\n","  sockaddr_in  saServer;");
      fprintf(Outfile,"%s\n","  iaHost.s_addr=inet_addr(ServerName);");
      fprintf(Outfile,"%s\n","  if(iaHost.s_addr==INADDR_NONE)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      lpHostEntry=gethostbyname(ServerName);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  else");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","     lpHostEntry=gethostbyaddr((char*)&iaHost,sizeof(in_addr),AF_INET);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n"," if(lpHostEntry==NULL)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s%s%s\n","      printf(",enc("Error! HOST NOT FOUND: %s\\n"),", ServerName);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  else");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      saServer.sin_port=htons(port);");
      fprintf(Outfile,"%s\n","      saServer.sin_family=AF_INET;");
      fprintf(Outfile,"%s\n","      saServer.sin_addr=*(in_addr*)lpHostEntry->h_addr;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  return saServer;");
      fprintf(Outfile,"%s\n","}\n\n");
      fprintf(Outfile,"%s\n","int connect_socket (sockaddr_in saServer)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  int Socket, nRet;");
      fprintf(Outfile,"%s\n","  Socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);");
      fprintf(Outfile,"%s\n","  if(Socket==-1)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      return Socket;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  nRet=connect(Socket,(sockaddr*)&saServer,sizeof(sockaddr_in));");
      fprintf(Outfile,"%s\n","  if(nRet==-1)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      close(Socket);");
      fprintf(Outfile,"%s\n","      return nRet;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  return Socket;");
      fprintf(Outfile,"%s\n","}\n\n");
      fprintf(Outfile,"%s\n","int BcxSocket (char *ServerName,int port)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  sockaddr_in  saServer;");
      fprintf(Outfile,"%s\n","  saServer=sock_addr(ServerName,port);");
      fprintf(Outfile,"%s\n","  return connect_socket(saServer);");
      fprintf(Outfile,"%s\n","}\n\n");
      fprintf(Outfile,"%s\n","int BcxSocketSend (int Socket, char *szBuffer)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static int     nRet;");
      fprintf(Outfile,"%s\n","  nRet=send(Socket,szBuffer,strlen(szBuffer),0);");
      fprintf(Outfile,"%s\n","  if(nRet==-1)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      close(Socket);");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  return nRet;");
      fprintf(Outfile,"%s\n","}\n\n");
      fprintf(Outfile,"%s\n","int BcxSocketRead (int Socket, char *szBuffer)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  return read(Socket,szBuffer,strlen(szBuffer));");
      fprintf(Outfile,"%s\n","}\n\n");
      fprintf(Outfile,"%s\n","void    BcxSocketClose(int Socket) {");
      fprintf(Outfile,"%s\n","	close(Socket);");
      fprintf(Outfile,"%s\n","}\n\n");
    }
  if(Use_RegEx)
    {
      fprintf(Outfile,"%s\n","bool regmatch (char *buffer, char *pattern, REGEX* retval)");
      fprintf(Outfile,"%s\n","{");
      fprintf(Outfile,"%s\n","  static int     t;");
      fprintf(Outfile,"%s\n","  static int     i;");
      fprintf(Outfile,"%s\n","  static   regex_t  re;");
      fprintf(Outfile,"%s\n","  t=regcomp( &re,pattern,REG_ICASE|REG_EXTENDED);");
      fprintf(Outfile,"%s\n","  if(t)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      regerror(t, &re,buffer,sizeof(buffer));");
      fprintf(Outfile,"%s%s%s\n","      printf(",enc("regex error: %s %s"),",buffer,pattern);");
      fprintf(Outfile,"%s\n","      return 0;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  t=regexec( &re,buffer,1023,(*retval).matches,0);");
      fprintf(Outfile,"%s\n","  (*retval).count=re.re_nsub;");
      fprintf(Outfile,"%s\n","  if(!t)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      for(i=1; i<=(*retval).count; i+=1)");
      fprintf(Outfile,"%s\n","        {");
      fprintf(Outfile,"%s\n","          if((*retval).matches[i].rm_so>=0)");
      fprintf(Outfile,"%s\n","            {");
      fprintf(Outfile,"%s\n","             (*retval).results[i]=peekstr( &buffer[(*retval).matches[i].rm_so],((*retval).matches[i].rm_eo-(*retval).matches[i].rm_so));");
      fprintf(Outfile,"%s\n","           }");
      fprintf(Outfile,"%s\n","        }");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  regfree( &re);");
      fprintf(Outfile,"%s\n","  if(!t)");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      return TRUE;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","  else");
      fprintf(Outfile,"%s\n","    {");
      fprintf(Outfile,"%s\n","      return FALSE;");
      fprintf(Outfile,"%s\n","    }");
      fprintf(Outfile,"%s\n","}\n\n");
    }
}


int JoinLines (char *Arg)
{
  if(iMatchRgt(Arg," _"))
    {
      Arg[strlen(Arg)-1]=0;
      strcat(CurLine,Arg);
      return 1;
    }
  if(*CurLine!=0)
    {
      strcpy(Arg, join(2,CurLine,Arg));
      *CurLine=0;
    }
  UmQt=FALSE;
  return 0;
}


void StripCode (char *Arg)
{
   PCHAR  p;
   PCHAR  p2=Arg;
  int     asmFlag=0;
  int     eStr=0;
  char sub_[2048];
  while((*p2>8&&*p2<14)||*p2==32)
    {
      p2++;
    }
  if(*p2==33)
    {
      asmFlag=!UmQt;
    }
  p=p2;
  while(*p)
    {
      if(*p==9)
        {
          *p=32;
        }
      if(*p==34)
        {
          if(*(p-1)==69)
            {
              *(p-1)=1;
              eStr=TRUE;
            }
          while(*(++p)!=34)
            {
              if(*p==92&&eStr)
                {
                  *p=2;
                  for(;;)
                  {
                    if(*(p+1)==48)
                      {
                        *(p+1)=3;
                        break;
                      }
                    if(*(p+1)==116)
                      {
                        *(p+1)=4;
                        break;
                      }
                    if(*(p+1)==110)
                      {
                        *(p+1)=5;
                        break;
                      }
                    if(*(p+1)==114)
                      {
                        *(p+1)=6;
                        break;
                      }
                    if(*(p+1)==113)
                      {
                        *(p+1)=7;
                        break;
                      }
                    if(*(p+1)==92)
                      {
                        *(p+1)=8;
                      }
                    break;
                  }
                  p++;
                }
              if(*p==0)
                {
                  UmQt=!UmQt;
                  break;
                }
            }
        }
      if(!UmQt&&!asmFlag)
        {
          if((*p BOR 32)==114)
            {
              if((*(p+1) BOR 32)==101&&(*(p+2) BOR 32)==109&&(*(p+3)==32||*(p+3)==0))
                {
                  if(p==p2||*(p-1)==58||*(p-1)==32)
                    {
                      *p=0;
                      break;
                    }
                }
            }
          if(*p==39||(*p==47&&*(p+1)==47))
            {
              *p=0;
              break;
            }
        }
      p++;
    }
  while(p2<p)
    {
      while((*(p-1)>8&&*(p-1)<14)||*(p-1)==32)
        {
          *(--p)=0;
        }
      if(UmQt||asmFlag)
        {
          break;
        }
      if(*(p-1)==58&&*(p-2)==32)
        {
          p--;
        }
      else
        {
          break;
        }
    }
  if(eStr)
    {
      strcpy(p2,replace(p2,chr(1),""));
      strcpy(p2,replace(p2,chr(2),""));
      strcpy(sub_, join(3,DQ,"+CHR$(0)+",DQ));
      strcpy(p2,replace(p2,chr(3),sub_));
      strcpy(sub_, join(3,DQ,"+CHR$(9)+",DQ));
      strcpy(p2,replace(p2,chr(4),sub_));
      strcpy(sub_, join(3,DQ,"+CHR$(10)+",DQ));
      strcpy(p2,replace(p2,chr(5),sub_));
      strcpy(sub_, join(3,DQ,"+CHR$(13)+",DQ));
      strcpy(p2,replace(p2,chr(6),sub_));
      strcpy(sub_, join(3,DQ,"+CHR$(34)+",DQ));
      strcpy(p2,replace(p2,chr(7),sub_));
      strcpy(sub_, join(3,DQ,"+CHR$(92)+",DQ));
      strcpy(p2,replace(p2,chr(8),sub_));
      strcpy(p2,replace(p2,(join(3,chr(34),chr(34),chr(43))),""));
      strcpy(p2,replace(p2,(join(3,chr(43),chr(34),chr(34))),""));
    }
  memcpy(Arg,p2,strlen(p2)+1);
}


void ProcSingleLineIf (int* ifFlag)
{
  char Tmp[2048];
  int     ifp;
  int     NdIfs;
  static int     EFlag;
  if((*ifFlag)==0)
    {
      EFlag=0;
    }

REDO:;
  if(SplitCnt>120)
    {
      Abort("Stack Overflow - Too many statements on one line");
    }
  strcpy(Tmp, join(2,SplitStk[SplitCnt],SPC));
  if(iMatchLft(Tmp,"if "))
    {
      ifp=iMatchNQ(Tmp," then ");
      if(ifp)
        {
          strcpy(SplitStk[SplitCnt++],left(Tmp,ifp+4));
          strcpy(SplitStk[SplitCnt],ltrim(Tmp+ifp+4));
          EFlag=_MAX_(0,EFlag-1);
          (*ifFlag)++;
          goto REDO;
        }
    }
  else if((*ifFlag))
    {
      if(iMatchLft(Tmp,"else "))
        {

LFTLSE:;
          if(++EFlag>1)
            {
              NdIfs=_MAX_(1,(*ifFlag)-1);
              (*ifFlag)=1;
              EFlag=0;
              if(iMatchWrd(SplitStk[SplitCnt-1],"else"))
                {
                  SplitCnt--;
                }
                {int BCX_REPEAT;
                for(BCX_REPEAT=1;BCX_REPEAT<=NdIfs;BCX_REPEAT++)
                {
                  strcpy(SplitStk[SplitCnt++],"END IF");
                }
                }
            }
          strcpy(SplitStk[SplitCnt++],"ELSE");
          strcpy(SplitStk[SplitCnt],trim(Tmp+4));
          goto REDO;
        }
      else
        {
          ifp=iMatchNQ(Tmp," else ");
          if(ifp)
            {
              strcpy(SplitStk[SplitCnt++],rtrim(left(Tmp,ifp-1)));
              strcpy(Tmp,mid(Tmp,ifp+1));
              goto LFTLSE;
            }
        }
    }
}


int SplitLines (char *Arg)
{
   PCHAR  p=Arg;
   PCHAR  st=Arg;
  int     i=0;
  int     IfFlag=0;
  int     SpcolonFlag=0;
  int     ParaCnt=0;
  if(*p==33||*p==36)
    {
      return 0;
    }
  while(*p)
    {
      if(*p==32)
        {
          SpcolonFlag=1;
        }
      if(*p==34)
        {
          while(*(++p)!=34)
            {
              if(*p==0)
                {
                  return SplitCnt;
                }
            }
        }
      if(*p==40)
        {
          ParaCnt++;
        }
      if(*p==41)
        {
          ParaCnt--;
        }
      if(*p==58&&*(p+1)!=61)
        {
          if(*(p+1)==58)
            {
              *p=-15;
              *(p+1)=-15;
            }
          else
            {
              if(*(p+1)!=0||SpcolonFlag)
                {
                  while(*st==32)
                    {
                      st++;
                    }
                  SplitCnt++;
                  while(st<p)
                    {
                      SplitStk[SplitCnt][i++]=*(st++);
                    }
                  while(SplitStk[SplitCnt][i-1]==32)
                    {
                      i--;
                    }
                  SplitStk[SplitCnt][i]=0;
                  if(ParaCnt==0)
                    {
                      i=0;
                      st++;
                      ProcSingleLineIf( &IfFlag);
                    }
                  else
                    {
                      SplitCnt--;
                    }
                }
            }
        }
      p++;
    }
  if(SplitCnt>0)
    {
      while(*st==32)
        {
          st++;
        }
      SplitCnt++;
      while(*st)
        {
          SplitStk[SplitCnt][i++]=*(st++);
        }
      SplitStk[SplitCnt][i]=0;
      ProcSingleLineIf( &IfFlag);
    }
  else if(iMatchLft(Arg,"if ")&&!iMatchRgt(Arg," then"))
    {
      strcpy(SplitStk[++SplitCnt],Arg);
      ProcSingleLineIf( &IfFlag);
    }
  if(IfFlag)
    {
      while(IfFlag)
        {
          strcpy(SplitStk[++SplitCnt],"END IF");
          IfFlag--;
        }
    }
  return SplitCnt;
}


int iMatch (char *Arg, char *MatchStr, int mt)
{
  if(mt==2)
    {
      int     L1;
      int     L2;
      L1=strlen(Arg);
      L2=strlen(MatchStr);
      if(L1<L2)
        {
          return 0;
        }
      Arg=(Arg+L1)-L2;
    }
  while(*MatchStr)
    {
      if(*Arg==0)
        {
          return 0;
        }
      if((*Arg BOR 32)!=(*MatchStr BOR 32))
        {
          return 0;
        }
      Arg++;
      MatchStr++;
    }
  if(mt&&*Arg!=0)
    {
      return 0;
    }
  return 1;
}


int iMatchNQ (char *Arg, char *MatchStr)
{
  int     mi=0;
   PCHAR  a=Arg;
  while(MatchStr[mi])
    {
      if(*a==34)
        {
          mi=0;
          while(*(++a)!=34)
            {
              if(*a==0)
                {
                  return 0;
                }
            }
        }
      if(a[mi]==0)
        {
          return 0;
        }
      if((a[mi] BOR 32)!=(MatchStr[mi] BOR 32))
        {
          a++;
          mi=-1;
        }
      mi++;
    }
  return (a-Arg)+1;
}


int SpecialCaseHandler (char *Arg)
{
  int     i;
  int     j;
  char lsz[2048];
  if(iMatchNQ(Arg," sub ")||iMatchNQ(Arg," function "))
    {
      return 0;
    }
  if(iMatchNQ(Arg,"function main("))
    {
      strcpy(SrcStk[++SrcCnt],Arg);
      strcpy(SrcStk[++SrcCnt],"G_argc = argc");
      strcpy(SrcStk[++SrcCnt],"G_argv = argv");
      goto PROCESSNEW;
    }
  strcpy(lsz, join(3,SPC,extract(Arg," "),SPC));
  if(iMatchNQ(" dim , local , global , raw , static , shared , dynamic , auto , register , extern ",lsz))
    {
      FastLexer(Arg," ",",(){}");
      for(i=1; i<=Ndx; i+=1)
        {
          if(iMatchWrd(Stk[i],"as"))
            {
              strcpy(Stk[i-1],Clean(Stk[i-1]));
            }
        }
      strcpy(Stk[2], join(3,SPC,Stk[2],SPC));
      if(iMatchNQ(" raw local dynamic register static shared auto ",Stk[2]))
        {
          strcpy(Stk[1], join(2,Stk[1],Stk[2]));
          *Stk[2]=0;
        }
      SrcCnt++;
      j=0;
      for(i=1; i<=Ndx; i+=1)
        {
          if(Stk[i][0]==40)
            {
              j++;
            }
          if(Stk[i][0]==123)
            {
              j++;
            }
          if(Stk[i][0]==41)
            {
              j--;
            }
          if(Stk[i][0]==125)
            {
              j--;
            }
          if(Stk[i][0]==44&&!j)
            {
              strcpy(Stk[i],Stk[1]);
              SrcCnt++;
            }
          strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt],Stk[i]," "));
        }
      goto PROCESSNEW;
    }
  for(;;)
  {
    if(TRUE==iMatchLft(Arg,"on "))
      {
        int     Target;
        j=0;
        FastLexer(Arg," ",",");
        for(i=1; i<=Ndx; i+=1)
          {
            if(iMatchLft(Stk[i],"gosub")||iMatchLft(Stk[i],"goto")||iMatchLft(Stk[i],"call"))
              {
                Target=i+1;
                break;
              }
          }
        strcpy(SrcStk[++SrcCnt],"select case ");
        for(i=2; i<=Target-2; i+=1)
          {
            strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt]," ",Stk[i]));
          }
        for(i=Target; i<=Ndx; i+=1)
          {
            if(str_cmp(Stk[i],",")==0)
              {
                continue;
              }
            j++;
            strcpy(SrcStk[++SrcCnt], join(2,"case",str(j)));
            strcpy(SrcStk[++SrcCnt], join(3,Stk[Target-1]," ",Stk[i]));
          }
        strcpy(SrcStk[++SrcCnt],"end select");
        goto PROCESSNEW;
      }
    if(TRUE==iMatchLft(Arg,"loop "))
      {
        FastLexer(Arg," ",",()");
        if(iMatchLft(Stk[2],"until"))
          {
            strcpy(SrcStk[++SrcCnt],"if ");
            for(i=3; i<=Ndx; i+=1)
              {
                strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt],Stk[i]," "));
              }
            strcpy(SrcStk[SrcCnt], join(2,SrcStk[SrcCnt]," then"));
            strcpy(SrcStk[++SrcCnt],"exit loop");
            strcpy(SrcStk[++SrcCnt],"end if");
            strcpy(SrcStk[++SrcCnt],"loop");
            goto PROCESSNEW;
          }
        else if(iMatchLft(Stk[2],"while"))
          {
            strcpy(SrcStk[++SrcCnt],"if NOT (");
            for(i=3; i<=Ndx; i+=1)
              {
                strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt],Stk[i]," "));
              }
            strcpy(SrcStk[SrcCnt], join(2,SrcStk[SrcCnt],") then"));
            strcpy(SrcStk[++SrcCnt],"exit loop");
            strcpy(SrcStk[++SrcCnt],"end if");
            strcpy(SrcStk[++SrcCnt],"loop");
            goto PROCESSNEW;
          }
        else
          {
            if(Ndx>1)
              {
                Abort(join(3,"UNKNOWN Word ",Stk[2]," After LOOP"));
              }
          }
        break;
      }
    if(TRUE==iMatchLft(Arg,"do "))
      {
        FastLexer(Arg," ",",()");
        if(iMatchLft(Stk[2],"until"))
          {
            strcpy(SrcStk[++SrcCnt],"do");
            strcpy(SrcStk[++SrcCnt],"if ");
            for(i=3; i<=Ndx; i+=1)
              {
                strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt],Stk[i]," "));
              }
            strcpy(SrcStk[SrcCnt], join(2,SrcStk[SrcCnt],"then"));
            strcpy(SrcStk[++SrcCnt],"exit loop");
            strcpy(SrcStk[++SrcCnt],"end if");
            goto PROCESSNEW;
          }
        else if(iMatchLft(Stk[2],"while"))
          {
            strcpy(SrcStk[++SrcCnt],"while ");
            for(i=3; i<=Ndx; i+=1)
              {
                strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt],Stk[i]," "));
              }
            goto PROCESSNEW;
          }
        else
          {
            if(Ndx>1)
              {
                Abort(join(3,"UNKNOWN Word ",Stk[2]," After DO"));
              }
          }
      }
    break;
  }
  return 0;

PROCESSNEW:;
  Ndx=i=0;
  while(SrcCnt)
    {
      strcpy(Arg,SrcStk[++i]);
      *SrcStk[i]=0;
      SrcCnt--;
      Parse(Arg);
      if(Ndx)
        {
          Emit();
        }
    }
  return TRUE;
}


void FastLexer (char * Arg,char * delim1,char * delim2,int TokQuote)
{
  int     cnt1=0;
  int     cnt2=0;
   PCHAR  pd1;
   PCHAR  pd2;
  Ndx=1;
  while(Arg[cnt1])
    {
      if(Arg[cnt1]==34)
        {
          if(cnt2&&TokQuote)
            {
              Stk[Ndx++][cnt2]=0;
              cnt2=0;
            }
          Stk[Ndx][cnt2]=34;
          while(Arg[++cnt1]!=34)
            {
              Stk[Ndx][++cnt2]=Arg[cnt1];
              if(Arg[cnt1]==0)
                {
                  return;
                }
            }
          Stk[Ndx][++cnt2]=Arg[cnt1];
          if(TokQuote)
            {
              Stk[Ndx++][++cnt2]=0;
              cnt2=0;
              goto AGAIN;
            }
        }
      pd1=delim1;
      while(*pd1)
        {
          if(*(pd1++)==Arg[cnt1])
            {
              if(cnt2)
                {
                  Stk[Ndx++][cnt2]=0;
                  cnt2=0;
                }
              goto AGAIN;
            }
        }
      pd2=delim2;
      while(*pd2)
        {
          if(*(pd2++)==Arg[cnt1])
            {
              if(cnt2)
                {
                  Stk[Ndx++][cnt2]=0;
                }
              Stk[Ndx][0]=Arg[cnt1];
              Stk[Ndx++][1]=0;
              cnt2=0;
              goto AGAIN;
            }
        }
      Stk[Ndx][cnt2++]=Arg[cnt1];

AGAIN:;
      cnt1++;
    }
  Stk[Ndx][cnt2]=0;
  if(cnt2==0)
    {
      Ndx--;
    }
}


void InsertTokens (int PosAfter, int NumTokens, ...)
{
   va_list  ap;
  int     i;
  for(i=Ndx; i>=PosAfter+1; i+=-1)
    {
      strcpy(Stk[i+NumTokens],Stk[i]);
    }
  va_start(ap,NumTokens);
  for(i=PosAfter+1; i<=PosAfter+NumTokens; i+=1)
    {
      strcpy(Stk[i],va_arg(ap,char*));
    }
  va_end(ap);
  Ndx+=(NumTokens);
}


void EmitExportDef (char *fs)
{
  static int     beenhere;
  char fname[2048];
  char funcname[2048];
  int     i;
  int     st=1;
  int     sz=0;
  strcpy(fname, join(2,extract(FileIn,"."),".def"));
  if(!beenhere)
    {
      if((fpdef=fopen(fname,"w"))==0)
       {
         fprintf(stderr,"Can't open file %s\n",fname);
         exit(1);
       }
      _splitpath_(FileIn,NULL,NULL,fname,NULL);
      fprintf(fpdef,"%s%s\n","LIBRARY ",enc(fname));
      fprintf(fpdef,"%s\n","EXPORTS");
      beenhere=TRUE;
    }
  FastLexer(fs,"","(,)");
  while(*Stk[st]!=40)
    {
      st++;
    }
  for(i=st+1; i<=Ndx; i+=1)
    {
      if(*Stk[i]==41)
        {
          break;
        }
      if(*Stk[i]!=44)
        {
          if(inchr(Stk[i],"*"))
            {
              sz+=(4);
              continue;
            }
          if(instr_b(Stk[i],"longlong",1,1)||instr_b(Stk[i],"double",1,1)||instr_b(Stk[i],"long long"))
            {
              sz+=(8);
              continue;
            }
          if(!inchr(Stk[i],"void"))
            {
              sz+=(4);
            }
        }
    }
  strcpy(Stk[1],trim(Stk[1]));
  strcpy(funcname,mid(Stk[1],InstrRev(Stk[1]," ")+1));
  fprintf(fpdef,"%s%s%s%s%s\n",funcname," = _",funcname,"@",ltrim(str(sz)));
}


char * GetArg (int ArgNum, functionParse* fp)
{
  char *BCX_RetStr={0};
  char RetArg[2048];
  int     ArgEnd=fp->CommaPos[ArgNum]-1;
  int     ArgStart=fp->CommaPos[ArgNum-1]+1;
  *RetArg=0;
  if(ArgNum>=fp->NumArgs)
    {
      ArgEnd=Ndx;
    }
  for(ArgStart=ArgStart; ArgStart<=ArgEnd; ArgStart+=1)
    {
      strcat(RetArg,Stk[ArgStart]);
    }
  BCX_RetStr=BCX_TmpStr(strlen(RetArg));
  strcpy(BCX_RetStr,RetArg);
  return BCX_RetStr;
}


int SepFuncArgs (int Strt, functionParse* fp, int functionflag)
{
  int     CountR=0;
  int     i=Strt;
  if(functionflag)
    {
      while(i<=Ndx)
        {
          if(Stk[i][0]==40)
            {
              break;
            }
          i++;
        }
      Strt=i+1;
      fp->NumArgs=0;
      fp->CommaPos[0]=i;
      if(Strt>Ndx)
        {
          return 0;
        }
    }
  else
    {
      Strt=2;
      fp->CommaPos[0]=1;
    }
  if(*Stk[Strt]==41)
    {
      fp->CommaPos[1]=Strt;
      return 0;
    }
  fp->NumArgs=1;
  for(i=Strt; i<=Ndx; i+=1)
    {
      if(*Stk[i]==40||*Stk[i]==91)
        {
          CountR++;
        }
      else if(*Stk[i]==41||*Stk[i]==93)
        {
          if(CountR==0)
            {
              fp->CommaPos[fp->NumArgs]=i;
              break;
            }
          CountR--;
        }
      else if(*Stk[i]==44&&CountR==0)
        {
          fp->CommaPos[fp->NumArgs]=i;
          fp->NumArgs++;
        }
    }
  if(functionflag==0)
    {
      fp->CommaPos[fp->NumArgs]=Ndx;
    }
  return fp->NumArgs;
}


PCHAR MakeDecProto (functionParse* fp)
{
   functionParse  fpp;
  char FunType[2048];
  char AsType[2048];
  char AsArrys[2048];
  int     FoundAs;
  int     pointer=0;
  int     i;
  int     ii;
  char OptValue[2048];
  int     OptFlag=0;
  static char Proto[2048];
  static int     SubFunPtr;
  if(SubFunPtr)
    {
      goto ARGPARSE;
    }
  *Proto=0;
  *FunType=0;
  if(iMatchWrd(Stk[2],"sub")||iMatchWrd(Stk[2],"constructor")||iMatchWrd(Stk[2],"destructor"))
    {
      strcpy(FunType,"void");
    }
  else if(*Stk[Ndx]==41)
    {
      strcpy(FunType,VarTypeLookup[inchr(VarTypes,right(Stk[3],1))]);
    }
  else
    {
      for(i=Ndx; i>=fp->CommaPos[fp->NumArgs]+1; i+=-1)
        {
          if(iMatchWrd(Stk[i],"ptr"))
            {
              pointer++;
            }
          else if(iMatchWrd(Stk[i],"as"))
            {
              break;
            }
          else
            {
              strcpy(FunType, join(3,Stk[i],SPC,FunType));
            }
        }
    }
  if(InTypeDef)
    {
      if(iMatchWrd(Stk[2],"constructor"))
        {
          strcpy(Proto, join(2,Clean(Stk[3]),"("));
        }
      else if(iMatchWrd(Stk[2],"destructor"))
        {
          strcpy(Proto, join(3,"~",Clean(Stk[3]),"("));
        }
      else
        {
          strcpy(Proto, join(4,FunType," ",Clean(Stk[3]),"("));
        }
      char Var[2048];
      int     w;
      int     id;
      int     vt;
      strcpy(Var, join(2,FunType,stringx(pointer,42)));
      GetTypeInfo(Var, &w, &id, &vt);
      AddTypedefElement(BaseTypeDefsCnt[InTypeDef],vt,Clean(Stk[3]),FunType,0);
    }
  else if(SFPOINTER)
    {
      strcpy(Proto, join(7,"typedef ",FunType," (",CallType,"*",Clean(Stk[3]),"_TYPE)("));
    }
  else if(!NoTypeDeclare)
    {
      strcpy(Proto, join(7,"typedef ",FunType," (",CallType,"*BCXFPROT",ltrim(str(DllCnt)),")("));
    }
  else
    {
      if(UseCProto)
        {
          UseCProto=FALSE;
          strcpy(Proto, join(7,FunType,"  ",stringx(pointer,42),SPC,CallType,Clean(Stk[3]),"("));
        }
      else
        {
          strcpy(Proto, join(8,"C_IMPORT ",FunType,"  ",stringx(pointer,42),SPC,CallType,Clean(Stk[3]),"("));
        }
    }

ARGPARSE:;
  if(fp->NumArgs==0)
    {
      if(iMatchWrd(Stk[2],"destructor")||iMatchWrd(Stk[2],"constructor")||Use_Virtual)
        {
          strcat(Proto,")");
        }
      else
        {
          strcat(Proto,"void)");
        }
    }
  else
    {
      for(ii=0; ii<=fp->NumArgs-1; ii+=1)
        {
          *OptValue=0;
          *AsType=0;
          *AsArrys=0;
          pointer=0;
          FoundAs=0;
          int     FirstToken=fp->CommaPos[ii]+1;
          int     LastToken=fp->CommaPos[ii+1]-1;
          int     NumOfTokens=(LastToken-FirstToken)+1;
          i=inchr(Stk[FirstToken],"[");
          if(i)
            {
              strcpy(AsArrys,mid(Stk[FirstToken],i));
              Stk[FirstToken][i-1]=0;
            }
          if(NumOfTokens==1)
            {
              strcpy(AsType,VarTypeLookup[inchr(VarTypes,right(Stk[FirstToken],1))]);
              if(*AsArrys)
                {
                  strcpy(AsType,RemoveStr(AsType,"*"));
                }
              else
                {
                  pointer=tally(Stk[FirstToken],"*");
                }
              FoundAs=TRUE;
            }
          else
            {
              for(i=LastToken; i>=FirstToken; i+=-1)
                {
                  if(iMatchWrd(Stk[i],"ptr")||*Stk[i]==42)
                    {
                      pointer++;
                    }
                  else if(iMatchWrd(Stk[i],"sub"))
                    {
                      SepFuncArgs(fp->CommaPos[ii]+2, &fpp,TRUE);
                      strcat(Proto,"void (*)(");
                      SubFunPtr=FoundAs=TRUE;
                      MakeDecProto( &fpp);
                      SubFunPtr=FALSE;
                      break;
                    }
                  else if(iMatchWrd(Stk[i],"function"))
                    {
                      SepFuncArgs(fp->CommaPos[ii]+2, &fpp,TRUE);
                      if(AsType[0]==0)
                        {
                          strcpy(AsType,VarTypeLookup[inchr(VarTypes,right(Stk[FirstToken],1))]);
                        }
                      strcpy(Proto, join(4,Proto,rtrim(AsType),stringx(pointer,42)," (*)("));
                      pointer=0;
                      *AsType=0;
                      SubFunPtr=FoundAs=TRUE;
                      MakeDecProto( &fpp);
                      SubFunPtr=FALSE;
                      break;
                    }
                  else if(iMatchWrd(Stk[i],"as"))
                    {
                      if(AsType[0]==0)
                        {
                          Abort(join(2,"No type specified for argument",str(ii+1)));
                        }
                      FoundAs=TRUE;
                      break;
                    }
                  else if(*Stk[i]==61)
                    {
                      OptFlag=FoundAs=TRUE;
                      strcpy(OptValue, join(2," =",AsType));
                      *AsType=0;
                      if(i==FirstToken+1)
                        {
                          strcpy(AsType,VarTypeLookup[inchr(VarTypes,right(Stk[FirstToken],1))]);
                          if(*AsArrys)
                            {
                              strcpy(AsType,RemoveStr(AsType,"*"));
                            }
                          else
                            {
                              pointer=tally(Stk[FirstToken],"*");
                            }
                          break;
                        }
                    }
                  else
                    {
                      if(*Stk[i]!=46)
                        {
                          strcpy(AsType, join(3,Stk[i],SPC,AsType));
                        }
                      else
                        {
                          if(*Stk[i-1]==46)
                            {
                              if(OptFlag)
                                {
                                  Abort("Default value not allowed when using variable arguments");
                                }
                              if(ii!=(fp->NumArgs-1))
                                {
                                  Abort("Variable argument must be the last parameter");
                                }
                              if(fp->NumArgs==1)
                                {
                                  Abort("Variable argument must be preceded by at least one other parameter");
                                }
                              FoundAs=TRUE;
                            }
                          strcpy(AsType, join(2,Stk[i],AsType));
                        }
                    }
                }
            }
          if(!FoundAs)
            {
              Abort(join(2,"Malformed argument type in parameter",str(ii+1)));
            }
          if(ii!=fp->NumArgs&&OptFlag&&str_cmp(OptValue,"")==0)
            {
              Warning(join(2,"No default value specified for parameter",str(ii+1)),1);
            }
          strcpy(Proto, join(6,Proto,rtrim(AsType),AsArrys,stringx(pointer,42),OptValue,Stk[fp->CommaPos[ii+1]]));
        }
    }
  return Proto;
}


void AsmUnknownStructs (int CompArrays)
{
  int     InBrace=0;
  int     InStruct=0;
  int     i;
  char sztemp[2048];
  for(i=2; i<=Ndx; i+=1)
    {
      if(CompArrays)
        {
          if(str_cmp(Stk[i],"[")==0)
            {
              strcpy(sztemp,Stk[i-1]);
              *Stk[i-1]=0;
              for(;;)
                {
                  strcat(sztemp,Stk[i]);
                  if(str_cmp(Stk[i],"]")==0)
                    {
                      InBrace--;
                    }
                  if(str_cmp(Stk[i],"[")==0)
                    {
                      InBrace++;
                    }
                  *Stk[i]=0;
                  i++;
                  if(!(InBrace&&i<=Ndx))
                    {
                      break;
                    }
                }
              strcpy(Stk[--i],sztemp);
            }
        }
      if(strlen(Stk[i])>1&&!IsNumber(Stk[i]+1))
        {
          if(*Stk[i]==46||iMatchLft(Stk[i],"->"))
            {
              if(InStruct==0)
                {
                  strcpy(Stk[i], join(2,Stk[i-1],Stk[i]));
                  *Stk[i-1]=0;
                  InStruct=i;
                }
              else
                {
                  strcat(Stk[InStruct],Stk[i]);
                  *Stk[i]=0;
                }
              continue;
            }
        }
      if(*Stk[i]&&InStruct>0)
        {
          InStruct=0;
        }
    }
  RemEmptyTokens();
}


void EmitIfCond (char *CondType)
{
  int     TestString;
  int     A;
  int     B;
  int     ParCnt;
  int     Tmp;
  int     IsWhile=FALSE;
  char szTest[2048];
  TestString=DataType(Stk[2]);
  if(TestString==vt_STRVAR)
    {
      if(str_cmp(Stk[4],DDQ)==0)
        {
          strcpy(Stk[2], join(2,Clean(Stk[2]),"[0]"));
          strcpy(Stk[4],"0");
        }
      else if(str_cmp(Stk[3],"[")==0 &&  str_cmp(Stk[7],DDQ)==0)
        {
          strcpy(Stk[2],Clean(Stk[2]));
          strcat(Stk[5],"[0]");
          strcpy(Stk[7],"0");
        }
    }
  if(str_cmp(CondType,"while")==0)
    {
      IsWhile=TRUE;
    }
  fprintf(Outfile,"%s%s%s",Scoot,CondType,"(");
  Tmp=2;
  while(str_cmp(Stk[Tmp],"(")==0 ||  str_cmp(Stk[Tmp],"!")==0)
    {
      fprintf(Outfile,"%s",Stk[Tmp]);
      Tmp++;
    }
  TestString=FALSE;
  A=DataType(Stk[Tmp]);
  if(A==vt_STRLIT||A==vt_STRVAR)
    {
      if(str_cmp(Stk[Tmp+1],")")!=0 && !iMatchWrd(Stk[Tmp+1],"then"))
        {
          TestString=TRUE;
          Use_Str_Cmp=TRUE;
          fprintf(Outfile,"%s","str_cmp(");
        }
    }
  *szTest=0;
  ParCnt=0;
  for(;;)
    {
      if(TestString)
        {
          if(str_cmp(Stk[Tmp],"=")==0)
            {
              strcpy(Stk[Tmp],",");
              strcpy(szTest,")==0");
              ParCnt=0;
            }
          else if(str_cmp(Stk[Tmp],"!=")==0)
            {
              strcpy(Stk[Tmp],",");
              strcpy(szTest,")!=0");
              ParCnt=0;
            }
          else if(str_cmp(Stk[Tmp],">")==0)
            {
              if(str_cmp(Stk[Tmp+1],"=")==0)
                {
                  strcpy(Stk[Tmp],",");
                  strcpy(szTest,")>=0");
                  *Stk[Tmp+1]=0;
                }
              else
                {
                  strcpy(Stk[Tmp],",");
                  strcpy(szTest,")==1");
                }
              ParCnt=0;
            }
          else if(str_cmp(Stk[Tmp],"<")==0)
            {
              if(str_cmp(Stk[Tmp+1],"=")==0)
                {
                  strcpy(Stk[Tmp],",");
                  strcpy(szTest,")<=0");
                  *Stk[Tmp+1]=0;
                }
              else
                {
                  strcpy(Stk[Tmp],",");
                  strcpy(szTest,")==-1");
                }
              ParCnt=0;
            }
          else if(str_cmp(Stk[Tmp],"(")==0)
            {
              ParCnt++;
            }
          else if(str_cmp(Stk[Tmp],")")==0)
            {
              ParCnt--;
            }
          if(str_cmp(Stk[Tmp],")")==0 &&  str_cmp(szTest,"")!=0 && ParCnt<0)
            {
              fprintf(Outfile,"%s%s",szTest,Stk[Tmp]);
              *szTest=0;
            }
          else
            {
              if(str_cmp(Stk[Tmp],"||")==0 ||  str_cmp(Stk[Tmp],"&&")==0)
                {
                  strcpy(Stk[Tmp], join(4,szTest," ",Stk[Tmp]," "));
                  *szTest=0;
                  B=1;
                  while(str_cmp(Stk[Tmp+B],"(")==0)
                    {
                      strcat(Stk[Tmp],"(");
                      *Stk[Tmp+B]=0;
                      B++;
                    }
                  A=DataType(Stk[Tmp+B]);
                  if((A==vt_STRLIT||A==vt_STRVAR)&&str_cmp(Stk[Tmp+B+1],")")!=0)
                    {
                      strcat(Stk[Tmp]," str_cmp(");
                      Use_Str_Cmp=TRUE;
                    }
                  else
                    {
                      fprintf(Outfile,"%s",Clean(Stk[Tmp]));
                      TestString=FALSE;
                      goto NXTTOKEN;
                    }
                }
              fprintf(Outfile,"%s",Clean(Stk[Tmp]));
            }
        }
      else
        {
          if(str_cmp(Stk[Tmp],"||")==0 ||  str_cmp(Stk[Tmp],"&&")==0)
            {
              B=1;
              while(str_cmp(Stk[Tmp+B],"(")==0)
                {
                  strcat(Stk[Tmp],"(");
                  *Stk[Tmp+B]=0;
                  B++;
                }
              A=DataType(Stk[Tmp+B]);
              if((A==vt_STRLIT||A==vt_STRVAR)&&str_cmp(Stk[Tmp+B+1],")")!=0)
                {
                  strcat(Stk[Tmp],"str_cmp(");
                  TestString=TRUE;
                  Use_Str_Cmp=TRUE;
                  *szTest=0;
                  ParCnt=0;
                  fprintf(Outfile,"%s",Clean(Stk[Tmp]));
                  goto NXTTOKEN;
                }
            }
          if(str_cmp(Stk[Tmp],"!")==0)
            {
              fprintf(Outfile,"%s",Stk[Tmp]);
            }
          else
            {
              fprintf(Outfile,"%s",Clean(Stk[Tmp]));
            }
          if(str_cmp(Stk[Tmp],"=")==0)
            {
              if(str_cmp(Stk[Tmp-1],"<")!=0 &&  str_cmp(Stk[Tmp-1],">")!=0)
                {
                  if(str_cmp(Stk[Tmp+1],">")!=0 &&  str_cmp(Stk[Tmp+1],"<")!=0)
                    {
                      fprintf(Outfile,"%s","=");
                    }
                }
            }
        }

NXTTOKEN:;
      Tmp++;
      if(!IsWhile)
        {
          if(iMatchWrd(Stk[Tmp],"then"))
            {
              break;
            }
          else if(Tmp>Ndx)
            {
              Abort("If Without THEN");
            }
        }
      if(Tmp>Ndx)
        {
          break;
        }
    }
  fprintf(Outfile,"%s%s\n",szTest,")");
  BumpUp();
  fprintf(Outfile,"%s%s\n",Scoot,"{");
  BumpUp();
}


void PrintGlobal (int A, int idx, char *Storage, char *P, char *VarName, char *VarDim)
{
  char VAR[2048];
  for(;;)
  {
    if(A==vt_FILEPTR)
      {
        strcpy(VarName,RemoveStr(VarName,"@"));
        fprintf(Outfile,"%s%s%s%s%s%s\n",Storage,"FILE   *",P,VarName,VarDim,";");
        break;
      }
    if(A==vt_UDT||A==vt_STRUCT||A==vt_UNION)
      {
        strcpy(VAR,TypeDefs[GlobalVars[idx].VarDef].VarName);
        strcpy(VAR,rpad(VAR,7));
        fprintf(Outfile,"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
        break;
      }
    if(A==vt_BOOL)
      {
        fprintf(Outfile,"%s%s%s%s%s\n",Storage,"bool    ",VarName,VarDim,";");
        break;
      }
    if(A==vt_STRVAR)
      {
        if(VarDim[0]==0)
          {
            strcpy(VarDim,"[65535]");
          }
        fprintf(Outfile,"%s%s%s%s%s%s\n",Storage,"char    ",P,VarName,VarDim,";");
        break;
      }
    if(A>=vt_VarMin&&A<=vt_VarMax)
      {
        strcpy(VAR,GetVarTypeName(GlobalVars[idx].VarType));
        strcpy(VAR,rpad(VAR,7));
        fprintf(Outfile,"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
      }
    break;
  }
}


void ReDirectFPrint (FILE* TgtFile, char *pat, ...)
{
   va_list  ap;
  if(DoCountLines&&TgtFile==FP3)
    {
      gLinesWritten++;
    }
  va_start(ap,pat);
  vfprintf(TgtFile,pat,ap);
  va_end(ap);
}


int IsReservedWord (char *match)
{
  char mat[2048];
  strcpy(mat,ucase(match));
  if(containedin(mat,ReservedWord)==0)
    {
      return 1;
    }
  return 0;
}


int GetAsPos (void)
{
  int     i;
  for(i=Ndx; i>=2; i+=-1)
    {
      if(iMatchWrd(Stk[i],"as"))
        {
          return i;
        }
    }
  return 0;
}


void FreeGlobals (void)
{
  if(RmLibs)free(RmLibs);
  if(WarnMsg)free(WarnMsg);
  if(AbortSrc)free(AbortSrc);
  if(Src)free(Src);
  if(szTmp)free(szTmp);
}