AIR/MBC
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
6d59a74922
MBC/mbc4.cc

20629 lines
623 KiB
C++
Raw Normal View History

Initial Code Commit
2022-07-28 18:29:51 +00:00
// *********************************************************************
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
// Created with MBC (V) 4.0-Beta4 (2022/07/26)Ported to OSX by Armando Rivera
Initial Code Commit
2022-07-28 18:29:51 +00:00
// 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
// *************************************************
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
#define Version "4.0-Beta4 (2022/07/26)"
Initial Code Commit
2022-07-28 18:29:51 +00:00
#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*
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
#define iMatchLft(A,B) iMatch ((char *)A ,(char *)B ,0)
#define iMatchWrd(A,B) iMatch ((char *)A ,(char *)B ,1)
#define iMatchRgt(A,B) iMatch ((char *)A ,(char *)B ,2)
Initial Code Commit
2022-07-28 18:29:51 +00:00
// *************************************************
// 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.
// ******************************************************************************************
// -------------------------------------------
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
// 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
// -------------------------------------------
Initial Code Commit
2022-07-28 18:29:51 +00:00
// 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)
{
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
int c, status = ((c = fgetc(stream)) == EOF);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
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);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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__)
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n","MBC4: Ported to Mac OSX by Armando Rivera (c) 2009-2018");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#else
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n","MBC4: Based on Linux BCX by Mike Henning (c) 2009");
printf((char*)"%s%s\n","(c) 2009-2018 Armando Rivera with additional code (c) 2009 John Jacques",LF);
Initial Code Commit
2022-07-28 18:29:51 +00:00
#endif
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%s%s","Version ",Version," Compiled with ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
// FP3
#if defined __BCPLUSPLUS__// OUTFILE
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n","Borland C++");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#elif defined __BORLANDC__
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n","Borland C");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#elif defined __POCC__
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n","Pelles C");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#elif defined __GNUG__
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n","GNU G++");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#else
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n","Unknown");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#endif // Main
if(bitz==64)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"\n");
printf((char*)"%s\n","********************");
printf((char*)"%s\n","** 64 BIT VERSION **");
printf((char*)"%s%s\n","********************",LF);
}
printf((char*)"%s%s%s\n"," Usage: ",AppExeName()," infile [.bas] [options]");
printf((char*)"%s\n"," [-c] Generate C++ Compatible code");
printf((char*)"%s%s%s\n"," [-d] DEFINE a constant ... ex. ",AppExeName()," MyFile -D:MyConst[=SomeValue]");
printf((char*)"%s\n"," [-e] Write ERRORS to BCX.ERR file");
printf((char*)"%s%s%s\n"," [-f] Output FILENAME... ex. ",AppExeName()," MyFile -f:/MyFiles/MyFile.c");
printf((char*)"%s\n"," [-k] KILL the generated BCX generated 'C' file");
printf((char*)"%s\n"," [-o] OUTPUT a copy of the generated C file to STDOUT");
printf((char*)"%s\n"," [-q] QUIET - No output to screen during translation");
printf((char*)"%s\n"," [-s] Show STATUS of translation by line number");
printf((char*)"%s\n"," [-w] Enable WARNINGS during translation");
printf((char*)"%s%s%s\n"," [-t] TURBO Mode ON w/optional size ... ex. ",AppExeName()," MyFile -t[:1024]");
printf((char*)"%s\n"," [-u] Turn UNICODE Support ON");
Initial Code Commit
2022-07-28 18:29:51 +00:00
FreeGlobals();
fflush(stdout);
exit(0);
}
Quiet=FALSE;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%s\n","MBC Version ",Version);
Initial Code Commit
2022-07-28 18:29:51 +00:00
#if defined (__APPLE__)
IsApple=TRUE;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%s\n","MBC4: Ported to Mac OSX by Armando Rivera (c) 2009-2018",LF);
Initial Code Commit
2022-07-28 18:29:51 +00:00
#else
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n","MBC4: Based on Linux BCX by Mike Henning (c) 2009");
printf((char*)"%s%s\n","(c) 2009-2018 Armando Rivera with additional code (c) 2009 John Jacques",LF);
Initial Code Commit
2022-07-28 18:29:51 +00:00
#endif
if(bitz==64)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"\n");
printf((char*)"%s\n","********************");
printf((char*)"%s\n","** 64 BIT VERSION **");
printf((char*)"%s%s\n","********************",LF);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
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))
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"\n");
printf((char*)"%s%s\n","FILE NOT FOUND: ",command(1));
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Src,65535,SourceFile);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n","// [",trim(Modules[ModuleNdx])," - ",trim(str(ModuleLineNos[ModuleNdx])),"] ",Src);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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),");"));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
}
if(SrcFlag)
{
if(!iMatchLft(Src,"$sourc")&&*Src!=33)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n","// [",trim(Modules[ModuleNdx])," - ",trim(str(ModuleLineNos[ModuleNdx])),"] ",Src);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(ShowStatus)
{
locate (2,1,0);
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%s%s%d\n","Processing Module: ",trim(Modules[ModuleNdx])," - Line:",(int)ModuleLineNos[ModuleNdx]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Src[0]==33)
{
Src[0]=32;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",Src);
Initial Code Commit
2022-07-28 18:29:51 +00:00
*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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","// *********************************************************************");
fprintf(FP3,(char*)"%s%s%s\n","// Created with MBC (V) ",Version,"Ported to OSX by Armando Rivera");
fprintf(FP3,(char*)"%s\n","// Ported from BCX32 BASIC To C/C++ Translator (V) 5.12");
fprintf(FP3,(char*)"%s\n","// BCX (c) 1999 - 2018 by Kevin Diggins");
fprintf(FP3,(char*)"%s\n","// LinuxBC (c) 2009 by Mike Henning ");
fprintf(FP3,(char*)"%s\n","// MBC (c) 2009 - 2018 by Armando Rivera");
fprintf(FP3,(char*)"%s\n","// *********************************************************************");
fprintf(FP3,(char*)"%s\n","// Translated for compiling with the g++ Compiler");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(UseCpp)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","// g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$.cpp -ldl -o $FILE$");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","// g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$.cc -ldl -o $FILE$");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","// *********************************************************************");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(NoRT==FALSE)
{
if(Use_Osx)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#import <Cocoa/Cocoa.h>");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
/*****2010-11-24AddedWxCFORWXCONSOLEApps-AIR*****/;
if(Use_Wx||Use_WxC)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","// WXWIDGETS HEADER FILES //");
fprintf(FP3,(char*)"%s\n","#include <wx/wx.h>");
fprintf(FP3,(char*)"%s\n","#include <wx/process.h>");
fprintf(FP3,(char*)"%s\n","#include <wx/txtstrm.h>");
fprintf(FP3,(char*)"%s\n","#include <wx/msgdlg.h>");
fprintf(FP3,(char*)"%s\n","#include <wx/stdpaths.h>");
fprintf(FP3,(char*)"%s\n","#include <wx/event.h>");
fprintf(FP3,(char*)"%s\n","// ******************* //");
fprintf(FP3,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Gtk)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#include <gtk/gtk.h>");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Glib)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#include <glib.h>");
}
fprintf(FP3,(char*)"%s\n","#include <stdbool.h>");
fprintf(FP3,(char*)"%s\n","#include <ctype.h>");
fprintf(FP3,(char*)"%s\n","#include <math.h>");
fprintf(FP3,(char*)"%s\n","#include <stdio.h>");
fprintf(FP3,(char*)"%s\n","#include <iostream>");
fprintf(FP3,(char*)"%s\n","#include <fstream>");
fprintf(FP3,(char*)"%s\n","#include <string.h>");
fprintf(FP3,(char*)"%s\n","#include <stddef.h>");
fprintf(FP3,(char*)"%s\n","#include <stdlib.h>");
fprintf(FP3,(char*)"%s\n","#include <setjmp.h>");
fprintf(FP3,(char*)"%s\n","#include <time.h>");
fprintf(FP3,(char*)"%s\n","#include <stdarg.h>");
fprintf(FP3,(char*)"%s\n","#include <dirent.h>");
fprintf(FP3,(char*)"%s\n","#include <sys/types.h>");
fprintf(FP3,(char*)"%s\n","#include <sys/stat.h>");
fprintf(FP3,(char*)"%s\n","#include <sys/wait.h>");
fprintf(FP3,(char*)"%s\n","#include <unistd.h>");
fprintf(FP3,(char*)"%s\n","#include <dlfcn.h>");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#if defined (__APPLE__)
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#include <libproc.h>");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#endif
if(UseCpp)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#include <iostream>");
fprintf(FP3,(char*)"%s\n","#include <fstream>");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Instat)
{
Use_Keypress=TRUE;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#include <fcntl.h>");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Keypress)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#include <term.h>");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Socket)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#include <sys/socket.h>");
fprintf(FP3,(char*)"%s\n","#include <netinet/in.h>");
fprintf(FP3,(char*)"%s\n","#include <netdb.h>");
fprintf(FP3,(char*)"%s\n","#include <errno.h>");
fprintf(FP3,(char*)"%s\n","#include <arpa/inet.h>");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_RegEx)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#include <regex.h>");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
EmitCompilerDefines();
}
while(!EoF(FP2))
{
Z[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Z,65535,FP2);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n",Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
char Lastlyne[2048];
*Lastlyne=0;
while(!EoF(FP1))
{
static int bMainOut=0;
Z[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Z,65535,FP1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
if(iMatchLft(Lastlyne,"#if"))
{
if(iMatchLft(Z,"#endif"))
{
*Lastlyne=0;
continue;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n",Lastlyne);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
strcpy(Lastlyne,Z);
if(iMatchLft(Lastlyne,"#if"))
{
continue;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n",Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(bMainOut)
{
continue;
}
if(str_cmp(left(ltrim(Z),8),"int main")==0)
{
while(str_cmp(trim(Z),"{")!=0)
{
Z[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Z,65535,FP1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n",Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_StartupCode)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s%s\n",Scoot,"int BCX_SUCode = BCX_StartupCode_(); // execute user's startup code");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_ExitCode)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s%s\n",Scoot,"int BCX_EXCode = BCX_ExitCode_(); // Prepare for user's exit code");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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);
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%d%s%d%s","[Lines In:",(int)LinesRead,"] [Lines Out:",(int)gLinesWritten,"] ");
printf((char*)"%s%d%s%.7G%s\n","[Statements:",(int)Statements,"] [Time:",(float)Elapsed," sec's]");
Initial Code Commit
2022-07-28 18:29:51 +00:00
strcpy(Z, join(4,"BCX translated ",RemoveStr(FileIn," ")," to ",RemoveStr(FileOut," ")));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n",Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
PostProcess();
if(WarnMsg[0]>0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%s%s\n","Warnings! :",CRLF,WarnMsg);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(KillCFile)
{
remove (FileOut);
}
FreeGlobals();
return 0;
}
void EmitCmdLineConst (void)
{
if(CmdLineConst[0]>0)
{
static FILE* Ftmp;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n","");
fprintf(FP7,(char*)"%s\n","// ***************************************************");
fprintf(FP7,(char*)"%s\n","// Commandline Defines");
fprintf(FP7,(char*)"%s\n","// ***************************************************");
fprintf(FP7,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Ftmp=FP6;
FP6=FP7;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
void EmitCompilerDefines (void)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","");
fprintf(FP3,(char*)"%s\n","// ***************************************************");
fprintf(FP3,(char*)"%s\n","// Compiler Defines");
fprintf(FP3,(char*)"%s\n","// ***************************************************");
fprintf(FP3,(char*)"%s%s\n"," #define C_EXPORT extern ",enc("C"));
fprintf(FP3,(char*)"%s%s\n"," #define C_IMPORT extern ",enc("C"));
fprintf(FP3,(char*)"%s\n","");
fprintf(FP3,(char*)"%s\n","#ifndef stat");
fprintf(FP3,(char*)"%s\n"," #define lstat stat");
fprintf(FP3,(char*)"%s\n","#endif");
fprintf(FP3,(char*)"%s\n","#ifndef _fcloseall");
fprintf(FP3,(char*)"%s\n"," #define _fcloseall _fcloseall");
fprintf(FP3,(char*)"%s\n","#endif");
fprintf(FP3,(char*)"%s\n","#ifndef HWND");
fprintf(FP3,(char*)"%s\n"," #define HWND GHWND");
fprintf(FP3,(char*)"%s\n","#endif");
fprintf(FP3,(char*)"%s\n","#ifndef MAX_PATH");
fprintf(FP3,(char*)"%s\n"," #define MAX_PATH 2048");
fprintf(FP3,(char*)"%s\n","#endif");
fprintf(FP3,(char*)"%s\n","#ifndef CALLBACK");
fprintf(FP3,(char*)"%s\n"," #define CALLBACK");
fprintf(FP3,(char*)"%s\n","#endif");
fprintf(FP3,(char*)"%s\n","typedef unsigned int HINSTANCE;");
fprintf(FP3,(char*)"%s\n","typedef void* LPVOID;");
fprintf(FP3,(char*)"%s\n","typedef char* PCHAR;");
fprintf(FP3,(char*)"%s\n","typedef unsigned char BYTE;");
fprintf(FP3,(char*)"%s\n","typedef unsigned int UINT;");
fprintf(FP3,(char*)"%s\n","typedef unsigned char UCHAR;");
fprintf(FP3,(char*)"%s\n","typedef unsigned char* PUCHAR;");
fprintf(FP3,(char*)"%s\n","typedef unsigned long ULONG;");
fprintf(FP3,(char*)"%s\n","typedef unsigned long* ULONG_PTR;");
fprintf(FP3,(char*)"%s\n","typedef unsigned long DWORD;");
fprintf(FP3,(char*)"%s\n","");
fprintf(FP3,(char*)"%s\n","#ifndef TRUE");
fprintf(FP3,(char*)"%s\n"," #define TRUE 1");
fprintf(FP3,(char*)"%s\n","#endif");
fprintf(FP3,(char*)"%s\n","");
fprintf(FP3,(char*)"%s\n","#ifndef FALSE");
fprintf(FP3,(char*)"%s\n"," #define FALSE 0");
fprintf(FP3,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(!Use_Osx)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#define BOOL bool");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(UseCpp)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#define println(a) (std::cout << a << std::endl)");
fprintf(FP3,(char*)"%s\n"," typedef std::string CSTRING;");
fprintf(FP3,(char*)"%s\n"," typedef std::fstream CFILE;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
void MakeFreeGlobals (void)
{
strcpy(Src,"SUB FreeGlobals");
PassOne=1;
Parse(Src);
Emit();
while(GlobalDynaCnt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n"," ",GlobalDynaStr[GlobalDynaCnt]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,RemoveStr(VarCode.StaticOut,"static "));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,VarCode.StaticOut);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s",Scoot,Tipe," ",CVar);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s",Scoot,"static ",Tipe," ",CVar);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","[65535]=");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Stk[i]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(str_cmp(Stk[i],"=")==0)
{
break;
}
if(i==Ndx)
{
break;
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
while(!EoF(SourceFile))
{
Src[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Src,65535,SourceFile);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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))
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s"," ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(ii=1; ii<=Ndx; ii+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[ii]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","};\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
*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
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n","");
printf((char*)"%s%s\n","Program written for BCX Version ",Src);
printf((char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP4,(char*)"%s%s\n","#pragma pack ",ltrim(Src));
Initial Code Commit
2022-07-28 18:29:51 +00:00
*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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s%s%s\n","typedef ",remain(Src," "),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
*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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","try {");
Initial Code Commit
2022-07-28 18:29:51 +00:00
*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!"));
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"throw ",szTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
*Src=0;
return 0;
}
if(str_cmp(Z,"$catch")==0)
{
strcpy(szTmp,mid(Src,8));
if(szTmp[0]==0)
{
strcpy(szTmp,"char *str");
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","}");
fprintf(Outfile,(char*)"%s%s%s\n","catch (",szTmp,")");
fprintf(Outfile,(char*)"%s\n","{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
*Src=0;
return 0;
}
if(str_cmp(Z,"$endtr")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
*Src=0;
return 0;
}
if(str_cmp(Z,"$endna")==0)
{
InNameSpace--;
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
*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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n","using namespace ",szTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n","using namespace ",szTmp);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
*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++;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP4,(char*)"%s\n","#ifndef __cplusplus");
fprintf(FP4,(char*)"%s\n"," #error A C++ compiler is required");
fprintf(FP4,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP4,(char*)"%s%s%s\n","interface ",szTmp," {");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(;;)
{
if(EoF(SourceFile))
{
Abort("$Interface Without $EndInterface");
}
Src[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Src,65535,SourceFile);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
ModuleLineNos[ModuleNdx]++;
if(iMatchLft(ltrim(Src),"$endinterface"))
{
break;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP4,(char*)"%s\n",Src);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP4,(char*)"%s%s%s\n","}",trim(join(2,Src,13)),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
return 0;
}
if(str_cmp(Z,"$comme")==0)
{
*Src=0;
for(;;)
{
if(EoF(SourceFile))
{
Abort("Unbalanced $Comment");
}
Src[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Src,65535,SourceFile);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
ModuleLineNos[ModuleNdx]++;
StripTabs();
if(iMatchLft(ltrim(Src),"$comment"))
{
break;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n","// ",Src);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
*Src=0;
return 0;
}
if(str_cmp(Z,"$ccode")==0)
{
*Src=0;
for(;;)
{
if(EoF(SourceFile))
{
Abort("Unbalanced $Ccode");
}
Src[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Src,65535,SourceFile);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
ModuleLineNos[ModuleNdx]++;
StripTabs();
if(iMatchLft(ltrim(Src),"$ccode"))
{
if(SrcFlag)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s\n","// [",trim(Modules[ModuleNdx])," - ",trim(str(ModuleLineNos[ModuleNdx])),"] End of $CCODE Block");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
break;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",rtrim(Src));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
*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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n","// ***************************************************");
fprintf(FP7,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(;;)
{
if(EoF(SourceFile))
{
Abort("Unbalanced $Header");
}
Src[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Src,65535,SourceFile);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
ModuleLineNos[ModuleNdx]++;
StripTabs();
strcpy(Src,trim(Src));
if(iMatchLft(Src,"$heade"))
{
break;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n",Src);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
*Src=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Src,65535,SourceFile);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
ModuleLineNos[ModuleNdx]++;
if(SrcFlag)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n","// ",Src);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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);
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#if !defined( __POCC__ ) && !defined (__cplusplus )");
Initial Code Commit
2022-07-28 18:29:51 +00:00
strcpy(Src,replace(Src,chr(1),")"));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",Src);
fprintf(Outfile,(char*)"%s\n","#else");
Initial Code Commit
2022-07-28 18:29:51 +00:00
strcpy(SrcTmp,replace(SrcTmp,"_asm(","__asm{"));
strcpy(SrcTmp,replace(SrcTmp,chr(1),"}"));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",RemoveStr(SrcTmp,DQ));
fprintf(Outfile,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
*Src=0;
return 0;
}
if(str_cmp(Z,"#inclu")==0)
{
strcpy(Src,RemoveStr(lcase(Src),"#include"));
strcpy(Src,trim(Src));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s%s\n","#include ",Src);
Initial Code Commit
2022-07-28 18:29:51 +00:00
*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];
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
char *ZZ;
ZZ=(char*)calloc(256+65535,1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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");
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
BCX_RetStr=join(4,"printf((char*)",enc(Frmat),Clean(Arg),");");
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
if(ZZ)free(ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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];
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
char *ZZ;
ZZ=(char*)calloc(256+65535,1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"printf(",Clean(Stk[2]),");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"*",trim(Clean(Stak[i])),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
break;
}
if(j==vt_INTEGER)
{
strcat(Frmat,"%d");
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
break;
}
if(j==vt_SINGLE)
{
strcat(Frmat,"%g");
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
break;
}
if(j==vt_DOUBLE)
{
strcat(Frmat,"%lG");
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
break;
}
if(j==vt_LDOUBLE)
{
strcat(Frmat,"%lG");
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
break;
}
// case else
{
strcat(Frmat,"%d");
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
}
break;
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"AR_fgets_retval=fgets(InputBuffer,sizeof(InputBuffer),stdin);");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"InputBuffer[strlen(InputBuffer)-1]=0;");
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Scoot,"ScanError = scan(InputBuffer,",enc(Frmat),Arg,");\n");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"*InputBuffer=0;");
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
if(ZZ)free(ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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];
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
char *ZZ;
ZZ=(char*)calloc(256+65535,1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"*",trim(Clean(Stak[i])),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
break;
}
if(j==vt_INTEGER)
{
strcat(Frmat,"%d");
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
break;
}
if(j==vt_SINGLE)
{
strcat(Frmat,"%g");
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
break;
}
if(j==vt_DOUBLE)
{
strcat(Frmat,"%lG");
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
break;
}
if(j==vt_LDOUBLE)
{
strcat(Frmat,"%lG");
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
break;
}
// case else
{
strcat(Frmat,"%d");
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
VarCnt++;
}
break;
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"AR_fgets_retval=fgets(InputBuffer,65535,",FHandle,");");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"if(InputBuffer[strlen(InputBuffer)-1]== 10)");
fprintf(Outfile,(char*)"%s%s\n",Scoot," InputBuffer[strlen(InputBuffer)-1]=0;");
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Scoot,"ScanError = scan(InputBuffer,",enc(Frmat),Arg,");\n");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"*InputBuffer=0;");
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
if(ZZ)free(ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
void AddFuncs (void)
{
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
char *ZZ;
ZZ=(char*)calloc(256+65535,1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// ************************************");
fprintf(Outfile,(char*)"%s%s\n","// ",BCX_STR_USR_PROCS);
fprintf(Outfile,(char*)"%s\n","// ************************************");
fprintf(Outfile,(char*)"%s\n","\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
while(!EoF(FP1))
{
ZZ[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(ZZ,65535,FP1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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);
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
if(ZZ)free(ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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));
}
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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);
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fErr,(char*)"%s%s\n","WARNING ",ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n","");
fprintf(FP7,(char*)"%s\n","#ifndef LINUXBCX");
fprintf(FP7,(char*)"%s\n","#if !defined( __LCC__ )");
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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++;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n","// *************************************************");
fprintf(FP7,(char*)"%s\n","// Instruct Linker to Search Object/Import Libraries");
fprintf(FP7,(char*)"%s\n","// *************************************************");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s%s%s\n","#pragma comment(lib,",enc(ltmp),")");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
NEXTLIB:;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n","#else");
Initial Code Commit
2022-07-28 18:29:51 +00:00
strcat(RmLibs,",<libc.lib>,<kernel32.lib>,<comdlg32.lib>,<user32.lib>,<gdi32.lib>,<advapi32.lib>,<comctl32.lib>,<crtdll.lib>");
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(i=0; i<=MaxLib-1; i+=1)
{
if(Library[i][0]==0&&nCount>0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n","// *************************************************");
fprintf(FP7,(char*)"%s\n","// End of Object/Import Libraries To Search");
fprintf(FP7,(char*)"%s\n","// *************************************************");
Initial Code Commit
2022-07-28 18:29:51 +00:00
goto LIBEND;
}
else if(Library[i][0]==0)
{
goto LIBEND;
}
if(instr_b(RmLibs,Library[i]))
{
continue;
}
if(nCount==0)
{
nCount++;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n","");
fprintf(FP7,(char*)"%s\n","// *************************************************");
fprintf(FP7,(char*)"%s\n","// Instruct Linker to Search Object/Import Libraries");
fprintf(FP7,(char*)"%s\n","// *************************************************");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s%s\n","#pragma lib ",Library[i]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
LIBEND:;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP7,(char*)"%s\n","#endif");
fprintf(FP7,(char*)"%s\n","#endif // LINUXBCX not defined");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Z,65535,FP1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s\n",Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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,".")));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%s\n","Shelling Out To: ",Cmd);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%s\n","Shelling Out To: ",Compiler);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%s\n","Shelling Out To:",Linker);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%s\n","Shelling Out To: ",Cmd);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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"))
{
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP11,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Ndx==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP11,(char*)"%s\n","enum");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP11,(char*)"%s%s\n","enum ",Stk[1]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP11,(char*)"%s\n"," {");
Initial Code Commit
2022-07-28 18:29:51 +00:00
*Src=0;
while(!iMatchLft(Src,"end "))
{
if(EoF(SourceFile))
{
Abort("Unbalanced ENUM");
}
Src[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Src,65535,SourceFile);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP11,(char*)"%s\n",",");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP11,(char*)"%s%s"," ",rtrim(Src));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
*Src=0;
Ndx=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP11,(char*)"%s\n","");
fprintf(FP11,(char*)"%s\n"," };\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stk[1]),"++;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Ndx=0;
Statements++;
return;
}
if(str_cmp(Stk[2],"-")==0 && str_cmp(Stk[3],"-")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Clean(Stk[1]),"--;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Ndx=0;
Statements++;
return;
}
if(str_cmp(Stk[1],"+")==0 && str_cmp(Stk[2],"+")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"++",Clean(Stk[3]),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Ndx=0;
Statements++;
return;
}
if(str_cmp(Stk[1],"-")==0 && str_cmp(Stk[2],"-")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"--",Clean(Stk[3]),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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"))
{
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
char *ZZ;
ZZ=(char*)calloc(256+65535,1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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);
}
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
if(ZZ)free(ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"char *",SVar,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else if(IsRegister)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"register char *",SVar,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"char *",SVar,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s",Scoot,SVar,"=(char*)calloc(256+");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(A=4; A<=Ndx; A+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[A]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",1);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP4,(char*)"%s%s\n",MakeDecProto( &FP),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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"))
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",LF,Scoot,MakeDecProto( &FP),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else if(Use_Virtual)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Scoot,"virtual ",MakeDecProto( &FP),vproc,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Virtual=FALSE;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,MakeDecProto( &FP),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
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];
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
char *ZZ;
ZZ=(char*)calloc(256+65535,1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
if(ZZ)free(ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
return;
}
Statements++;
if(iMatchRgt(Stk[1],":"))
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s%s\n",ucase(Stk[1]),";");
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
if(ZZ)free(ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
return;
}
for(i=1; i<=Ndx; i+=1)
{
strcpy(Stk[i],replace(Stk[i],chr(-15),":"));
}
if((CurrentFuncType==vt_STRVAR)&&InFunc&&OkayToSend)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"char *BCX_RetStr={0};");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"end")==0)
{
if(Ndx==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"fflush(stdout);");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"exit(0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Stk[2],"=")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"fflush(stdout);");
fprintf(Outfile,(char*)"%s%s",Scoot,"exit(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(Tmp=3; Tmp<=Ndx; Tmp+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[Tmp]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(iMatchWrd(Stk[2],"if"))
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpDown();
break;
}
break;
}
if(str_cmp(Lookup,"endif")==0)
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpDown();
break;
}
if(str_cmp(Lookup,"if")==0)
{
EmitIfCond("if");
break;
}
if(str_cmp(Lookup,"elseif")==0)
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot," {int ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Reg,"single")==0 || str_cmp(Reg,"float")==0)
{
strcpy(Reg,SPC);
LoopLocalVar[LoopLocalCnt++]=1;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot," {float ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Reg,"double")==0)
{
strcpy(Reg,SPC);
LoopLocalVar[LoopLocalCnt++]=1;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot," {double ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Reg,"ldouble")==0)
{
strcpy(Reg,SPC);
LoopLocalVar[LoopLocalCnt++]=1;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot," {LDOUBLE ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",xxx,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
*Reg=0;
if(IsNumberEx(qqq))
{
if(str_cmp(left(qqq,1),"-")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%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,")");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%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,")");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%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,")");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
BumpUp();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpUp();
break;
}
if(str_cmp(Lookup,"next")==0)
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(LoopLocalVar[--LoopLocalCnt])
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(LoopLocalCnt<0)
{
Abort("Next without For");
}
BumpDown();
break;
}
if(str_cmp(Lookup,"do")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"for(;;)");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpUp();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpUp();
break;
}
if(str_cmp(Lookup,"loop")==0)
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpDown();
break;
}
if(str_cmp(Lookup,"caseelse")==0)
{
CaseElseFlag[Pusher]=TRUE;
if(CaseFlag)
{
if(NoBreak2==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"break;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"// case else");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpUp();
}
break;
}
if(str_cmp(Lookup,"endselect")==0)
{
if(CaseFlag)
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
BumpDown();
if(CaseElseFlag[Pusher]==0||NoBreak2==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"break;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
NoBreak2=CaseElseFlag[Pusher]=0;
Pop(CaseVar);
break;
}
if(str_cmp(Lookup,"else")==0)
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"else");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpUp();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"break;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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]));
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"sleep(",lszTmp,");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"Key = ",Stk[Ndx],";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(str_cmp(Var,"0")!=0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"int iDx;");
fprintf(Outfile,(char*)"%s%s%s%s",Scoot,"for(iDx=0; iDx<",lszTmp,"; iDx+=1) ");
fprintf(Outfile,(char*)"%s%s\n",Var,"[iDx]=iDx;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(!inchr(Stk[Ndx-2],"."))
{
Use_Idxqsort=TRUE;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"pppStr = ",Clean(Stk[Ndx-2]),";");
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"qsort(",Var,",",lszTmp,",sizeof(int),IdxCompare);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s%s\n",Scoot,"cmp1 =(char*)(",Stptr,") + offsetof(",StName,",",StMem,");");
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"StructSize = sizeof(",StName,");");
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"qsort(",Var,",",lszTmp,",sizeof(int),IdxCompareSt);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Use_PtrqsortSt=TRUE;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"OffSet = offsetof(",StName,",",StMem,");");
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s%s\n",Scoot,"qsort(",Stptr,",",lszTmp,",sizeof(",StName,"),PtrCompareSt);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
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]);
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s",Scoot,"qsort(",Var,",",Clean(lszTmp));
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(;;)
{
if(vt==vt_STRVAR)
{
if(!QST)
{
if(order==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",",sizeof(",Var,"[0]),StrCompareD);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Strqsortd=TRUE;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",",sizeof(",Var,"[0]),StrCompareA);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Strqsorta=TRUE;
}
}
else
{
if(order==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",",sizeof(",Var,"[0]),DynStrCompareD);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_DynStrqsortd=TRUE;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",",sizeof(",Var,"[0]),DynStrCompareA);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_DynStrqsorta=TRUE;
}
}
break;
}
if(vt==vt_INTEGER)
{
if(order==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",sizeof(int),NumCompareDint);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Numqsortdint=TRUE;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",sizeof(int),NumCompareAint);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Numqsortaint=TRUE;
}
break;
}
if(vt==vt_SINGLE)
{
if(order==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",sizeof(float),NumCompareDfloat);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Numqsortdfloat=TRUE;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",sizeof(float),NumCompareAfloat);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Numqsortafloat=TRUE;
}
break;
}
if(vt==vt_DOUBLE)
{
if(order==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",sizeof(double),NumCompareDdouble);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Numqsortddouble=TRUE;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",sizeof(double),NumCompareAdouble);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Numqsortadouble=TRUE;
}
break;
}
// case else
{
if(order==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",sizeof(int),NumCompareDint);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Numqsortdint=TRUE;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",sizeof(int),NumCompareAint);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Numqsortaint=TRUE;
}
}
break;
}
break;
}
if(str_cmp(Lookup,"endprogram")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n"," return 0; // End of main program");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",InIfDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP6,(char*)"%s\n",InIfDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","// FP3");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Outfile==FP2)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","// FP2");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",InIfDef,"// OUTFILE");
Initial Code Commit
2022-07-28 18:29:51 +00:00
strcpy(InIfDef,"FP3");
}
else if(InMain)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",InIfDef,"// --FP2--");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
break;
}
if(str_cmp(Lookup,"~else")==0)
{
strcpy(InIfDef,"#else");
strcpy(ConstLastDef,InIfDef);
if(InFunc||InMain)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",InIfDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP6,(char*)"%s\n",InIfDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",InIfDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP6,(char*)"%s\n",InIfDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
break;
}
if(str_cmp(Lookup,"~endif")==0)
{
if(str_cmp(InIfDef,"FP3")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP3,(char*)"%s\n","#endif // FP3");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#endif // Main");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(str_cmp(ConstLastDef,"FP6")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP6,(char*)"%s\n","#endif // FP6");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
strcpy(InIfDef,"#endif // other");
if(InConditional==0)
{
*InIfDef=0;
*ConstLastDef=0;
}
break;
}
if(str_cmp(Lookup,"incr")==0)
{
j=FALSE;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Scoot);
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(i=2; i<=Ndx; i+=1)
{
if(str_cmp(Stk[i],",")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","+=(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
j=TRUE;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[i]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",sziif(j,");","++;"));
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"decr")==0)
{
j=FALSE;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Scoot);
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(i=2; i<=Ndx; i+=1)
{
if(str_cmp(Stk[i],",")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","-=(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
j=TRUE;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[i]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",sziif(j,");","--;"));
Initial Code Commit
2022-07-28 18:29:51 +00:00
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);
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"fseek(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(Tmp=2; Tmp<=Ndx; Tmp+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[Tmp]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"select")==0)
{
*CaseVar=0;
CaseFlag=0;
for(A=3; A<=Ndx; A+=1)
{
strcat(CaseVar,Stk[A]);
}
Push(CaseVar);
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"for(;;)");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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);
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"GET(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(Tmp=2; Tmp<=Ndx; Tmp+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[Tmp]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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);
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"PUT(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(Tmp=2; Tmp<=Ndx; Tmp+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[Tmp]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"gosub")==0)
{
Use_Gosub=TRUE;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"if (setjmp(GosubStack[GosubNdx++])==0)");
fprintf(Outfile,(char*)"%s%s%s\n"," goto ",ucase(Stk[2]),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"return")==0)
{
Use_Gosub=TRUE;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"longjmp (GosubStack [--GosubNdx],1 );");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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]));
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP5,(char*)"%s",Stk[A]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP5,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"namespace")==0)
{
UseCpp=TRUE;
strcpy(szTmp,mid(Src,inchr(Src," ")+1));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n","namespace ",ltrim(szTmp));
fprintf(Outfile,(char*)"%s\n","{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
InNameSpace++;
BumpUp();
break;
}
if(str_cmp(Lookup,"endnamespace")==0)
{
InNameSpace--;
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s%s%s%s\n","class ",TypeName[InTypeDef],Stk[3]," {");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpUp();
}
break;
}
if(str_cmp(Lookup,"endclass")==0)
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n","};",LF);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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");
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","typedef ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
j=i-1;
i++;
while(i<=Ndx)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Stk[i]," ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
i++;
}
for(i=2; i<=j; i+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Stk[i]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Outfile=SaveOutfileNum;
}
else
{
InTypeDef++;
strcpy(TypeName[InTypeDef],Stk[2]);
AddTypeDefs(TypeName[InTypeDef],vt_STRUCT);
BaseTypeDefsCnt[InTypeDef]=TypeDefsCnt;
if(InTypeDef==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s%s\n","typedef struct _",TypeName[InTypeDef]);
fprintf(Outfile,(char*)"%s\n","{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpUp();
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"struct");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
AddTypedefElement(BaseTypeDefsCnt[InTypeDef-1],vt_STRUCT,TypeName[InTypeDef],TypeName[InTypeDef],0);
BumpUp();
}
}
break;
}
if(str_cmp(Lookup,"endtype")==0)
{
if(InTypeDef==1)
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n","}",TypeName[InTypeDef],", *","LP",ucase(TypeName[InTypeDef]),";");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Outfile=SaveOutfileNum;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP6,(char*)"%s%s%s%s%s%s\n",Scoot,"#define ",ucase(TypeName[InTypeDef]),"_CLASS struct _",ucase(TypeName[InTypeDef]),"*");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"} ",TypeName[InTypeDef],";");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","typedef union ");
fprintf(Outfile,(char*)"%s\n","{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpUp();
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"union");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
AddTypedefElement(BaseTypeDefsCnt[InTypeDef-1],vt_UNION,TypeName[InTypeDef],TypeName[InTypeDef],0);
BumpUp();
}
break;
}
if(str_cmp(Lookup,"endunion")==0)
{
if(InTypeDef==1)
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n","} ",TypeName[InTypeDef],", *","LP",ucase(TypeName[InTypeDef]),";");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Outfile=SaveOutfileNum;
}
else
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"} ",TypeName[InTypeDef],";");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"Clear ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(str_cmp(Stk[2],"(")!=0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
for(i=2; i<=Ndx; i+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[i]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(str_cmp(Stk[2],"(")!=0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",")");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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));
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{int BCX_REPEAT;");
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"for(BCX_REPEAT=",lszTmp,";BCX_REPEAT>=1;BCX_REPEAT--)");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{int BCX_REPEAT;");
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"for(BCX_REPEAT=1;BCX_REPEAT<=",lszTmp,";BCX_REPEAT++)");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
BumpUp();
break;
}
if(str_cmp(Lookup,"endrepeat")==0)
{
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",Buffer);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
if(str_cmp(ConstLastDef,"FP6")!=0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP6,(char*)"%s%s\n",InIfDef,"// FP6");
Initial Code Commit
2022-07-28 18:29:51 +00:00
strcpy(ConstLastDef,"FP6");
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP6,(char*)"%s\n",Buffer);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP6,(char*)"%s\n",Buffer);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
break;
}
if(str_cmp(Lookup,"kill")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"remove (");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(A=2; A<=Ndx; A+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(trim(Stk[A])));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s",Scoot,Lookup," (");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(A=2; A<=Ndx; A+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(trim(Stk[A])));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s",Scoot,"if (",CVar);
fprintf(Outfile,(char*)"%s%s%s%d%s",") { DestroyArr((void **)",CVar,",",(int)dms,", 1); ");
fprintf(Outfile,(char*)"%s%s\n",CVar,"=NULL; }");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
}
if(VI->VarPntr>1)
{
Use_DynamicA=TRUE;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s",Scoot,"if (",CVar);
fprintf(Outfile,(char*)"%s%s%s%s%s",") { DestroyArr((void **)",CVar,",",str(VI->VarPntr),", 1); ");
fprintf(Outfile,(char*)"%s%s\n",CVar,"=NULL; }");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"free(",CVar,"), ",CVar,"=NULL;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
break;
}
if(str_cmp(Lookup,"midstr")==0)
{
*Src=0;
for(A=1; A<=Ndx; A+=1)
{
strcat(Src,Clean(Stk[A]));
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,trim(Src),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"swap")==0)
{
VarInfo* VI1;
VarInfo* VI2;
int indx;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"swap ((BYTE*)&");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(i=2; i<=Ndx; i+=1)
{
if(str_cmp(Stk[i],",")==0)
{
break;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[i]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","[0]");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",",(BYTE*)&");
Initial Code Commit
2022-07-28 18:29:51 +00:00
i++;
for(j=i; j<=Ndx; j+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[j]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","[0]");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(VI1->VarType!=VI2->VarType)
{
Warning("Possible size error in swap statement");
}
if(VI2->VarType==vt_STRVAR||VI2->VarType==vt_CHAR)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",",strlen(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",",sizeof(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
for(j=i; j<=Ndx; j+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[j]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","));");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"rename")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"rename (");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(A=2; A<=Ndx; A+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(trim(Stk[A])));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"copyfile")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"CopyFile ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(str_cmp(Stk[2],"(")!=0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
for(A=2; A<=Ndx; A+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(trim(Stk[A])));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(str_cmp(Stk[Ndx],")")!=0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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);
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"Shell(",Clean(ZZ),");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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]));
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"printf(",enc("%s"),",",Stk[2],");");
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"AR_fgets_retval=fgets(",Clean(Stk[3]),",65535,stdin);");
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Scoot,Clean(Stk[3]),"[strlen(",Clean(Stk[3]),")-1]=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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);
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,Var,"[0]=0;");
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"AR_fgets_retval=fgets(",Var,",65535,",Clean(Stk[2]),");");
fprintf(Outfile,(char*)"%s%s%s%s%s%s",Scoot,"if(",CVar,"[strlen(",CVar,")-1]==10)");
fprintf(Outfile,(char*)"%s%s%s%s\n",CVar,"[strlen(",CVar,")-1]=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Var1[0]!=0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Var1,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Scoot,Var," = sizeof(",Stk[A+1],");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Scoot,Var," = ",Clean(Stk[A+1]),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
*Stk[A]=0;
*Stk[A+1]=0;
}
break;
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s%s\n",Scoot,"if((",Clean(Handl),"=fopen(",Filnam,",",Op,"))==0)");
fprintf(Outfile,(char*)"%s%s\n",Scoot," {");
Initial Code Commit
2022-07-28 18:29:51 +00:00
strcpy(lszTmp,enc("Can't open file %s\\n"));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot," fprintf(stderr,",lszTmp,",",Filnam,");");
fprintf(Outfile,(char*)"%s%s\n",Scoot," exit(1);");
fprintf(Outfile,(char*)"%s%s\n",Scoot," }");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%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);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else if(numargs==2)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s%s\n",Scoot,"fseek(",GetArg(1, &ffp),", (",GetArg(2, &ffp)," - 1) * ",Stk[2],"len, SEEK_SET);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"fseek(",GetArg(1, &ffp),", 0, SEEK_SET);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"close")==0)
{
if(Ndx==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"fcloseall();");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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]);
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"if(",Handl,")");
fprintf(Outfile,(char*)"%s%s\n",Scoot," {");
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot," fclose(",Handl,");");
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot," ",Handl,"=NULL;");
fprintf(Outfile,(char*)"%s%s\n",Scoot," }");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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,";");
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,lszTmp);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP4,(char*)"%s%s\n",TempProto,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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");
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int ct;
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(ct=1; ct<=Ndx; ct+=1)
{
if(str_cmp(Stk[ct],"using")==0)
{
New_Ndx=ct-1;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int ut;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",InIfDef);
printf((char*)"%s\n",InIfDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(Use_Ctor)
{
strcpy(VarCode.Header,replace(VarCode.Header,"void ",""));
strcpy(VarCode.Header,replace(VarCode.Header,"void",""));
if(strlen(CTOR_USE))
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",VarCode.Header);
fprintf(Outfile,(char*)"%s%s\n",Scoot,CTOR_USE);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",VarCode.Header);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Use_Ctor=FALSE;
}
else if(InNameSpace)
{
char szCPP_SF1[2048];
*szCPP_SF1=0;
if(iMatchLft(Lookup,"public"))
{
strcpy(szCPP_SF1,"public: virtual ");
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",Scoot,szCPP_SF1,VarCode.Header);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",VarCode.Header);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",VarCode.Header);
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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));
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",VarCode.Header);
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,DynaStr[j]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(LocalDynArrCount!=0)
{
for(i=1; i<=LocalDynArrCount; i+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,LocalDynArrName[i]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"return ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,DynaStr[j]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
LocalDynaCnt=0;
}
if(LocalDynArrCount!=0)
{
for(i=1; i<=LocalDynArrCount; i+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,LocalDynArrName[i]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
LocalDynArrCount=0;
}
}
if(ForceMainToFunc==TRUE)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"return 0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
ForceMainToFunc=FALSE;
}
BumpDown();
if(InNameSpace)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(FP2,(char*)"%s%s\n",Scoot,"}\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Scoot,"struct _",SOF," ",stringx(dms,42),CVar,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,SOF," ",stringx(dms,42),CVar,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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; }"));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,SOF," ",stringx(dms,42),CVar,"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%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,");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s%s%s%s\n",Scoot,"if (",CVar,") { DestroyArr((void **)",CVar,",",str(dms),", 1); ",CVar,"=NULL; }");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)));
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%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,");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Stk[3],"*")==0 || (IsPreserve&&str_cmp(Stk[4],"*")==0))
{
if(IsPreserve)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s",Scoot,CVar,"=(char*)realloc(",CVar,",256+");
Initial Code Commit
2022-07-28 18:29:51 +00:00
i=5;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"free(",CVar,");");
fprintf(Outfile,(char*)"%s%s%s",Scoot,CVar,"=(char*)calloc(256+");
Initial Code Commit
2022-07-28 18:29:51 +00:00
i=4;
}
for(A=i; A<=Ndx; A+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[A]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(IsPreserve)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",",1);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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"))
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n",LF,lcase(Stk[2]),":");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
}
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int act;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"register FILE* ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s",Scoot,"register ",sConst," ",Stk[Ndx]," ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
else
{
if(vt==vt_FILEPTR)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s",Scoot,"auto ",IV," FILE* ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s%s",Scoot,"auto ",IV," ",sConst," ",Stk[Ndx]," ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
}
else
{
if(IsRaw==TRUE)
{
if(vt==vt_FILEPTR)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s",Scoot,"static ",IV," FILE* ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s",Scoot,IV,sConst," ",Stk[Ndx]," ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
else
{
if(InTypeDef)
{
*UseStatic=0;
}
else
{
strcpy(UseStatic,"static ");
}
if(vt==vt_STRUCT)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s%s",Scoot,UseStatic,IV,sConst," ","struct _",Stk[Ndx]," ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
if(vt==vt_FILEPTR)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s",Scoot,UseStatic,IV,"FILE *");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s",Scoot,UseStatic,IV,sConst," ",Stk[Ndx]," ");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(InTypeDef)
{
AddTypedefElement(BaseTypeDefsCnt[InTypeDef],vt,CVar,Var,0);
}
}
}
if(InFunc&&!InTypeDef)
{
AddLocal(Var1,vt,id,DimType,IsPointer,0,0,iIsConst);
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Clean(lszTmp),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(!InTypeDef&&!IsStatic&&!IsRaw&&!IsRegister&&!IsVolatile)
{
strcpy(T,Clean(extract(lszTmp,"[")));
if(IsPointer)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",Clean(Var)," *","));");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",T,"));");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,IV,"char ",CVar,lszTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else if(IsAuto)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Scoot,"auto ",IV,"char ",CVar,lszTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else if(IsRegister)
{
if(IsVolatile)
{
Abort("register volatile not supported");
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Scoot,"register char ",CVar,lszTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
if(InTypeDef)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,IV,"char ",CVar,lszTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Scoot,"static ",IV,"char ",CVar,lszTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(j&&!IsVolatile)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",T,"));");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
break;
}
if(VType>=vt_VarMin&&VType<=vt_VarMax)
{
strcpy(ZZ,GetVarTypeName(VType));
strcpy(ZZ,rpad(ZZ,7));
if(IsRaw)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Scoot,IV,ZZ," ",CVar,lszTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else if(IsAuto)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s%s\n",Scoot,"auto ",IV,ZZ," ",CVar,lszTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else if(IsRegister)
{
if(IsVolatile)
{
Abort("Regester volatile not supported");
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Scoot,"register ",ZZ," ",CVar,lszTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
if(InTypeDef)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Scoot,IV,ZZ," ",CVar,lszTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s%s\n",Scoot,"static ",IV,ZZ," ",CVar,lszTmp,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(j&&!IsVolatile)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",T,"));");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
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);
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%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,");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,DynaStr[j]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(LocalDynArrCount!=0)
{
for(i=1; i<=LocalDynArrCount; i+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,LocalDynArrName[i]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"return;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(iMatchWrd(Stk[2],"function"))
{
if(LocalDynaCnt!=0)
{
for(j=1; j<=LocalDynaCnt; j+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,DynaStr[j]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(LocalDynArrCount!=0)
{
for(i=1; i<=LocalDynArrCount; i+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,LocalDynArrName[i]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"return 0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"break;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
break;
}
if(str_cmp(Lookup,"goto")==0)
{
if(CaseFlag)
{
NoBreak2=TRUE;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"goto ",ucase(Stk[2]),";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"print")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,PrintWriteFormat(0));
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"write")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,PrintWriteFormat(1));
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"run")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"Run (");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(A=2; A<=Ndx; A+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[A]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"color")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"color (");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(A=2; A<=Ndx; A+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[A]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"locate")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,"locate (");
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(A=2; A<=Ndx; A+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[A]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(str_cmp(Lookup,"cls")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"cls();");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",lszTmp);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,lszTmp);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(FuncRetnFlag==2)
{
FuncRetnFlag=0;
*Stk[1]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
if(ZZ)free(ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"*",Clean(Stk[1]),"=0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"BCX_RetStr=BCX_TmpStr(strlen(",Stk[3],"));");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"strcpy(",Stk[1],",",Stk[3],");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"BCX_RetStr=",Arg,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
goto STRINGEXIT;
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"BCX_RetStr=BCX_TmpStr(strlen(",Arg,"));");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"strcpy(",Var,",",Arg,");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
goto STRINGEXIT;
}
if(k==TRUE&&j==1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s\n",Scoot,"strcat(",Arg,");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
goto STRINGEXIT;
}
strcpy(lszTmp,ltrim(str(++j)));
Use_Join=TRUE;
if(str_cmp(Var,"BCX_RetStr")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Scoot,"BCX_RetStr=join(",lszTmp,",",Arg,");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s%s\n",Scoot,"strcpy(",Var,", join(",lszTmp,",",Arg,"));");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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;
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",Scoot,Clean(Stk[1]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(A=2; A<=Ndx; A+=1)
{
if(str_cmp(Stk[A],"!")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","!");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[A]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
break;
}
if(FuncRetnFlag==1)
{
if(LocalDynaCnt!=0)
{
for(j=1; j<=LocalDynaCnt; j+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,DynaStr[j]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"return BCX_RetStr;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
if(ZZ)free(ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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);
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fpErr,(char*)"%s%s%d%s%s\n",Z," at line",(int)ModuleLineNos[ModuleNdx]," in Module: ",trim(Modules[ModuleNdx]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(fpErr)
{
fclose(fpErr);
fpErr=NULL;
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
printf((char*)"%s%s%s%s%s\n","Error!",CRLF,FileIn,CRLF,WarnMsg);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","return 0; // End of main program");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpDown();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
fflush(Outfile);
}
}
void EmitProlog (void)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","int main(int argc, char *argv[])");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s%s\n","// ",BCX_STR_USR_CONST);
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
while(!EoF(FP3))
{
Z[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Z,65535,FP3);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",ltrim(Z));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(FP3)
{
fclose(FP3);
FP3=NULL;
}
if(Use_EnumFile)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","// User's GLOBAL ENUM blocks");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if((FP8=fopen(enuFile,"r"))==0)
{
fprintf(stderr,"Can't open file %s\n",enuFile);
exit(1);
}
while(!EoF(FP8))
{
Z[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Z,65535,FP8);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(FP8)
{
fclose(FP8);
FP8=NULL;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if((FP3=fopen(udtFile,"r"))==0)
{
fprintf(stderr,"Can't open file %s\n",udtFile);
exit(1);
}
if(lof(udtFile)>0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s%s\n","// ",BCX_STR_USR_TYPES);
fprintf(Outfile,(char*)"%s\n","// *************************************************");
Initial Code Commit
2022-07-28 18:29:51 +00:00
while(!EoF(FP3))
{
Z[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Z,65535,FP3);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(FP3)
{
fclose(FP3);
FP3=NULL;
}
if(HFileCnt>0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","// User Include Files");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
A=0;
while(A<HFileCnt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",HFiles[A]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
A++;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#include <term.h>");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_SingleFile==TRUE)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s%s\n","// ",BCX_STR_SYS_VARS);
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Use_RegEx)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","typedef struct _REGEX");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int count;");
fprintf(Outfile,(char*)"%s\n"," regmatch_t matches[1024];");
fprintf(Outfile,(char*)"%s\n"," PCHAR results[1024];");
fprintf(Outfile,(char*)"%s\n","}REGEX, *LPREGEX;\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Time)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","enum TIME_OPTIONS");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," TIME,");
fprintf(Outfile,(char*)"%s\n"," HOUR,");
fprintf(Outfile,(char*)"%s\n"," MINUTE,");
fprintf(Outfile,(char*)"%s\n"," SECOND,");
fprintf(Outfile,(char*)"%s\n"," APM,");
fprintf(Outfile,(char*)"%s\n"," YEAR,");
fprintf(Outfile,(char*)"%s\n"," MONTH,");
fprintf(Outfile,(char*)"%s\n"," DAY,");
fprintf(Outfile,(char*)"%s\n"," DAYNAME,");
fprintf(Outfile,(char*)"%s\n"," WEEKDAY,");
fprintf(Outfile,(char*)"%s\n"," YEARDAY,");
fprintf(Outfile,(char*)"%s\n"," WEEKNUMBER,");
fprintf(Outfile,(char*)"%s\n"," DATE,");
fprintf(Outfile,(char*)"%s\n"," FULLDATE");
fprintf(Outfile,(char*)"%s\n"," };\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Findfirst||Use_Findnext)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","typedef struct _FILE_FIND_DATA");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," DWORD dwFileAttributes;");
fprintf(Outfile,(char*)"%s\n"," DWORD ftCreationTime;");
fprintf(Outfile,(char*)"%s\n"," DWORD ftLastAccessTime;");
fprintf(Outfile,(char*)"%s\n"," DWORD ftLastWriteTime;");
fprintf(Outfile,(char*)"%s\n"," DWORD nFileSizeHigh;");
fprintf(Outfile,(char*)"%s\n"," DWORD nFileSizeLow;");
fprintf(Outfile,(char*)"%s\n"," char cFileSpec[MAX_PATH];");
fprintf(Outfile,(char*)"%s\n"," char cFileName[MAX_PATH];");
fprintf(Outfile,(char*)"%s\n"," char path[MAX_PATH];");
fprintf(Outfile,(char*)"%s\n"," DIR *FileHandle;");
fprintf(Outfile,(char*)"%s\n","}FILE_FIND_DATA, *LPFILE_FIND_DATA;\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Ldouble)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define LDOUBLE long double");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Idxqsort)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char*** pppStr;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Idxqsort||Use_IdxqsortSt||Use_PtrqsortSt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Key;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_IdxqsortSt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* cmp1;");
fprintf(Outfile,(char*)"%s\n","int StructSize;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_PtrqsortSt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int OffSet;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_NUL)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char NUL [1]={0}; // Null");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_BEL)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char BEL [2]={7,0}; // Bell");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_BS)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char BS [2]={8,0}; // Back Space");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_TAB)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char TAB [2]={9,0}; // Horz Tab");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_LF)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char LF [2]={10,0}; // Line Feed");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_VT)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char VT [2]={11,0}; // Vert Tab");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_FF)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char FF [2]={12,0}; // Form Feed");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_CR)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char CR [2]={13,0}; // Carr Rtn");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_EOF)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char EF [2]={26,0}; // End-of-File");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_ESC)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char ESC [2]={27,0}; // Escape");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_SPC)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char SPC [2]={32,0}; // Space");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_DQ)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char DQ [2]={34,0}; // Double-Quote");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_DDQ)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char DDQ [3]={34,34,0}; // Double-Double-Quote");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Crlf)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char CRLF[3]={13,10,0}; // Carr Rtn & Line Feed");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Console)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int color_fg = 7;");
fprintf(Outfile,(char*)"%s\n","int color_bg = 0;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Lineinput)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *AR_fgets_retval;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Scan)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int ScanError;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Inputbuffer==TRUE)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char InputBuffer[65535];");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Findfirst||Use_Findnext)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","FILE_FIND_DATA FindData;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Gosub)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","jmp_buf GosubStack[32];");
fprintf(Outfile,(char*)"%s\n","int GosubNdx;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Dynacall)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","HINSTANCE BCX_DllStore[256];");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(GlobalVarCnt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s%s\n","// ",BCX_STR_USR_VARS);
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",LastDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(str_cmp(LastDef,GlobalVars[i].VarCondDef)!=0)
{
if(str_cmp(GlobalVars[i].VarCondDef,"#else")==0)
{
while(LastLevel>GlobalVars[i].VarCondLevel)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
LastLevel--;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#else");
Initial Code Commit
2022-07-28 18:29:51 +00:00
strcpy(LastDef,GlobalVars[i].VarCondDef);
}
else
{
while(LastLevel>=GlobalVars[i].VarCondLevel)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
LastLevel--;
}
strcpy(LastDef,GlobalVars[i].VarCondDef);
LastLevel=GlobalVars[i].VarCondLevel;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",LastDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
*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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
LastLevel--;
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(DllCnt)
{
int i;
char AR_DllName[2048];
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// **********[ DLL Declarations ]**********");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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],"."));
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s\n","void *H_",ucase(AR_DllName)," = dlopen(",enc(Loadlibs[i]),", RTLD_LAZY);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
for(i=1; i<=DllCnt; i+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",DllDecl[i]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// ****************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if((FP5=fopen(datFile,"r"))==0)
{
fprintf(stderr,"Can't open file %s\n",datFile);
exit(1);
}
if(lof(datFile)>0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","// User Data Statements");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","char * DATA [] =");
fprintf(Outfile,(char*)"%s\n","{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
while(!EoF(FP5))
{
Z[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Z,65535,FP5);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","};");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(FP5)
{
fclose(FP5);
FP5=NULL;
}
while(!EoF(FP1))
{
Z[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Z,65535,FP1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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];
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
char *ZZ;
ZZ=(char*)calloc(256+65535,1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(ZZ,65535,FP1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
if(instr_b(ZZ,"int main"))
{
strcpy(SaveMain,ZZ);
break;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s%s\n","// ",BCX_STR_STD_MACROS);
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Use_BcxSplitPath)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define FDRV 2");
fprintf(Outfile,(char*)"%s\n","#define FPATH 4");
fprintf(Outfile,(char*)"%s\n","#define FNAME 8");
fprintf(Outfile,(char*)"%s\n","#define FEXT 16");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cbool)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define CBOOL(A)(A!=0)?1:0");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Isptr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define IsPtr(a)((DWORD)a)");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Band)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define BAND &");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Bor)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define BOR |");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Bnot)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define BNOT ~(int)");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Ubound)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define ubound(T)(sizeof((T))/sizeof((T[0]))-1)");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Clear)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define Clear(arg)memset(&arg,0,sizeof(arg))");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Imod)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define imod(a,b)((a)%(b))");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Get)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define GET(A,B,C) F_GetVal=fread(B,1,C,A)");
Initial Code Commit
2022-07-28 18:29:51 +00:00
AddGlobal("F_GetVal",vt_INTEGER,0,"",0,0,0,0);
}
if(Use_Put)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define PUT(A,B,C) F_PutVal=fwrite(B,1,C,A)");
Initial Code Commit
2022-07-28 18:29:51 +00:00
AddGlobal("F_PutVal",vt_INTEGER,0,"",0,0,0,0);
}
if(Use_Strptr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define STRPTR(A)((char*)&(A))");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Val)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define VAL(a)(double)atof(a)");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Vall)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define VALL(a) (long double)strtold(a,(char**)NULL)");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Fint)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define FINT(a)floor(a)");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Frac)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define FRAC(a)(double)(a-FIX(a))");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Fix=TRUE;
}
if(Use_Fracl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define FRACL(a)(long double)(a-FIX(a))");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Use_Fix=TRUE;
}
if(Use_Fix)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define FIX(a)(int)((a))");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Csng)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define CSNG(a)((float)(a))");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cdbl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define CDBL(a)((double)(a))");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cldbl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define CLDBL(a)((long double)(a))");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Threads)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#define BCX_THREAD(fn,arg) ({ pthread_t tid; pthread_create(&tid, NULL, (void*(*)(void*))fn, arg); tid;})");
fprintf(Outfile,(char*)"%s\n","#define BCX_THREADWAIT(a) pthread_join(a, NULL)");
fprintf(Outfile,(char*)"%s\n","#define BCX_INITLOCK(a) pthread_mutex_init(a, NULL)");
fprintf(Outfile,(char*)"%s\n","#define BCX_THREADLOCK(a) pthread_mutex_lock (a)");
fprintf(Outfile,(char*)"%s\n","#define BCX_THREADUNLOCK(a) pthread_mutex_unlock (a)");
fprintf(Outfile,(char*)"%s\n","#define BCX_THREADKILL(t) pthread_cancel(t)");
fprintf(Outfile,(char*)"%s\n","#define BCX_THREADEND pthread_exit(0)");
}
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s%s\n","// ",BCX_STR_STD_PROTOS);
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(NoRT==FALSE)
{
if(Use_Clng)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","long CLNG(double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cint)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Cint(double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_StartupCode)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int BCX_StartupCode_(void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_ExitCode)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int BCX_ExitCode_(void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Str_Cmp)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int str_cmp(char*, char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Eof)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int EoF (FILE*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_CopyFile)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void CopyFile (char *,char *,int=FALSE);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_QBColor)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int qbcolor (int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cls)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void cls(void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Color)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void color (int,int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Locate)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void locate (int,int,int=1,int=12);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Run)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Run (char*, int =1, int =0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Randomize)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void randomize (unsigned int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Midstr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void midstr (char*, int, int, char *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Swap)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void swap (UCHAR*,UCHAR*,int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(UseFlag)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* BCX_TmpStr(size_t);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_sziif)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* sziif (bool,char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Using)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* Using (char*,double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_TempFileName)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* TempFileName (char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_AppExePath)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* AppExePath (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_AppExeName)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* AppExeName (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Lcase)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* lcase (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Ucase)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* ucase (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mid)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* mid (char*, int, int=-1);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Ltrim)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* ltrim (char*,char=32);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Rtrim)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* rtrim (char*,char=32);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Trim)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* trim (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Strim)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* strim (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Left)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* left (char*,int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Right)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* right (char*,int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Rpad)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* rpad (char*,int,int=32);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Lpad)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* lpad (char*,int,int=32);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_String)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* stringx (int,int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Repeat)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* repeat (int,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Extract)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* extract (char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Remain)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* remain (char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Reverse)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* reverse (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Command)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* command (int=-1);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mcase)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* mcase (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Replace)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* replace (char*,char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_iReplace)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* iReplace (char*,char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Shell)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void Shell (char *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Space)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* space (int a);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Str)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* str (double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Strl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* strl (long double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Findfirst)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* findfirst (char*, FILE_FIND_DATA*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Findnext)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* findnext (FILE_FIND_DATA*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Curdir)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* curdir (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Sysdir)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* sysdir (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Tempdir)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* tempdir (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Environ)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* Environ (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Boolstr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* BoolStr (int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Hex)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* hex (int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Bin)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* Bin (int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Oct)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* oct (int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Now)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* now (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_SearchPath)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* SEARCHPATH (char *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_StrUpLow)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* _strupr_(char *);");
fprintf(Outfile,(char*)"%s\n","char* _strlwr_(char *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_BcxSplitPath)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* BcxSplitPath (char *, int);");
fprintf(Outfile,(char*)"%s\n","void _splitpath_(const char* path, char* drv, char* dir, char* name, char* ext);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Strtoken)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* StrToken (char*,char*,int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_FileLocked)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int FileLocked (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_FillArray)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int fillarray (char *, int, int, void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Remove)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* RemoveStr (char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_IRemove)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* IRemoveStr (char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Time)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* timef (int i=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Join)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* join (int, ... );");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Enclose)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* enc (char*, int=0, int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Chr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","char* chr");
fprintf(Outfile,(char*)"%s\n","(int,int=0,int=0,int=0,int=0,int=0,int=0,int=0,int=0,int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_VChr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* vchr (int,...);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Freefile)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","FILE* FreeFile (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_PeekStr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* peekstr (LPVOID,int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Asc)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int asc (char*,int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Instrrev)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int InstrRev (char*,char*,int=0,int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Instr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int instr_b(char*,char*,int=0,int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(UseLCaseTbl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *MakeLCaseTbl(void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Stristr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *_stristr_(char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_StrStr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *_strstr_(char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Verify)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Verify (char *, char *);");
fprintf(Outfile,(char*)"%s\n","int VerifyInstr(char*,char*,int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Retain)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* Retain (char*,char *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_LoadFile)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* LoadFile (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Inchr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int inchr (char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Idxqsort)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int IdxCompare (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_IdxqsortSt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int IdxCompareSt (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_PtrqsortSt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int PtrCompareSt (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Strqsorta)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int StrCompareA (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Strqsortd)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int StrCompareD (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_DynStrqsorta)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int DynStrCompareA (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_DynStrqsortd)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int DynStrCompareD (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortaint)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareAint (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortdint)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareDint (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortafloat)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareAfloat (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortdfloat)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareDfloat (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortadouble)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareAdouble (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortddouble)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareDdouble (const void *,const void *);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Like)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int like (char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Tally)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int tally (char*,char*,int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Inkey)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* inkey (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_InkeyD)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int inkeyd (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Instat)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int kbhit(void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_GetCh)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int _getch_(int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Bin2dec)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Bin2Dec (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Hex2Dec)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Hex2Dec (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Download)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Download (char*,char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Embed)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* GetResource (int* );");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Exist)
{
if(Use_Osx)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","bool Exist (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","BOOL Exist (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(Use_Ins)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* ins (char *S, int i, char *a);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Del)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* del (char*,int,int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Pause)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void Pause (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Keypress)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int keypress (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Lof)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","DWORD lof (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Sgn)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double sgn (double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Round)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double Round (double,int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Rnd)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","float rnd (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Exp)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double Exp (double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Min)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double _MIN_ (double,double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Max)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double _MAX_ (double,double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Timer)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","float timer (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Iif)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double iif (bool,double,double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Loc)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int loc (FILE *fp, int fplen);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Rec)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int rec (FILE *fp, int fplen);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_RecCount)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int reccount (FILE *fp, int fplen);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Scan)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int scan (char *input, char *format, ... );");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Split)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Split (char [][65535], char*, char*, int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_DSplit)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int DSplit (PCHAR *, char*, char*, int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_SysStr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","BSTR SysStr (char * szIn, int=0, int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_WideToAnsi)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* WideToAnsi (wchar_t *, UINT=0, DWORD=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_AnsiToWide)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","wchar_t* AnsiToWide (char*,UINT=0,DWORD=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cvi)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","short CVI (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mki)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* MKI (short);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cvl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","long CVL (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mkl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* MKL (int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cvs)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","float CVS (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mks)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* MKS (float);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cvd)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double CVD (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cvld)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","long double CVLD (char*);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mkd)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* MKD (double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mkld)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* MKLD (long double);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_OSVersion)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int OSVersion (void);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Dynacall)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","HINSTANCE BCX_LoadDll(char *);");
fprintf(Outfile,(char*)"%s\n","void BCX_UnloadDll(void);");
fprintf(Outfile,(char*)"%s\n","typedef int (CALLBACK *DYNACALL1)(void);");
fprintf(Outfile,(char*)"%s\n","int BCX_DynaCall(char *, char *, int, ...);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_DynamicA)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void* CreateArr (void*,int,int,int,...);");
fprintf(Outfile,(char*)"%s\n","void* CreateArr_internal(void*, int, int, int, va_list);");
fprintf(Outfile,(char*)"%s\n","void DestroyArr (void**,int,int);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_ContainedIn)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int containedin(char * ,char **,int=0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_FindInType)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int FindInType(char *,char *,int,int,int,int=0,int* =0);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s%s%s\n","class ",BcxSplitPath(FileIn,FNAME),": public wxApp {");
fprintf(Outfile,(char*)"%s\n"," public:");
fprintf(Outfile,(char*)"%s\n"," virtual bool OnInit();");
fprintf(Outfile,(char*)"%s\n","};");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s%s%s\n","IMPLEMENT_APP(",BcxSplitPath(FileIn,FNAME),")");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Socket)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","sockaddr_in sock_addr (char* ,int=80);");
fprintf(Outfile,(char*)"%s\n","int connect_socket (sockaddr_in);");
fprintf(Outfile,(char*)"%s\n","int BcxSocket (char* ,int=80);");
fprintf(Outfile,(char*)"%s\n","int BcxSocketSend (int, char *);");
fprintf(Outfile,(char*)"%s\n","int BcxSocketRead (int, char *);");
fprintf(Outfile,(char*)"%s\n","void BcxSocketClose(int);");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_RegEx)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","bool regmatch (char *, char *, REGEX* );");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(ProtoCnt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s%s\n","// ",BCX_STR_USR_PROTOS);
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fpHFile,(char*)"%s\n",LastDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(LastDef[0]>0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",LastDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fpHFile,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
LastLevel--;
}
if(Use_SingleFile==FALSE)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fpHFile,(char*)"%s\n","#else");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#else");
Initial Code Commit
2022-07-28 18:29:51 +00:00
strcpy(LastDef,ProtoType[A].Condition);
LastLevel=ProtoType[A].CondLevel;
}
else
{
while(LastLevel>ProtoType[A].CondLevel)
{
if(Use_SingleFile==FALSE)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fpHFile,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
LastLevel--;
}
strcpy(LastDef,ProtoType[A].Condition);
LastLevel=ProtoType[A].CondLevel;
if(Use_SingleFile==FALSE)
{
if(LastDef[0]>0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fpHFile,(char*)"%s\n",LastDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(LastDef[0]>0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",LastDef);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fpHFile,(char*)"%s\n",ProtoType[A].Prototype);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(UseCpp==FALSE&&!instr_b(ProtoType[A].Prototype,"::"))
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",ProtoType[A].Prototype);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(*LastDef)
{
while(LastLevel>0)
{
if(Use_SingleFile==FALSE)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fpHFile,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","#endif");
Initial Code Commit
2022-07-28 18:29:51 +00:00
LastLevel--;
}
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
char P[2048];
int i;
char VarName[2048];
char VarDim[2048];
char Storage[2048];
char VAR[2048];
if(GlobalVarCnt>0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","// User Global Initialized Arrays");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Storage,"char ",VarName,VarDim,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(A==vt_FILEPTR)
{
strcpy(GlobalVars[i].VarName,RemoveStr(GlobalVars[i].VarName,"@"));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Storage,"FILE *",VarName,VarDim,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(A==vt_BOOL)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Storage,"bool ",VarName,VarDim,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(A==vt_UDT||A==vt_STRUCT||A==vt_UNION)
{
strcpy(VAR,TypeDefs[GlobalVars[i].VarDef].VarName);
strcpy(VAR,rpad(VAR,7));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(A>=vt_VarMin&&A<=vt_VarMax)
{
strcpy(VAR,GetVarTypeName(GlobalVars[i].VarType));
strcpy(VAR,rpad(VAR,7));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
break;
}
}
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Overloaded)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","// User's Overloaded Subs/Functions ");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if((FP8=fopen(ovrFile,"r"))==0)
{
fprintf(stderr,"Can't open file %s\n",ovrFile);
exit(1);
}
while(!EoF(FP8))
{
ZZ[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(ZZ,65535,FP8);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
if(instr_b(ZZ,"overloaded"))
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(FP8)
{
fclose(FP8);
FP8=NULL;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if((FP5=fopen(setFile,"r"))==0)
{
fprintf(stderr,"Can't open file %s\n",setFile);
exit(1);
}
if(lof(setFile)>0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","// User GLOBAL SET Statements");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
while(!EoF(FP5))
{
Z[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(Z,65535,FP5);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",Z);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(FP5)
{
fclose(FP5);
FP5=NULL;
}
if(Use_SingleFile==FALSE)
{
if(fpHFile)
{
fclose(fpHFile);
fpHFile=NULL;
}
}
if(NoMain==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s%s\n","// ",BCX_STR_MAIN_PROG);
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(NoMain==FALSE)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n",SaveMain);
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," G_argc = argc;");
fprintf(Outfile,(char*)"%s\n"," G_argv = argv;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpUp();
}
while(!EoF(FP1))
{
ZZ[0]=0;
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
AR_fgets_retval=fgets(ZZ,65535,FP1);
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_SingleFile==TRUE)
{
RunTimeFunctions();
}
fflush(Outfile);
CloseAll();
remove (FileOut);
rename ("$t$e$m$p",FileOut);
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
if(ZZ)free(ZZ);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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"));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s%s\n","// ",BCX_STR_RUNTIME);
fprintf(Outfile,(char*)"%s\n","// *************************************************");
fprintf(Outfile,(char*)"%s\n","");
Initial Code Commit
2022-07-28 18:29:51 +00:00
if(NoRT==TRUE)
{
return;
}
if(UseFlag)
{
if(Use_Turbo)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *BCX_TmpStr (size_t Bites)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static int StrCnt;");
fprintf(Outfile,(char*)"%s%d%s\n"," static char *StrFunc[",(int)TurboSize,"];");
fprintf(Outfile,(char*)"%s%d%s\n"," StrCnt=((StrCnt+1) &",(int)TurboSize-1,");");
fprintf(Outfile,(char*)"%s\n"," #if defined BCX_MAX_VAR_SIZE");
fprintf(Outfile,(char*)"%s\n"," if(Bites*sizeof(char)>BCX_MAX_VAR_SIZE)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%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,(char*)"%s\n"," abort();");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," #endif");
fprintf(Outfile,(char*)"%s\n"," StrFunc[StrCnt]=(char*)realloc(StrFunc[StrCnt],Bites + 128);");
fprintf(Outfile,(char*)"%s\n"," return (char*)memset(StrFunc[StrCnt],0,Bites+128);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *BCX_TmpStr (size_t Bites)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static int StrCnt;");
fprintf(Outfile,(char*)"%s\n"," static char *StrFunc[65535];");
fprintf(Outfile,(char*)"%s\n"," StrCnt=(StrCnt + 1) & 65535;");
fprintf(Outfile,(char*)"%s\n"," if(StrFunc[StrCnt]) free (StrFunc[StrCnt]);");
fprintf(Outfile,(char*)"%s\n"," #if defined BCX_MAX_VAR_SIZE");
fprintf(Outfile,(char*)"%s\n"," if(Bites*sizeof(char)>BCX_MAX_VAR_SIZE)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%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,(char*)"%s\n"," abort();");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," #endif");
fprintf(Outfile,(char*)"%s\n"," return StrFunc[StrCnt]=(char*)calloc(Bites+128,sizeof(char));");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
if(Use_CopyFile)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void CopyFile (char *InFile,char *TmpFile,int OverWrite)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," #define BLOCKCOPYSIZE (10 * 1000*1024)");
fprintf(Outfile,(char*)"%s\n"," char* tmp=0;");
fprintf(Outfile,(char*)"%s\n"," UINT blocks=1;");
fprintf(Outfile,(char*)"%s\n"," UINT overage=0;");
fprintf(Outfile,(char*)"%s\n"," UINT i;");
fprintf(Outfile,(char*)"%s\n"," FILE *FP1,*FP2;");
fprintf(Outfile,(char*)"%s\n"," if(!OverWrite)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(Exist(TmpFile)) return;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(Exist(InFile))");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," UINT length = lof(InFile);");
fprintf(Outfile,(char*)"%s\n"," if(length > BLOCKCOPYSIZE)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," blocks = length/BLOCKCOPYSIZE;");
fprintf(Outfile,(char*)"%s\n"," overage= length % BLOCKCOPYSIZE;");
fprintf(Outfile,(char*)"%s\n"," length = BLOCKCOPYSIZE;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," tmp=(char*)calloc(16+length,1);");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s%s%s\n"," if((FP1=fopen(InFile,",enc("rb"),"))==0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s%s%s\n"," fprintf(stderr,",enc("Can't open file %s\\n"),",InFile);");
fprintf(Outfile,(char*)"%s\n"," exit(1);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s%s%s\n"," if((FP2=fopen(TmpFile,",enc("wb+"),"))==0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s%s%s\n"," fprintf(stderr,",enc("Can't open file %s\\n"),",TmpFile);");
fprintf(Outfile,(char*)"%s\n"," exit(1);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," for(i=0; i<blocks; i+=1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," fread(tmp,1,length,FP1);");
fprintf(Outfile,(char*)"%s\n"," fwrite(tmp,1,length,FP2);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(overage>0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," fread(tmp,1,overage,FP1);");
fprintf(Outfile,(char*)"%s\n"," fwrite(tmp,1,overage,FP2);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," fclose(FP2); fclose(FP1);");
fprintf(Outfile,(char*)"%s\n"," if(tmp) free(tmp);");
fprintf(Outfile,(char*)"%s\n"," struct stat st;");
fprintf(Outfile,(char*)"%s\n"," if(stat(InFile, &st) != -1)");
fprintf(Outfile,(char*)"%s\n"," chmod(TmpFile,st.st_mode);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Str_Cmp)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int str_cmp (char *a, char *b)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int counter=0;");
fprintf(Outfile,(char*)"%s\n"," for(;;)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if((a[counter]^b[counter]))");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if((UINT) a[counter]>= (UINT) b[counter])");
fprintf(Outfile,(char*)"%s\n"," return 1;");
fprintf(Outfile,(char*)"%s\n"," return -1;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(!a[counter]) return 0;");
fprintf(Outfile,(char*)"%s\n"," counter++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Eof)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int EoF (FILE* stream)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int c, status = ((c = fgetc(stream)) == EOF);");
fprintf(Outfile,(char*)"%s\n"," ungetc(c,stream);");
fprintf(Outfile,(char*)"%s\n"," return status;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cint)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Cint (double A)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return (A >=0 ? (int)(A+0.5) : (int)(A-0.5));");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Clng)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","long CLNG (double A)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," float r=.5;");
fprintf(Outfile,(char*)"%s\n"," double a=A-(long)A;");
fprintf(Outfile,(char*)"%s\n"," if(A<0) { r=-.5; a=-a; }");
fprintf(Outfile,(char*)"%s\n"," if(((long)A % 2)==0&&a<=.5)");
fprintf(Outfile,(char*)"%s\n"," return (long)A;");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," return (long)(A+r);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Left)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *left (char *S, int length)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int tmplen = strlen(S);");
fprintf(Outfile,(char*)"%s\n"," if(length<1) return BCX_TmpStr(1);");
fprintf(Outfile,(char*)"%s\n"," if(length<tmplen) tmplen=length;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(tmplen);");
fprintf(Outfile,(char*)"%s\n"," return (char*)memcpy(strtmp,S,tmplen);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Right)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *right (char *S, int length)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int tmplen = strlen(S);");
fprintf(Outfile,(char*)"%s\n"," char *BCX_RetStr = BCX_TmpStr(tmplen);");
fprintf(Outfile,(char*)"%s\n"," tmplen -= length;");
fprintf(Outfile,(char*)"%s\n"," if (tmplen<0) tmplen = 0;");
fprintf(Outfile,(char*)"%s\n"," return strcpy(BCX_RetStr, &S[tmplen]);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Rpad)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *rpad (char *a, int L, int c)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp;");
fprintf(Outfile,(char*)"%s\n"," int s = strlen(a);");
fprintf(Outfile,(char*)"%s\n"," if((L-s)<1) return a;");
fprintf(Outfile,(char*)"%s\n"," strtmp=BCX_TmpStr(L);");
fprintf(Outfile,(char*)"%s\n"," strcpy(strtmp,a);");
fprintf(Outfile,(char*)"%s\n"," memset(&strtmp[s],c,(L-s));");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Lpad)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *lpad (char *a, int L, int c)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp;");
fprintf(Outfile,(char*)"%s\n"," L=L-strlen(a);");
fprintf(Outfile,(char*)"%s\n"," if(L<1) return a;");
fprintf(Outfile,(char*)"%s\n"," strtmp = BCX_TmpStr(L);");
fprintf(Outfile,(char*)"%s\n"," memset(strtmp,c,L);");
fprintf(Outfile,(char*)"%s\n"," return strcat(strtmp,a);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mid)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *mid (char *S, int start, int length)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp;");
fprintf(Outfile,(char*)"%s\n"," int tmplen = strlen(S);");
fprintf(Outfile,(char*)"%s\n"," if(start>tmplen||start<1) return BCX_TmpStr(1);");
fprintf(Outfile,(char*)"%s\n"," if (length<0 || length>(tmplen-start)+1)");
fprintf(Outfile,(char*)"%s\n"," length = (tmplen-start)+1;");
fprintf(Outfile,(char*)"%s\n"," strtmp = BCX_TmpStr(length);");
fprintf(Outfile,(char*)"%s\n"," return (char*)memcpy(strtmp,&S[start-1],length);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Trim)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *trim (char *S)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," while(*S==32 || *S==9 || *S==10 || *S==11 || *S==13)");
fprintf(Outfile,(char*)"%s\n"," S++;");
fprintf(Outfile,(char*)"%s\n"," int i = strlen(S);");
fprintf(Outfile,(char*)"%s\n"," while( i>0 && (S[i-1]==32 || S[i-1]==9 || S[i-1]==10");
fprintf(Outfile,(char*)"%s\n"," || S[i-1]==11 || S[i-1]==13))");
fprintf(Outfile,(char*)"%s\n"," i--;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp=BCX_TmpStr(i);");
fprintf(Outfile,(char*)"%s\n"," return (char*)memcpy(strtmp,S,i);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Ltrim)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *ltrim (char *S, char c)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(S[0]==0) return S;");
fprintf(Outfile,(char*)"%s\n"," while((*S==32 || *S==c) && *S !=0) S++;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(strlen(S));");
fprintf(Outfile,(char*)"%s\n"," return strcpy(strtmp,S);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Rtrim)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *rtrim (char *S,char c)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(S[0]==0) return S;");
fprintf(Outfile,(char*)"%s\n"," int i = strlen(S);");
fprintf(Outfile,(char*)"%s\n"," while(i>0 && (S[i-1]==c || S[i-1]==32))");
fprintf(Outfile,(char*)"%s\n"," i--;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(i);");
fprintf(Outfile,(char*)"%s\n"," return (char*)memcpy(strtmp,S,i);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Strim)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *strim (char *src)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(strlen(src));");
fprintf(Outfile,(char*)"%s\n"," char *dst = strtmp;");
fprintf(Outfile,(char*)"%s\n"," while (isspace((unsigned char)*src)) src++;");
fprintf(Outfile,(char*)"%s\n"," do");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," while (*src && !isspace((unsigned char)*src)) *dst++ = *src++;");
fprintf(Outfile,(char*)"%s\n"," if (*src)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," *dst++ = *src++;");
fprintf(Outfile,(char*)"%s\n"," while (isspace((unsigned char)*src)) src++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," } while (*src);");
fprintf(Outfile,(char*)"%s\n"," if (isspace((unsigned char)*(--dst))) *dst = 0;");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Command)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *command (int nArg)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," int i = 0;");
fprintf(Outfile,(char*)"%s\n"," char *retstr=BCX_TmpStr(1);");
fprintf(Outfile,(char*)"%s\n"," if(nArg < i) // return entire commandline");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," retstr = BCX_TmpStr(G_argc * 2048);");
fprintf(Outfile,(char*)"%s\n"," for(i=1; i < G_argc; i++)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," strcat(retstr, G_argv[i]);");
fprintf(Outfile,(char*)"%s\n"," strcat(retstr, SPC);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," else if(nArg < G_argc)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," retstr = BCX_TmpStr(strlen(G_argv[nArg]) + 1);");
fprintf(Outfile,(char*)"%s\n"," strcpy(retstr, G_argv[nArg]);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return retstr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Extract)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *extract (char *mane, char *match)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *a;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(strlen(mane));");
fprintf(Outfile,(char*)"%s\n"," if(*match!=0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," a=_strstr_(mane,match);");
fprintf(Outfile,(char*)"%s\n"," if(a) return (char*)memcpy(strtmp,mane,a-mane);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return strcpy(strtmp,mane);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Remain)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *remain (char *mane, char *mat)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *p = strstr(mane,mat);");
fprintf(Outfile,(char*)"%s\n"," if(p)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," p+=(strlen(mat));");
fprintf(Outfile,(char*)"%s\n"," return p;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return mane;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Replace)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *replace (char *src, char *pat, char *rep)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," size_t patsz, repsz, tmpsz, delta;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp, *p, *q, *r;");
fprintf(Outfile,(char*)"%s\n"," if (!pat || !*pat)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," strtmp = BCX_TmpStr(strlen(src));");
fprintf(Outfile,(char*)"%s\n"," if (!strtmp) return NULL;");
fprintf(Outfile,(char*)"%s\n"," return strcpy(strtmp, src);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," repsz = strlen(rep);");
fprintf(Outfile,(char*)"%s\n"," patsz = strlen(pat);");
fprintf(Outfile,(char*)"%s\n"," for (tmpsz=0, p=src; (q=_strstr_(p,pat))!=0; p=q+patsz)");
fprintf(Outfile,(char*)"%s\n"," tmpsz += (size_t) (q - p) + repsz;");
fprintf(Outfile,(char*)"%s\n"," tmpsz += strlen(p);");
fprintf(Outfile,(char*)"%s\n"," strtmp = BCX_TmpStr(tmpsz);");
fprintf(Outfile,(char*)"%s\n"," if (!strtmp) return NULL;");
fprintf(Outfile,(char*)"%s\n"," for (r=strtmp,p=src; (q=_strstr_(p,pat))!=0;p=q+patsz)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," delta = (size_t) (q-p);");
fprintf(Outfile,(char*)"%s\n"," memcpy(r,p,delta); r += delta;");
fprintf(Outfile,(char*)"%s\n"," strcpy(r,rep); r += repsz;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," strcpy(r,p);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Reverse)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *reverse (char *s)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int j=strlen(s);");
fprintf(Outfile,(char*)"%s\n"," char *rstr = BCX_TmpStr(j);");
fprintf(Outfile,(char*)"%s\n"," while(j) rstr[--j] = *(s++);");
fprintf(Outfile,(char*)"%s\n"," return rstr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Findfirst)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *findfirst (char *filespec, FILE_FIND_DATA *FindData)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," struct dirent *dp;");
fprintf(Outfile,(char*)"%s\n"," struct stat st;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if(FindData->FileHandle)");
fprintf(Outfile,(char*)"%s\n"," closedir(FindData->FileHandle);");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," strcpy(FindData->path, BcxSplitPath(filespec, FDRV|FPATH));");
fprintf(Outfile,(char*)"%s\n"," strcpy(FindData->cFileSpec,BcxSplitPath(filespec, FNAME|FEXT));");
fprintf(Outfile,(char*)"%s%s%s\n"," if(*FindData->path==0) strcpy(FindData->path, ",enc("."),");");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," FindData->FileHandle=opendir(FindData->path);");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," while(FindData->FileHandle)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," dp=readdir(FindData->FileHandle);");
fprintf(Outfile,(char*)"%s\n"," if(dp==NULL) break;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if(like(dp->d_name,FindData->cFileSpec))");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," strcpy(FindData->cFileName,dp->d_name);");
fprintf(Outfile,(char*)"%s\n"," lstat(join(2,FindData->path,dp->d_name), &st);");
fprintf(Outfile,(char*)"%s\n"," FindData->dwFileAttributes = st.st_mode;");
fprintf(Outfile,(char*)"%s\n"," return FindData->cFileName;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," *FindData->cFileName=0;");
fprintf(Outfile,(char*)"%s\n"," return FindData->cFileName;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Findnext)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *findnext (FILE_FIND_DATA *FindData)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," struct dirent *dp;");
fprintf(Outfile,(char*)"%s\n"," struct stat st;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," while(FindData->FileHandle)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," dp=readdir(FindData->FileHandle);");
fprintf(Outfile,(char*)"%s\n"," if(dp==NULL) break;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if(like(dp->d_name,FindData->cFileSpec))");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," strcpy(FindData->cFileName,dp->d_name);");
fprintf(Outfile,(char*)"%s\n"," lstat(join(2,FindData->path,dp->d_name), &st);");
fprintf(Outfile,(char*)"%s\n"," FindData->dwFileAttributes = st.st_mode;");
fprintf(Outfile,(char*)"%s\n"," return FindData->cFileName;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," *FindData->cFileName=0;");
fprintf(Outfile,(char*)"%s\n"," return FindData->cFileName;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Ucase)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *ucase (char *S)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(strlen(S));");
fprintf(Outfile,(char*)"%s\n"," return _strupr_(strcpy(strtmp,S));");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Lcase)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *lcase (char *S)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(strlen(S));");
fprintf(Outfile,(char*)"%s\n"," return _strlwr_(strcpy(strtmp,S));");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mcase)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *mcase (char *S)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(strlen(S)+1);");
fprintf(Outfile,(char*)"%s\n"," char *s = strtmp;");
fprintf(Outfile,(char*)"%s\n"," _strlwr_(strcpy(strtmp,S));");
fprintf(Outfile,(char*)"%s\n"," while(*s)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(islower(*s))");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," *s-=32;");
fprintf(Outfile,(char*)"%s\n"," while(isalpha(*++s));");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," s++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Remove)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *RemoveStr (char *a, char *b)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp, *p, *d;");
fprintf(Outfile,(char*)"%s\n"," int tmplen;");
fprintf(Outfile,(char*)"%s\n"," strtmp = d = BCX_TmpStr(strlen(a));");
fprintf(Outfile,(char*)"%s\n"," if(!b || !*b) return strcpy(strtmp,a);");
fprintf(Outfile,(char*)"%s\n"," p=_strstr_(a,b); tmplen = strlen(b);");
fprintf(Outfile,(char*)"%s\n"," while(p)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," memcpy(d,a,p-a);");
fprintf(Outfile,(char*)"%s\n"," d+= (p-a);");
fprintf(Outfile,(char*)"%s\n"," a=p+tmplen;");
fprintf(Outfile,(char*)"%s\n"," p=_strstr_(a,b);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," strcpy(d,a);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_IRemove)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *IRemoveStr (char *a, char *b)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp, *p, *d;");
fprintf(Outfile,(char*)"%s\n"," int tmplen;");
fprintf(Outfile,(char*)"%s\n"," strtmp = d = BCX_TmpStr(strlen(a));");
fprintf(Outfile,(char*)"%s\n"," if(!b || !*b) return strcpy(strtmp,a);");
fprintf(Outfile,(char*)"%s\n"," p=_stristr_(a,b); tmplen = strlen(b);");
fprintf(Outfile,(char*)"%s\n"," while(p)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," memcpy(d,a,p-a);");
fprintf(Outfile,(char*)"%s\n"," d+= (p-a);");
fprintf(Outfile,(char*)"%s\n"," a=p+tmplen;");
fprintf(Outfile,(char*)"%s\n"," p=_stristr_(a,b);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," strcpy(d,a);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Ins)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *ins (char *S, int i, char *a)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int j = strlen(S);");
fprintf(Outfile,(char*)"%s\n"," if(i<1 || i>j+1) return S;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(j + strlen(a));");
fprintf(Outfile,(char*)"%s\n"," memcpy(strtmp,S,--i);");
fprintf(Outfile,(char*)"%s\n"," strcpy(&strtmp[i],a);");
fprintf(Outfile,(char*)"%s\n"," return strcat(strtmp,&S[i]);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Del)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *del (char *S, int i, int j)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int ln = strlen(S);");
fprintf(Outfile,(char*)"%s\n"," if(i<1 || i>ln) return S;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(ln);");
fprintf(Outfile,(char*)"%s\n"," memcpy(strtmp,S,--i);");
fprintf(Outfile,(char*)"%s\n"," return strcat(strtmp,&S[i+j]);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Str)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *str (double d)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(16);");
fprintf(Outfile,(char*)"%s%s%s\n"," sprintf(strtmp,",D1,",d);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Strl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *strl (long double d)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(27);");
fprintf(Outfile,(char*)"%s%s%s\n"," sprintf(strtmp,",D2,",d);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Curdir)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *curdir (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(2048);");
fprintf(Outfile,(char*)"%s\n"," char *res=getcwd(strtmp, 1024);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Hex)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *hex (int a)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(16);");
fprintf(Outfile,(char*)"%s%s%s\n"," sprintf(strtmp,",enc("%02X"),",a);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Tempdir)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *tempdir (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(2048);");
fprintf(Outfile,(char*)"%s%s%s\n"," if(!Exist(",enc("/tmp/mbc.compiler"),")) {");
fprintf(Outfile,(char*)"%s%s%s\n"," mkdir (",enc("/tmp/mbc.compiler"),",0755);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s%s%s\n"," strcpy(strtmp,",enc("/tmp/mbc.compiler"),");");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Sysdir)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *sysdir (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(2048);");
fprintf(Outfile,(char*)"%s\n"," GetSystemDirectory (strtmp,2048);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Repeat)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *repeat (int count, char *a)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr((1+count)*strlen(a));");
fprintf(Outfile,(char*)"%s\n"," while(count-->0) strtmp = strcat(strtmp, a);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_String)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *stringx (int count, int a)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(count<1) return BCX_TmpStr(1);");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(count);");
fprintf(Outfile,(char*)"%s\n"," return (char*)memset(strtmp,a,count);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Shell)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void Shell (char *cmd)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int res=system(cmd);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Space)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *space (int count)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(count<1) return BCX_TmpStr(1);");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(count);");
fprintf(Outfile,(char*)"%s\n"," return (char*)memset(strtmp,32,count);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Time)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *timef (int t)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," time_t elapse_time;");
fprintf(Outfile,(char*)"%s\n"," struct tm *tp;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(256);");
fprintf(Outfile,(char*)"%s\n"," time (&elapse_time);");
fprintf(Outfile,(char*)"%s\n"," tp = localtime(&elapse_time);");
fprintf(Outfile,(char*)"%s\n"," switch (t)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," case 0:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T0,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 1:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T1,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 2:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T2,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 3:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T3,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 4:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T4,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 5:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T5,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 6:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T6,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 7:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T7,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 8:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T8,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 9:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T9,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 10:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T10,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 11:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T11,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 12:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T12,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," case 13:");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",T13,",tp); break;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Enclose)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *enc (char *A, int L, int R)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *BCX_RetStr = BCX_TmpStr(strlen(A)+3);");
fprintf(Outfile,(char*)"%s\n"," if(L==0) L=34;");
fprintf(Outfile,(char*)"%s\n"," if(R==0) R=L;");
fprintf(Outfile,(char*)"%s%s%s%s%s\n"," sprintf(BCX_RetStr,",enc("%c%s%c%s"),",L,A,R,",enc("\0"),");");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Chr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%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,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(11);");
fprintf(Outfile,(char*)"%s\n"," strtmp[0] = a;");
fprintf(Outfile,(char*)"%s\n"," strtmp[1] = b;");
fprintf(Outfile,(char*)"%s\n"," strtmp[2] = c;");
fprintf(Outfile,(char*)"%s\n"," strtmp[3] = d;");
fprintf(Outfile,(char*)"%s\n"," strtmp[4] = e;");
fprintf(Outfile,(char*)"%s\n"," strtmp[5] = f;");
fprintf(Outfile,(char*)"%s\n"," strtmp[6] = g;");
fprintf(Outfile,(char*)"%s\n"," strtmp[7] = h;");
fprintf(Outfile,(char*)"%s\n"," strtmp[8] = i;");
fprintf(Outfile,(char*)"%s\n"," strtmp[9] = j;");
fprintf(Outfile,(char*)"%s\n"," strtmp[10] = 0;");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_VChr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *vchr(int charcount, ...)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int c = 0, i = charcount;");
fprintf(Outfile,(char*)"%s\n"," char *s_ = BCX_TmpStr(charcount + 1);");
fprintf(Outfile,(char*)"%s\n"," va_list marker;");
fprintf(Outfile,(char*)"%s\n"," s_[i] = 0;");
fprintf(Outfile,(char*)"%s\n"," va_start(marker, charcount);");
fprintf(Outfile,(char*)"%s\n"," while(i-- > 0) s_[c++] = va_arg(marker,int);");
fprintf(Outfile,(char*)"%s\n"," va_end(marker);");
fprintf(Outfile,(char*)"%s\n"," return s_;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Join)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char * join(int n, ...)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int i = n, tmplen = 0;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp, *s_;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," va_list marker;");
fprintf(Outfile,(char*)"%s\n"," va_start(marker, n); // Initialize variable arguments");
fprintf(Outfile,(char*)"%s\n"," while(i-- > 0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," s_ = va_arg(marker, char *);");
fprintf(Outfile,(char*)"%s\n"," if(s_) tmplen += strlen(s_);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," strtmp = BCX_TmpStr(tmplen);");
fprintf(Outfile,(char*)"%s\n"," va_end(marker); // Reset variable arguments");
fprintf(Outfile,(char*)"%s\n"," i = n;");
fprintf(Outfile,(char*)"%s\n"," va_start(marker, n); // Initialize variable arguments");
fprintf(Outfile,(char*)"%s\n"," while(i-- > 0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," s_ = va_arg(marker, char *);");
fprintf(Outfile,(char*)"%s\n"," if(s_) strcat(strtmp, s_);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," va_end(marker); // Reset variable arguments");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Environ)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* Environ(char *S)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp, *tmp;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," tmp = getenv(S);");
fprintf(Outfile,(char*)"%s\n"," if(tmp != NULL) {");
fprintf(Outfile,(char*)"%s\n"," strtmp = BCX_TmpStr(strlen(tmp)+1);");
fprintf(Outfile,(char*)"%s\n"," return strcpy(strtmp, tmp);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return BCX_TmpStr(1);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Oct)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *oct (int a)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(2048);");
fprintf(Outfile,(char*)"%s%s%s\n"," sprintf(strtmp,",O1,",a);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Bin)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* Bin(int number)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(2048);");
fprintf(Outfile,(char*)"%s\n"," itoa(number,strtmp,2);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Pause)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void Pause(void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s%s%s%s%s\n"," printf(",enc("\\n%s\\n"),",",enc("Press any key to continue . . ."),");");
fprintf(Outfile,(char*)"%s\n"," _getch_(TRUE);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Keypress)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int keypress(void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return _getch_(TRUE);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Inkey)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* inkey(void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(2);");
fprintf(Outfile,(char*)"%s\n"," strtmp[0] = _getch_(FALSE);");
fprintf(Outfile,(char*)"%s\n"," if(strtmp[0] == -1) strtmp[0] = 0;");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_InkeyD)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int inkeyd(void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return _getch_(TRUE);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Instat)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int kbhit(void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," struct termios oldt, newt;");
fprintf(Outfile,(char*)"%s\n"," int ch;");
fprintf(Outfile,(char*)"%s\n"," int oldf;");
fprintf(Outfile,(char*)"%s\n"," tcgetattr(STDIN_FILENO, &oldt);");
fprintf(Outfile,(char*)"%s\n"," newt = oldt;");
fprintf(Outfile,(char*)"%s\n"," newt.c_lflag &= ~(ICANON | ECHO);");
fprintf(Outfile,(char*)"%s\n"," tcsetattr(STDIN_FILENO, TCSANOW, &newt);");
fprintf(Outfile,(char*)"%s\n"," oldf = fcntl(STDIN_FILENO, F_GETFL, 0);");
fprintf(Outfile,(char*)"%s\n"," fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);");
fprintf(Outfile,(char*)"%s\n"," ch = getchar();");
fprintf(Outfile,(char*)"%s\n"," tcsetattr(STDIN_FILENO, TCSANOW, &oldt);");
fprintf(Outfile,(char*)"%s\n"," fcntl(STDIN_FILENO, F_SETFL, oldf);");
fprintf(Outfile,(char*)"%s\n"," if(ch != EOF)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," ungetc(ch, stdin);");
fprintf(Outfile,(char*)"%s\n"," return 1;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_GetCh)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int _getch_(int waitkey)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," struct termios initial_settings, new_settings;");
fprintf(Outfile,(char*)"%s\n"," unsigned char ch;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," tcgetattr(0,&initial_settings);");
fprintf(Outfile,(char*)"%s\n"," new_settings = initial_settings;");
fprintf(Outfile,(char*)"%s\n"," new_settings.c_lflag &= ~ICANON;");
fprintf(Outfile,(char*)"%s\n"," new_settings.c_lflag &= ~ECHO;");
fprintf(Outfile,(char*)"%s\n"," new_settings.c_lflag &= ~ISIG;");
fprintf(Outfile,(char*)"%s\n"," new_settings.c_cc[VMIN] = waitkey;");
fprintf(Outfile,(char*)"%s\n"," new_settings.c_cc[VTIME] = 0;");
fprintf(Outfile,(char*)"%s\n"," tcsetattr(0, TCSANOW, &new_settings);");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," //read(0,&ch,1);");
fprintf(Outfile,(char*)"%s\n"," ch = getchar();");
fprintf(Outfile,(char*)"%s\n"," tcsetattr(0, TCSANOW, &initial_settings);");
fprintf(Outfile,(char*)"%s\n"," return ch;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Now)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *now (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," time_t elapse_time;");
fprintf(Outfile,(char*)"%s\n"," struct tm *tp;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp = BCX_TmpStr(2048);");
fprintf(Outfile,(char*)"%s\n"," time(&elapse_time);");
fprintf(Outfile,(char*)"%s\n"," tp=localtime(&elapse_time);");
fprintf(Outfile,(char*)"%s%s%s\n"," strftime(strtmp,256,",enc("%m/%d/%y %I:%M:%S: %p"),",tp);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_AppExePath)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *AppExePath (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char fullpath[MAX_PATH];");
fprintf(Outfile,(char*)"%s\n"," int length;");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#if defined (__APPLE__)
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n"," pid_t pid = getpid();");
fprintf(Outfile,(char*)"%s\n"," length = proc_pidpath (pid, fullpath, sizeof(fullpath));");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#else
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n"," length = readlink(",enc("/proc/self/exe"),", fullpath, MAX_PATH);");
Initial Code Commit
2022-07-28 18:29:51 +00:00
#endif
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n"," if(length < 1) return BCX_TmpStr(1);");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," fullpath[length] = 0;");
fprintf(Outfile,(char*)"%s\n"," return BcxSplitPath(fullpath, FDRV|FPATH);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_AppExeName)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *AppExeName (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return BcxSplitPath(G_argv[0], FNAME|FEXT);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_TempFileName)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char * TempFileName (char *dr, char *prefix)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static unsigned int count;");
fprintf(Outfile,(char*)"%s\n"," char *f, *tmpstr = BCX_TmpStr(MAX_PATH);");
fprintf(Outfile,(char*)"%s\n"," int i, length;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if(!count) srand(time(0));");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if(dr) strcpy(tmpstr, dr);");
fprintf(Outfile,(char*)"%s\n"," length = strlen(tmpstr);");
fprintf(Outfile,(char*)"%s\n"," if(length && (tmpstr[length-1] != '\\\\' && tmpstr[length-1] != '/'))");
fprintf(Outfile,(char*)"%s\n"," tmpstr[length++] = '/';");
fprintf(Outfile,(char*)"%s\n"," if(prefix) strcpy(&tmpstr[length], prefix);");
fprintf(Outfile,(char*)"%s\n"," f = &tmpstr[strlen(tmpstr)];");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," do {");
fprintf(Outfile,(char*)"%s\n"," count++;");
fprintf(Outfile,(char*)"%s\n"," for(i=0; i<5; i+=1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," do {");
fprintf(Outfile,(char*)"%s\n"," f[i]=(char)(rnd()*122);");
fprintf(Outfile,(char*)"%s\n"," }while((f[i]<65)||(f[i]>90&&f[i]<97));");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s%s%s\n"," snprintf(&f[5],3,",enc("%x"),", count);");
fprintf(Outfile,(char*)"%s\n"," } while (Exist(tmpstr));");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," return tmpstr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Boolstr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char * BoolStr (int a)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *BCX_RetStr=BCX_TmpStr(5);");
fprintf(Outfile,(char*)"%s%s%s\n"," if(a) return strcpy(BCX_RetStr,",enc("True"),");");
fprintf(Outfile,(char*)"%s%s%s\n"," return strcpy(BCX_RetStr,",enc("False"),");");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Using)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *Using (char *Mask, double Num)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int Spaces = 0;");
fprintf(Outfile,(char*)"%s\n"," int CntDec = 0;");
fprintf(Outfile,(char*)"%s\n"," int Decimals = 0;");
fprintf(Outfile,(char*)"%s\n"," int Dollar = 0;");
fprintf(Outfile,(char*)"%s\n"," char* BCX_RetStr = BCX_TmpStr(512);");
fprintf(Outfile,(char*)"%s\n"," char Buf_1[512]={0};");
fprintf(Outfile,(char*)"%s\n"," char* p = Mask;");
fprintf(Outfile,(char*)"%s\n"," char* r;");
fprintf(Outfile,(char*)"%s\n"," int len;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," while (*p)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if (*p == 36) Dollar++;");
fprintf(Outfile,(char*)"%s\n"," if (*p == 32) Spaces++;");
fprintf(Outfile,(char*)"%s\n"," if ((*p == 32 || *p == 35)&& CntDec) Decimals++;");
fprintf(Outfile,(char*)"%s\n"," if (*p == 46) CntDec = 1;");
fprintf(Outfile,(char*)"%s\n"," p++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s%s%s\n"," sprintf(Buf_1,",enc("%1.*f"),",Decimals,Num);");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," len = strlen(Buf_1)-Decimals-(Decimals>0?1:0);");
fprintf(Outfile,(char*)"%s\n"," r = BCX_RetStr+Dollar+Spaces;");
fprintf(Outfile,(char*)"%s\n"," p = Buf_1;");
fprintf(Outfile,(char*)"%s\n"," while (*p)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," *r++ = *p++;");
fprintf(Outfile,(char*)"%s\n"," if (--len>2 && *(p-1) != '-' && len % 3 == 0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," *r++ = ',';");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(Dollar) BCX_RetStr[Spaces]=36;");
fprintf(Outfile,(char*)"%s\n"," if(Spaces) memset(BCX_RetStr,32,Spaces);");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_SearchPath)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *SEARCHPATH (char *szFile)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *BCX_RetStr=BCX_TmpStr(MAX_PATH+1);");
fprintf(Outfile,(char*)"%s\n"," PCHAR lpbs=0;");
fprintf(Outfile,(char*)"%s\n"," SearchPath(0,szFile,0,MAX_PATH,BCX_RetStr,&lpbs);");
fprintf(Outfile,(char*)"%s\n"," if(lpbs) *lpbs=0;");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Instrrev)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int InstrRev (char *s, char *p, int os, int sens)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int sl, pl, ox;");
fprintf(Outfile,(char*)"%s\n"," int (*cmp)(const char *, const char *, size_t );");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (!s || !p) return 0;");
fprintf(Outfile,(char*)"%s\n"," sl = strlen(s); pl = strlen(p);");
fprintf(Outfile,(char*)"%s\n"," if (os > sl || sl == 0 || pl == 0 || (ox = sl - pl) < 0)");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (os <= 0) ");
fprintf(Outfile,(char*)"%s\n"," os = ox ;");
fprintf(Outfile,(char*)"%s\n"," else if(os >= pl)");
fprintf(Outfile,(char*)"%s\n"," os = os - pl ;");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," cmp = (sens ? strncasecmp : strncmp);");
fprintf(Outfile,(char*)"%s\n"," do { if (cmp(s + os , p, pl) == 0)");
fprintf(Outfile,(char*)"%s\n"," return os+1;");
fprintf(Outfile,(char*)"%s\n"," } while (os--);");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Instr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int instr_b(char* mane,char* match,int offset,int sensflag)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *s;");
fprintf(Outfile,(char*)"%s\n"," if (!mane || !match || ! *match || offset>(int)strlen(mane)) return 0;");
fprintf(Outfile,(char*)"%s\n"," if (sensflag)");
fprintf(Outfile,(char*)"%s\n"," s = _stristr_(offset>0 ? mane+offset-1 : mane,match);");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," s = _strstr_(offset>0 ? mane+offset-1 : mane,match);");
fprintf(Outfile,(char*)"%s\n"," return s ? (int)(s-mane)+1 : 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(UseLCaseTbl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *MakeLCaseTbl (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static char tbl[256];");
fprintf(Outfile,(char*)"%s\n"," if(!tbl['a'])");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," int i; for (i=0; i < 256; i++)");
fprintf(Outfile,(char*)"%s\n"," tbl[i] = (char)(int)tolower(i);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return tbl;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Stristr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *_stristr_(char *String, char *Pattern)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int mi=-1;");
fprintf(Outfile,(char*)"%s\n"," char *LowCase = MakeLCaseTbl();");
fprintf(Outfile,(char*)"%s\n"," while(Pattern[++mi])");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(String[mi]==0) return 0;");
fprintf(Outfile,(char*)"%s\n"," if(LowCase[(unsigned char)String[mi]]!=LowCase[(unsigned char)Pattern[mi]])");
fprintf(Outfile,(char*)"%s\n"," { String++; mi=-1; }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return String;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_StrStr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *_strstr_(char *String, char *Pattern)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int mi=-1;");
fprintf(Outfile,(char*)"%s\n"," while(Pattern[++mi])");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(String[mi]==0) return 0;");
fprintf(Outfile,(char*)"%s\n"," if(String[mi]!=Pattern[mi])");
fprintf(Outfile,(char*)"%s\n"," { String++; mi=-1; }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return String;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Inchr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int inchr (char *A, char *B)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char* C=A;");
fprintf(Outfile,(char*)"%s\n"," while(*C)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(*C==*B) return C-A+1;");
fprintf(Outfile,(char*)"%s\n"," C++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Asc)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","extern int asc (char *z,int index)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return (unsigned char) z[index];");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Sgn)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double sgn (double a)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(a<0) return -1;");
fprintf(Outfile,(char*)"%s\n"," if(a>0) return 1;");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Round)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double Round (double n, int d)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return (floor((n)*pow(10.0,(d))+0.5)/pow(10.0,(d)));");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Embed)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* GetResource (int *resource)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *BCX_RetStr={0};");
fprintf(Outfile,(char*)"%s\n"," static char* dat;");
fprintf(Outfile,(char*)"%s\n"," memset(&dat,0,sizeof(char *));");
fprintf(Outfile,(char*)"%s\n"," dat=(char*)resource;");
fprintf(Outfile,(char*)"%s\n"," BCX_RetStr=BCX_TmpStr(strlen(dat));");
fprintf(Outfile,(char*)"%s\n"," strcpy(BCX_RetStr,dat);");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Exist)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","bool Exist (char *szFilePath)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int retstat;");
fprintf(Outfile,(char*)"%s\n"," struct stat sb;");
fprintf(Outfile,(char*)"%s\n"," retstat = stat(szFilePath, &sb);");
fprintf(Outfile,(char*)"%s\n"," if(retstat != -1)");
fprintf(Outfile,(char*)"%s\n"," return TRUE;");
fprintf(Outfile,(char*)"%s\n"," return FALSE;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Tally)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int tally (char *szLine, char *szChar, int sensflag)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(!*szChar) return 0;");
fprintf(Outfile,(char*)"%s\n"," int mlen = strlen(szChar);");
fprintf(Outfile,(char*)"%s\n"," int iCount = 0;");
fprintf(Outfile,(char*)"%s\n"," char *p = (sensflag == 0 ? _strstr_(szLine, szChar) : _stristr_(szLine, szChar));");
fprintf(Outfile,(char*)"%s\n"," while (p)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," iCount++;");
fprintf(Outfile,(char*)"%s\n"," p+=mlen;");
fprintf(Outfile,(char*)"%s\n"," p = (sensflag == 0 ? _strstr_(p, szChar) : _stristr_(p, szChar));");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return iCount;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Timer)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","float timer (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return ((double)clock()/CLOCKS_PER_SEC);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Rnd)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","float rnd (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return (float)rand()/RAND_MAX;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Exp)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double Exp (double arg)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return pow(2.718281828459045,arg);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Randomize)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void randomize (unsigned int seed)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," srand(seed);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Max)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double _MAX_ (double a, double b)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(a>b)");
fprintf(Outfile,(char*)"%s\n"," return a;");
fprintf(Outfile,(char*)"%s\n"," return b;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Min)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double _MIN_ (double a, double b)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(a<b)");
fprintf(Outfile,(char*)"%s\n"," return a;");
fprintf(Outfile,(char*)"%s\n"," return b;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Locate)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void locate (int row,int col,int show,int shape)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%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,(char*)"%s\n"," // find cursor size/shape function!");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cls)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void cls (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n"," printf(",enc("%s%s%s%s"),",ESC,",enc("[2J"),",ESC,",enc("[H"),");");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Color)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void color (int fg,int bg)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%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,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Midstr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void midstr (char *src, int st, int length, char *rep)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int srclen = strlen(src);");
fprintf(Outfile,(char*)"%s\n"," if(st>srclen++ || st<1) return;");
fprintf(Outfile,(char*)"%s\n"," int replen = strlen(rep);");
fprintf(Outfile,(char*)"%s\n"," if(replen < length || length==-1) length=replen;");
fprintf(Outfile,(char*)"%s\n"," if((st+length) > srclen) length=srclen-st;");
fprintf(Outfile,(char*)"%s\n"," memcpy(&src[st-1],rep,length);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Swap)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void swap ( UCHAR* A, UCHAR* B, int length)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," UCHAR t;");
fprintf(Outfile,(char*)"%s\n"," while(length--)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," t = *A;");
fprintf(Outfile,(char*)"%s\n"," *(A++) = *B;");
fprintf(Outfile,(char*)"%s\n"," *(B++) = t;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Like)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int like (char *raw, char *pat)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char a, b, d;");
fprintf(Outfile,(char*)"%s\n"," char *r, *p;");
fprintf(Outfile,(char*)"%s\n"," int star = 0;");
fprintf(Outfile,(char*)"%s\n"," for(;;) {");
fprintf(Outfile,(char*)"%s\n"," if ((d = *pat++)==0) return (star || !*raw);");
fprintf(Outfile,(char*)"%s\n"," else if (d == '*') star = 1;");
fprintf(Outfile,(char*)"%s\n"," else if (d == '?') { if (!*raw++) return 0; }");
fprintf(Outfile,(char*)"%s\n"," else break;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," b = d;");
fprintf(Outfile,(char*)"%s\n"," do if ((a = *raw++) == b) {");
fprintf(Outfile,(char*)"%s\n"," r = raw;");
fprintf(Outfile,(char*)"%s\n"," p = pat;");
fprintf(Outfile,(char*)"%s\n"," do {");
fprintf(Outfile,(char*)"%s\n"," if ((d = *p++) == '*')");
fprintf(Outfile,(char*)"%s\n"," if (like(r, p - 1)) return 1;");
fprintf(Outfile,(char*)"%s\n"," else break;");
fprintf(Outfile,(char*)"%s\n"," else if (!d) {");
fprintf(Outfile,(char*)"%s\n"," if (!*r) return 1;");
fprintf(Outfile,(char*)"%s\n"," else break;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," } while (*r++ == d || d == '?');");
fprintf(Outfile,(char*)"%s\n"," } while (star && a);");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Lof)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","DWORD lof (char *FileName)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," int retstat;");
fprintf(Outfile,(char*)"%s\n"," struct stat sb;");
fprintf(Outfile,(char*)"%s\n"," retstat = stat(FileName, &sb);");
fprintf(Outfile,(char*)"%s\n"," if(retstat != -1)");
fprintf(Outfile,(char*)"%s\n"," return sb.st_size;");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Iif)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double iif (bool cond, double tp, double fp)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(cond) return tp;");
fprintf(Outfile,(char*)"%s\n"," return fp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_sziif)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char * sziif (bool i, char *a, char *b)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(i) return a;");
fprintf(Outfile,(char*)"%s\n"," return b;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_DynamicA)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","void *CreateArr(void *a, int elem_size, int update, int num_dims, ... )");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," va_list ap;");
fprintf(Outfile,(char*)"%s\n"," void *RetPtr;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," va_start(ap, num_dims);");
fprintf(Outfile,(char*)"%s\n"," RetPtr = CreateArr_internal(a, elem_size, update, num_dims, ap);");
fprintf(Outfile,(char*)"%s\n"," va_end(ap);");
fprintf(Outfile,(char*)"%s\n"," return (RetPtr);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
fprintf(Outfile,(char*)"%s\n","void *CreateArr_internal(void *a, int elem_size, int update, int num_dims, va_list ap)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," size_t s, s1, s2;");
fprintf(Outfile,(char*)"%s\n"," void **vp;");
fprintf(Outfile,(char*)"%s\n"," va_list marker;");
fprintf(Outfile,(char*)"%s\n"," ");
fprintf(Outfile,(char*)"%s\n","#ifdef va_copy");
fprintf(Outfile,(char*)"%s\n"," va_copy(marker, ap);");
fprintf(Outfile,(char*)"%s\n","#else");
fprintf(Outfile,(char*)"%s\n"," marker = ap;");
fprintf(Outfile,(char*)"%s\n","#endif");
fprintf(Outfile,(char*)"%s\n"," s = va_arg(marker, size_t);");
fprintf(Outfile,(char*)"%s\n"," s2 = s + 2;");
fprintf(Outfile,(char*)"%s\n"," if(num_dims == 1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(update && a)");
fprintf(Outfile,(char*)"%s\n"," a=realloc(a,s2*elem_size);");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," a=calloc(s2,elem_size);");
fprintf(Outfile,(char*)"%s\n"," return a;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," if(update && a)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," s1 = 0;");
fprintf(Outfile,(char*)"%s\n"," vp = (void**)a;");
fprintf(Outfile,(char*)"%s\n"," while(*vp && s1 <= s)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," vp++;");
fprintf(Outfile,(char*)"%s\n"," s1++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(s1 > s)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," vp--;");
fprintf(Outfile,(char*)"%s\n"," DestroyArr(vp, num_dims, 0);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," a=realloc(a,s2*sizeof(int));");
fprintf(Outfile,(char*)"%s\n"," s1 = 0;");
fprintf(Outfile,(char*)"%s\n"," vp = (void**)a;");
fprintf(Outfile,(char*)"%s\n"," while(*vp && s1 <= s)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," vp++;");
fprintf(Outfile,(char*)"%s\n"," s1++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," while(s1 < s2)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," *(((int *)vp)) = 0;");
fprintf(Outfile,(char*)"%s\n"," vp++;");
fprintf(Outfile,(char*)"%s\n"," s1++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," a=calloc(s2*sizeof(int),1);");
fprintf(Outfile,(char*)"%s\n"," vp = (void**)a;");
fprintf(Outfile,(char*)"%s\n"," if(--num_dims > 0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," for(s1 = 0; s1 < s; s1++)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," vp[s1] = CreateArr_internal(vp[s1], elem_size, update, num_dims, marker);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return a;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
fprintf(Outfile,(char*)"%s\n","void DestroyArr (void** a,int num_dims, int top_free)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int i = 0;");
fprintf(Outfile,(char*)"%s\n"," static int s = 0;");
fprintf(Outfile,(char*)"%s\n"," if(num_dims == 1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," free(a);");
fprintf(Outfile,(char*)"%s\n"," return;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," s++;");
fprintf(Outfile,(char*)"%s\n"," num_dims--; ");
fprintf(Outfile,(char*)"%s\n"," while(a[i])");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," DestroyArr((void**)a[i], num_dims, top_free);");
fprintf(Outfile,(char*)"%s\n"," if(num_dims > 1)");
fprintf(Outfile,(char*)"%s\n"," free(a[i]);");
fprintf(Outfile,(char*)"%s\n"," a[i++]=NULL;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," s--;");
fprintf(Outfile,(char*)"%s\n"," if(s == 0 && top_free)");
fprintf(Outfile,(char*)"%s\n"," free(a);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Idxqsort)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int IdxCompare (const void *one, const void *two)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int *ptr1 = (int *)(one);");
fprintf(Outfile,(char*)"%s\n"," int *ptr2 = (int *)(two);");
fprintf(Outfile,(char*)"%s\n"," return strcasecmp (pppStr[Key][*ptr1],pppStr[Key][*ptr2]);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_IdxqsortSt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int IdxCompareSt (const void* one, const void* two)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n","#define compare1 cmp1+(StructSize * (*(UINT *)(one)))");
fprintf(Outfile,(char*)"%s\n","#define compare2 cmp1+(StructSize * (*(UINT *)(two)))");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (Key==0)");
fprintf(Outfile,(char*)"%s\n"," return strcasecmp(compare1, compare2);");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (Key==1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if (*(int*)(compare1) < *(int*)(compare2)) return -1;");
fprintf(Outfile,(char*)"%s\n"," if (*(int*)(compare1) > *(int*)(compare2)) return 1;");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (Key==2)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if (*(double*)(compare1) < *(double*)(compare2)) return -1;");
fprintf(Outfile,(char*)"%s\n"," if (*(double*)(compare1) > *(double*)(compare2)) return 1;");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (Key==3)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if (*(UINT*)(compare1) < *(UINT*)(compare2)) return -1;");
fprintf(Outfile,(char*)"%s\n"," if (*(UINT*)(compare1) > *(UINT*)(compare2)) return 1;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","return 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_PtrqsortSt)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int PtrCompareSt (const void* one, const void* two)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n","#define pcompare1 ((char*)(one)+OffSet)");
fprintf(Outfile,(char*)"%s\n","#define pcompare2 ((char*)(two)+OffSet)");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (Key==0)");
fprintf(Outfile,(char*)"%s\n"," return strcasecmp(pcompare1, pcompare2);");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (Key==1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if (*(int*)(pcompare1) < *(int*)(pcompare2)) return -1;");
fprintf(Outfile,(char*)"%s\n"," if (*(int*)(pcompare1) > *(int*)(pcompare2)) return 1;");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (Key==2)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if (*(double*)(pcompare1) < *(double*)(pcompare2)) return -1;");
fprintf(Outfile,(char*)"%s\n"," if (*(double*)(pcompare1) > *(double*)(pcompare2)) return 1;");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (Key==3)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if (*(UINT*)(pcompare1) < *(UINT*)(pcompare2)) return -1;");
fprintf(Outfile,(char*)"%s\n"," if (*(UINT*)(pcompare1) > *(UINT*)(pcompare2)) return 1;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","return 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Strqsorta)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int StrCompareA (const void *arg1, const void *arg2)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *v1 = (char*) arg1;");
fprintf(Outfile,(char*)"%s\n"," char *v2 = (char*) arg2;");
fprintf(Outfile,(char*)"%s\n"," return strcasecmp (v1,v2);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Strqsortd)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int StrCompareD (const void *arg1, const void *arg2)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *v1 = (char*) arg1;");
fprintf(Outfile,(char*)"%s\n"," char *v2 = (char*) arg2;");
fprintf(Outfile,(char*)"%s\n"," return strcasecmp (v2,v1);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_DynStrqsorta)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int DynStrCompareA (const void *arg1, const void *arg2)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *v1 = *(char **) arg1;");
fprintf(Outfile,(char*)"%s\n"," char *v2 = *(char **) arg2;");
fprintf(Outfile,(char*)"%s\n"," return strcasecmp(v1, v2);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_DynStrqsortd)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int DynStrCompareD (const void *arg1, const void *arg2)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *v1 = *(char **) arg1;");
fprintf(Outfile,(char*)"%s\n"," char *v2 = *(char **) arg2;");
fprintf(Outfile,(char*)"%s\n"," return strcasecmp(v2, v1);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortaint)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareAint (const void *one, const void *two)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int *ptr1 = (int *)(one);");
fprintf(Outfile,(char*)"%s\n"," int *ptr2 = (int *)(two);");
fprintf(Outfile,(char*)"%s\n"," if (*ptr1 < *ptr2) return -1;");
fprintf(Outfile,(char*)"%s\n"," else if (*ptr1 == *ptr2) return 0;");
fprintf(Outfile,(char*)"%s\n"," else return 1;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortdint)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareDint (const void *one, const void *two)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int *ptr1 = (int *)(one);");
fprintf(Outfile,(char*)"%s\n"," int *ptr2 = (int *)(two);");
fprintf(Outfile,(char*)"%s\n"," if (*ptr1 > *ptr2) return -1;");
fprintf(Outfile,(char*)"%s\n"," else if (*ptr1 == *ptr2) return 0;");
fprintf(Outfile,(char*)"%s\n"," else return 1;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortafloat)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareAfloat (const void *one, const void *two)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," float *ptr1 = (float *)(one);");
fprintf(Outfile,(char*)"%s\n"," float *ptr2 = (float *)(two);");
fprintf(Outfile,(char*)"%s\n"," if (*ptr1 < *ptr2) return -1;");
fprintf(Outfile,(char*)"%s\n"," else if (*ptr1 == *ptr2) return 0;");
fprintf(Outfile,(char*)"%s\n"," else return 1;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortdfloat)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareDfloat (const void *one, const void *two)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," float *ptr1 = (float *)(one);");
fprintf(Outfile,(char*)"%s\n"," float *ptr2 = (float *)(two);");
fprintf(Outfile,(char*)"%s\n"," if (*ptr1 > *ptr2) return -1;");
fprintf(Outfile,(char*)"%s\n"," else if (*ptr1 == *ptr2) return 0;");
fprintf(Outfile,(char*)"%s\n"," else return 1;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortadouble)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareAdouble (const void *one, const void *two)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," double *ptr1 = (double *)(one);");
fprintf(Outfile,(char*)"%s\n"," double *ptr2 = (double *)(two);");
fprintf(Outfile,(char*)"%s\n"," if (*ptr1 < *ptr2) return -1;");
fprintf(Outfile,(char*)"%s\n"," else if (*ptr1 == *ptr2) return 0;");
fprintf(Outfile,(char*)"%s\n"," else return 1;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Numqsortddouble)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int NumCompareDdouble (const void *one, const void *two)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," double *ptr1 = (double *)(one);");
fprintf(Outfile,(char*)"%s\n"," double *ptr2 = (double *)(two);");
fprintf(Outfile,(char*)"%s\n"," if (*ptr1 > *ptr2) return -1;");
fprintf(Outfile,(char*)"%s\n"," else if (*ptr1 == *ptr2) return 0;");
fprintf(Outfile,(char*)"%s\n"," else return 1;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_FillArray)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int fillarray(char *input, int ArrayType, int MaxCnt, void *Array)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(MaxCnt < 1) return -1;");
fprintf(Outfile,(char*)"%s\n"," int c = 0, cnt=-1, cnt2;");
fprintf(Outfile,(char*)"%s\n"," char A[65535];");
fprintf(Outfile,(char*)"%s\n"," int *intptr = (int *)Array;");
fprintf(Outfile,(char*)"%s\n"," float *floatptr = (float *)Array;");
fprintf(Outfile,(char*)"%s\n"," double *doubleptr = (double *)Array;");
fprintf(Outfile,(char*)"%s\n"," long double *ldoubleptr = (long double *)Array;");
fprintf(Outfile,(char*)"%s\n"," for(;;)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," cnt2=0;");
fprintf(Outfile,(char*)"%s\n"," while(input[++cnt]!=',')");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(input[cnt]==0) break;");
fprintf(Outfile,(char*)"%s\n"," A[cnt2++]=input[cnt];");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," A[cnt2]=0;");
fprintf(Outfile,(char*)"%s\n"," if(cnt2==0||c==MaxCnt) break;");
fprintf(Outfile,(char*)"%s\n"," ");
fprintf(Outfile,(char*)"%s\n"," if(ArrayType==2)");
fprintf(Outfile,(char*)"%s\n"," intptr[c++] = atoi(A);");
fprintf(Outfile,(char*)"%s\n"," else if(ArrayType==3)");
fprintf(Outfile,(char*)"%s\n"," floatptr[c++] = atof(A);");
fprintf(Outfile,(char*)"%s\n"," else if(ArrayType==4)");
fprintf(Outfile,(char*)"%s\n"," doubleptr[c++] = atof(A);");
fprintf(Outfile,(char*)"%s\n"," else if(ArrayType==5)");
fprintf(Outfile,(char*)"%s\n"," ldoubleptr[c++] = atof(A);");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if(input[cnt]==0) break;");
fprintf(Outfile,(char*)"%s\n"," } ");
fprintf(Outfile,(char*)"%s\n"," return (c-1);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Loc)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int loc(FILE *fp, int fplen)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," fpos_t t;");
fprintf(Outfile,(char*)"%s\n"," fgetpos(fp, &t);");
fprintf(Outfile,(char*)"%s\n","#if defined( __POCC__ )");
fprintf(Outfile,(char*)"%s\n"," t.off %= fplen;");
fprintf(Outfile,(char*)"%s\n"," return (int)t.off;");
fprintf(Outfile,(char*)"%s\n","#else");
fprintf(Outfile,(char*)"%s\n"," t %= fplen;");
fprintf(Outfile,(char*)"%s\n"," return (int)t;");
fprintf(Outfile,(char*)"%s\n","#endif");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Rec)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int rec(FILE *fp, int fplen)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," fpos_t t;");
fprintf(Outfile,(char*)"%s\n"," fgetpos(fp, &t);");
fprintf(Outfile,(char*)"%s\n","#if defined( __POCC__ )");
fprintf(Outfile,(char*)"%s\n"," t.off /= fplen;");
fprintf(Outfile,(char*)"%s\n"," return (int)++t.off;");
fprintf(Outfile,(char*)"%s\n","#else");
fprintf(Outfile,(char*)"%s\n"," t /= fplen;");
fprintf(Outfile,(char*)"%s\n"," return (int)++t;");
fprintf(Outfile,(char*)"%s\n","#endif");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_RecCount)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int reccount(FILE *fp, int fplen)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," fpos_t t;");
fprintf(Outfile,(char*)"%s\n"," fseek(fp,0,SEEK_END);");
fprintf(Outfile,(char*)"%s\n"," fgetpos(fp, &t);");
fprintf(Outfile,(char*)"%s\n","#if defined( __POCC__ )");
fprintf(Outfile,(char*)"%s\n"," t.off /= fplen;");
fprintf(Outfile,(char*)"%s\n"," return (int)t.off;");
fprintf(Outfile,(char*)"%s\n","#else");
fprintf(Outfile,(char*)"%s\n"," t /= fplen;");
fprintf(Outfile,(char*)"%s\n"," return (int)t;");
fprintf(Outfile,(char*)"%s\n","#endif");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Scan)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int scan(char *input, char *format, ... )");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int c,d ;");
fprintf(Outfile,(char*)"%s\n"," char *s_;");
fprintf(Outfile,(char*)"%s\n"," int *intptr;");
fprintf(Outfile,(char*)"%s\n"," float *floatptr;");
fprintf(Outfile,(char*)"%s\n"," double *doubleptr;");
fprintf(Outfile,(char*)"%s\n"," char A[50][65535];");
fprintf(Outfile,(char*)"%s\n"," va_list marker;");
fprintf(Outfile,(char*)"%s\n"," c = 0;");
fprintf(Outfile,(char*)"%s%s%s\n"," d = Split(A,input,",enc(","),");");
fprintf(Outfile,(char*)"%s\n"," va_start(marker, format); //Initialize arguments");
fprintf(Outfile,(char*)"%s\n"," while(d && *format)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(*format == '%') format++;");
fprintf(Outfile,(char*)"%s\n"," if(*format == 's')");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," s_ = va_arg(marker, char *);");
fprintf(Outfile,(char*)"%s\n"," strcpy(s_, A[c]);");
fprintf(Outfile,(char*)"%s\n"," c++;");
fprintf(Outfile,(char*)"%s\n"," d--;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(*format == 'd')");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," intptr = va_arg(marker, int *);");
fprintf(Outfile,(char*)"%s\n"," *intptr = atoi(A[c]);");
fprintf(Outfile,(char*)"%s\n"," c++;");
fprintf(Outfile,(char*)"%s\n"," d--;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(*format == 'g')");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," floatptr = va_arg(marker, float *);");
fprintf(Outfile,(char*)"%s\n"," *floatptr = atof(A[c]);");
fprintf(Outfile,(char*)"%s\n"," c++;");
fprintf(Outfile,(char*)"%s\n"," d--;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(*format == 'l')");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," format++;");
fprintf(Outfile,(char*)"%s\n"," doubleptr = va_arg(marker, double *);");
fprintf(Outfile,(char*)"%s\n"," *doubleptr = atof(A[c]);");
fprintf(Outfile,(char*)"%s\n"," c++;");
fprintf(Outfile,(char*)"%s\n"," d--;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," format++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," va_end(marker); // Reset variable arguments");
fprintf(Outfile,(char*)"%s\n"," if(d) return(1); // More data than variables");
fprintf(Outfile,(char*)"%s\n"," if(*format == 0) return(0); // OK");
fprintf(Outfile,(char*)"%s\n"," return(-1); // More variables than data");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Split)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Split (char Buf[][65535], char *T, char *Delim, int Flg)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int Begin = 0;");
fprintf(Outfile,(char*)"%s\n"," int Count = 0;");
fprintf(Outfile,(char*)"%s\n"," int Quote = 0;");
fprintf(Outfile,(char*)"%s\n"," int Index,i;");
fprintf(Outfile,(char*)"%s\n"," int lenT = strlen(T);");
fprintf(Outfile,(char*)"%s\n"," char Chr34[2]={34,0};");
fprintf(Outfile,(char*)"%s\n"," for(Index=1;Index<=lenT;Index++)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(instr_b(Delim,mid(T,Index,1))&&!Quote)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," strcpy(Buf[Count],(char*)mid(T,Begin,Index-Begin));");
fprintf(Outfile,(char*)"%s\n"," if ((Flg & 2) == 0) // 0 if old version");
fprintf(Outfile,(char*)"%s\n"," Count++;");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," if (Buf[Count][0] != 0) Count++;");
fprintf(Outfile,(char*)"%s\n"," Begin=0;");
fprintf(Outfile,(char*)"%s\n"," if((Flg & 1) == 1) // 1 if true");
fprintf(Outfile,(char*)"%s\n"," strcpy(Buf[Count++],(char*)mid(T,Index,1));");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(strcmp(mid(T,Index,1),Chr34)==0) Quote=!Quote;");
fprintf(Outfile,(char*)"%s\n"," if(Begin==0) Begin=Index;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(Begin)");
fprintf(Outfile,(char*)"%s\n"," strcpy(Buf[Count++],(char*)mid(T,Begin,Index-Begin));");
fprintf(Outfile,(char*)"%s\n"," if((Flg & 1) == 0) // 0 if false");
fprintf(Outfile,(char*)"%s\n"," for(i=0;i<Count;i++) strcpy(Buf[i],(char*)RemoveStr(Buf[i],Chr34));");
fprintf(Outfile,(char*)"%s\n"," return Count;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_DSplit)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int DSplit (PCHAR *Buf, char *T, char *Delim, int Flg)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int Begin=0;");
fprintf(Outfile,(char*)"%s\n"," int Count=0;");
fprintf(Outfile,(char*)"%s\n"," int Quote=0;");
fprintf(Outfile,(char*)"%s\n"," int Index=0;");
fprintf(Outfile,(char*)"%s\n"," int lenT = strlen(T);");
fprintf(Outfile,(char*)"%s\n"," char Chr34[2]={34,0};");
fprintf(Outfile,(char*)"%s\n"," for(Index=1;Index<=lenT;Index++)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(instr_b(Delim,mid(T,Index,1))&&!Quote)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," strcpy(Buf[Count],(char*)mid(T,Begin,Index-Begin));");
fprintf(Outfile,(char*)"%s\n"," if ((Flg & 2) == 0) // 0 if old version");
fprintf(Outfile,(char*)"%s\n"," Count++;");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," if (Buf[Count][0] != 0) Count++;");
fprintf(Outfile,(char*)"%s\n"," Begin=0;");
fprintf(Outfile,(char*)"%s\n"," if((Flg & 1) == 1) // 1 if true");
fprintf(Outfile,(char*)"%s\n"," strcpy(Buf[Count++],(char*)mid(T,Index,1));");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(strcmp(mid(T,Index,1),Chr34)==0) Quote=!Quote;");
fprintf(Outfile,(char*)"%s\n"," if(Begin==0) Begin=Index;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(Begin) strcpy(Buf[Count++],(char*)mid(T,Begin,Index-Begin));");
fprintf(Outfile,(char*)"%s\n"," if((Flg & 1) == 0) // 0 if false");
fprintf(Outfile,(char*)"%s\n"," for(Index=0;Index<Count;Index++) strcpy(Buf[Index],(char*)RemoveStr(Buf[Index],Chr34));");
fprintf(Outfile,(char*)"%s\n"," return Count;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Bin2dec)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Bin2Dec (char *cptr)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int i, j = 0;");
fprintf(Outfile,(char*)"%s%s%s\n"," while(cptr && *cptr && strchr(",enc("01"),", *cptr))");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," i = *cptr++ - '0';");
fprintf(Outfile,(char*)"%s\n"," j <<= 1;");
fprintf(Outfile,(char*)"%s\n"," j |= (i & 0x01);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return(j);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Hex2Dec)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Hex2Dec (char *szInput)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char ch;");
fprintf(Outfile,(char*)"%s\n"," char *dwLen = szInput+strlen(szInput);");
fprintf(Outfile,(char*)"%s\n"," char *LowCase = MakeLCaseTbl();");
fprintf(Outfile,(char*)"%s\n"," DWORD dwOut = 0;");
fprintf(Outfile,(char*)"%s\n"," while(*szInput)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," ch = LowCase[(unsigned char)*szInput++];");
fprintf(Outfile,(char*)"%s\n"," if((ch >= 'a' && ch <= 'f') || (ch >= '0' && ch <= '9'))");
fprintf(Outfile,(char*)"%s\n"," dwOut |=((int)ch - (ch>'9' ? 'a'-10 : '0')) << ((dwLen - szInput) << 2);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return dwOut;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Verify)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Verify (char *Src, char *Allowed)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int i, j;");
fprintf(Outfile,(char*)"%s\n"," for (i=1; i<=strlen(Src); i++)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," j=VerifyInstr(Allowed,mid(Src,i,1));");
fprintf(Outfile,(char*)"%s\n"," if (!j) return 0;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return TRUE;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
fprintf(Outfile,(char*)"%s\n","int VerifyInstr(char* mane,char* match,int offset)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *s;");
fprintf(Outfile,(char*)"%s\n"," if (!mane || !match || !*match || offset>(int)strlen(mane)) return 0;");
fprintf(Outfile,(char*)"%s\n"," s = strstr (offset>0 ? mane+offset-1 : mane,match);");
fprintf(Outfile,(char*)"%s\n"," return s ? (int)(s-mane)+1 : 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Retain)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *Retain (char *Text, char *ValidChars)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *BCX_RetStr=BCX_TmpStr(strlen(Text));");
fprintf(Outfile,(char*)"%s\n"," char *temp=BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n"," while(*Text)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(strchr(ValidChars,*Text)) *(temp++) = *Text;");
fprintf(Outfile,(char*)"%s\n"," Text++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_LoadFile)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* LoadFile (char *N)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," FILE* FP1;");
fprintf(Outfile,(char*)"%s\n"," char* BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n"," if(Exist(N))");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," BCX_RetStr=BCX_TmpStr(lof(N));");
fprintf(Outfile,(char*)"%s%s%s\n"," if((FP1=fopen(N,",enc("rb"),"))!=0)");
fprintf(Outfile,(char*)"%s\n"," GET(FP1,BCX_RetStr,lof(N));");
fprintf(Outfile,(char*)"%s\n"," fclose(FP1);");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," BCX_RetStr=BCX_TmpStr(64);");
fprintf(Outfile,(char*)"%s%s%s\n"," return strcpy(BCX_RetStr,",enc("File Not Found"),");");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Freefile)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","FILE* FreeFile (void)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static FILE *pf;");
fprintf(Outfile,(char*)"%s\n"," if(pf){free(pf);pf=NULL;}");
fprintf(Outfile,(char*)"%s\n"," pf = (FILE*)calloc(sizeof(FILE*),sizeof(FILE*));");
fprintf(Outfile,(char*)"%s\n"," return pf;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Run)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Run (char* Cmdline, int ShowHide, int WaitState)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int processId;");
fprintf(Outfile,(char*)"%s\n"," char *s, *p, *cmd_line;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," cmd_line=(char*)malloc(strlen(Cmdline)+1);");
fprintf(Outfile,(char*)"%s\n"," if(cmd_line==NULL) return -2;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," strcpy(cmd_line, Cmdline);");
fprintf(Outfile,(char*)"%s\n"," p = s = cmd_line;");
fprintf(Outfile,(char*)"%s\n"," processId=fork();");
fprintf(Outfile,(char*)"%s\n"," if(processId==0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," PCHAR argv[30];");
fprintf(Outfile,(char*)"%s\n"," int i=0;");
fprintf(Outfile,(char*)"%s\n"," while(*p)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(*p==34)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," while(*(++p)!=34) {}");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(*p==32)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," while(*(p+1)==32) p++;");
fprintf(Outfile,(char*)"%s\n"," argv[i++]=s;");
fprintf(Outfile,(char*)"%s\n"," *p=0; s=p+1;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," p++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," argv[i] = s;");
fprintf(Outfile,(char*)"%s\n"," argv[i+1]= 0;");
fprintf(Outfile,(char*)"%s\n"," execvp(argv[0],argv);");
fprintf(Outfile,(char*)"%s%s%s\n"," printf(",enc("Failed to run%s\\n"),",argv[0]);");
fprintf(Outfile,(char*)"%s\n"," exit(-1);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," else if(processId!=-1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(WaitState) waitpid(processId,NULL,0);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," waitpid(-1,NULL,WNOHANG);");
fprintf(Outfile,(char*)"%s\n"," free(cmd_line), cmd_line=NULL;");
fprintf(Outfile,(char*)"%s\n"," return processId;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Download)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int Download (char *URL,char *Localname)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int RetVal;");
fprintf(Outfile,(char*)"%s\n"," return RetVal=!RetVal;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_PeekStr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *peekstr (LPVOID Src, int Count)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *Des=BCX_TmpStr(Count);");
fprintf(Outfile,(char*)"%s\n"," memmove(Des,Src,Count);");
fprintf(Outfile,(char*)"%s\n"," return Des;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_QBColor)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int qbcolor (int N)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," switch (N)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," case 0 : return RGB(0,0,0);");
fprintf(Outfile,(char*)"%s\n"," case 1 : return RGB(0,0,128);");
fprintf(Outfile,(char*)"%s\n"," case 2 : return RGB(0,128,0);");
fprintf(Outfile,(char*)"%s\n"," case 3 : return RGB(0,128,128);");
fprintf(Outfile,(char*)"%s\n"," case 4 : return RGB(196,0,0);");
fprintf(Outfile,(char*)"%s\n"," case 5 : return RGB(128,0,128);");
fprintf(Outfile,(char*)"%s\n"," case 6 : return RGB(128,64,0);");
fprintf(Outfile,(char*)"%s\n"," case 7 : return RGB(196,196,196);");
fprintf(Outfile,(char*)"%s\n"," case 8 : return RGB(128,128,128);");
fprintf(Outfile,(char*)"%s\n"," case 9 : return RGB(0,0, 255);");
fprintf(Outfile,(char*)"%s\n"," case 10 : return RGB(0,255,0);");
fprintf(Outfile,(char*)"%s\n"," case 11 : return RGB(0,255,255);");
fprintf(Outfile,(char*)"%s\n"," case 12 : return RGB(255,0,0);");
fprintf(Outfile,(char*)"%s\n"," case 13 : return RGB(255,0,255);");
fprintf(Outfile,(char*)"%s\n"," case 14 : return RGB(255,255,0);");
fprintf(Outfile,(char*)"%s\n"," case 15 : return RGB(255,255,255);");
fprintf(Outfile,(char*)"%s\n"," case 16 : return RGB(164,164,164);");
fprintf(Outfile,(char*)"%s\n"," case 17 : return RGB(128,160,255);");
fprintf(Outfile,(char*)"%s\n"," case 18 : return RGB(160,255,160);");
fprintf(Outfile,(char*)"%s\n"," case 19 : return RGB(160,255,255);");
fprintf(Outfile,(char*)"%s\n"," case 20 : return RGB(255,160,160);");
fprintf(Outfile,(char*)"%s\n"," case 21 : return RGB(255,160,255);");
fprintf(Outfile,(char*)"%s\n"," case 22 : return RGB(255,255,160);");
fprintf(Outfile,(char*)"%s\n"," case 23 : return RGB(212,212,212);");
fprintf(Outfile,(char*)"%s\n"," case 24 : return RGB(180,180,180);");
fprintf(Outfile,(char*)"%s\n"," case 25 : return RGB(188,220,255);");
fprintf(Outfile,(char*)"%s\n"," case 26 : return RGB(220,255,220);");
fprintf(Outfile,(char*)"%s\n"," case 27 : return RGB(220,255,255);");
fprintf(Outfile,(char*)"%s\n"," case 28 : return RGB(255,220,220);");
fprintf(Outfile,(char*)"%s\n"," case 29 : return RGB(255,220,255);");
fprintf(Outfile,(char*)"%s\n"," case 30 : return RGB(255,255,220);");
fprintf(Outfile,(char*)"%s\n"," case 31 : return RGB(228,228,228);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","return 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cvi)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","short CVI (char *s)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return ((short*)s)[0];");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mki)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *MKI (short cvt)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static char temp[3];");
fprintf(Outfile,(char*)"%s\n"," return (char *)memmove(temp,&cvt,2);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cvl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","long CVL (char *s)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return ((long*)s)[0];");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mkl)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *MKL (int cvt)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static char temp[5];");
fprintf(Outfile,(char*)"%s\n"," return (char *) memmove(temp,&cvt,4);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cvs)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","float CVS (char *s)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return ((float*)s)[0];");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mks)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *MKS (float cvt)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static char temp[5];");
fprintf(Outfile,(char*)"%s\n"," return (char *) memmove(temp,&cvt,4);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cvd)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","double CVD (char *s)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return ((double*)s)[0];");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Cvld)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","long double CVLD (char *s)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return ((long double*)s)[0];");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mkd)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *MKD (double cvt)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static char temp[9];");
fprintf(Outfile,(char*)"%s\n"," return (char *) memmove(temp,&cvt,8);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Mkld)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *MKLD (long double cvt)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static char temp[11];");
fprintf(Outfile,(char*)"%s\n"," return (char *) memmove(temp,&cvt,10);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_BcxSplitPath)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *BcxSplitPath (char *FPath, int mask)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," if(!FPath) return BCX_TmpStr(1);");
fprintf(Outfile,(char*)"%s\n"," char *BCX_RetStr=BCX_TmpStr(strlen(FPath));");
fprintf(Outfile,(char*)"%s\n"," char tmp[MAX_PATH*4];");
fprintf(Outfile,(char*)"%s\n"," _splitpath_(FPath,tmp,&tmp[MAX_PATH],&tmp[MAX_PATH*2],&tmp[MAX_PATH*3]);");
fprintf(Outfile,(char*)"%s\n"," if(mask & FDRV) strcat(BCX_RetStr,tmp);");
fprintf(Outfile,(char*)"%s\n"," if(mask & FPATH)strcat(BCX_RetStr,&tmp[MAX_PATH]);");
fprintf(Outfile,(char*)"%s\n"," if(mask & FNAME)strcat(BCX_RetStr,&tmp[MAX_PATH*2]);");
fprintf(Outfile,(char*)"%s\n"," if(mask & FEXT) strcat(BCX_RetStr,&tmp[MAX_PATH*3]);");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
fprintf(Outfile,(char*)"%s\n"," void _splitpath_(const char* path, char* drv, char* dir, char* name, char* ext)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," const char* pend; /* end of processed string */");
fprintf(Outfile,(char*)"%s\n"," const char* p; /* search pointer */");
fprintf(Outfile,(char*)"%s\n"," const char* s; /* copy pointer */");
fprintf(Outfile,(char*)"%s\n"," ");
fprintf(Outfile,(char*)"%s\n"," /* extract drive name */");
fprintf(Outfile,(char*)"%s\n"," if (path[0] && path[1]==':') {");
fprintf(Outfile,(char*)"%s\n"," if (drv) {");
fprintf(Outfile,(char*)"%s\n"," *drv++ = *path++;");
fprintf(Outfile,(char*)"%s\n"," *drv++ = *path++;");
fprintf(Outfile,(char*)"%s\n"," *drv = 0;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," } else if (drv)");
fprintf(Outfile,(char*)"%s\n"," *drv = 0;");
fprintf(Outfile,(char*)"%s\n"," ");
fprintf(Outfile,(char*)"%s\n"," /* search for end of string or stream separator */");
fprintf(Outfile,(char*)"%s\n"," for(pend=path; *pend && *pend!=':'; )");
fprintf(Outfile,(char*)"%s\n"," pend++;");
fprintf(Outfile,(char*)"%s\n"," ");
fprintf(Outfile,(char*)"%s\n"," /* search for begin of file extension */");
fprintf(Outfile,(char*)"%s\n"," for(p=pend; p > path && *--p != '\\\\' && *p!='/'; )");
fprintf(Outfile,(char*)"%s\n"," if (*p == '.') {");
fprintf(Outfile,(char*)"%s\n"," pend = p;");
fprintf(Outfile,(char*)"%s\n"," break;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," ");
fprintf(Outfile,(char*)"%s\n"," if (ext)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," s=pend;");
fprintf(Outfile,(char*)"%s\n"," do{ *ext++ = *s; } while(*s++);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," /* search for end of directory name */");
fprintf(Outfile,(char*)"%s\n"," for(p=pend; p > path; )");
fprintf(Outfile,(char*)"%s\n"," if (*--p == '\\\\' || *p == '/') {");
fprintf(Outfile,(char*)"%s\n"," p++;");
fprintf(Outfile,(char*)"%s\n"," break;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," ");
fprintf(Outfile,(char*)"%s\n"," if (name) {");
fprintf(Outfile,(char*)"%s\n"," for(s=p; s<pend; )");
fprintf(Outfile,(char*)"%s\n"," *name++ = *s++;");
fprintf(Outfile,(char*)"%s\n"," ");
fprintf(Outfile,(char*)"%s\n"," *name = 0;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," ");
fprintf(Outfile,(char*)"%s\n"," if (dir) {");
fprintf(Outfile,(char*)"%s\n"," for(s=path; s<p; )");
fprintf(Outfile,(char*)"%s\n"," *dir++ = *s++;");
fprintf(Outfile,(char*)"%s\n"," ");
fprintf(Outfile,(char*)"%s\n"," *dir = 0;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_StrUpLow)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *_strupr_(char *string)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *s;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (string)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," for(s = string; *s; ++s)");
fprintf(Outfile,(char*)"%s\n"," *s = toupper(*s);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return string;");
fprintf(Outfile,(char*)"%s\n","}\n");
fprintf(Outfile,(char*)"%s\n","char *_strlwr_(char *string)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *s;");
fprintf(Outfile,(char*)"%s\n","");
fprintf(Outfile,(char*)"%s\n"," if (string)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," for (s = string; *s; ++s)");
fprintf(Outfile,(char*)"%s\n"," *s = tolower(*s);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return string;");
fprintf(Outfile,(char*)"%s\n","}\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Strtoken)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char * StrToken (char *Source, char *TokenChar, int n)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *BCX_RetStr={0};");
fprintf(Outfile,(char*)"%s\n"," char *RetVal;");
fprintf(Outfile,(char*)"%s\n"," char *Copy;");
fprintf(Outfile,(char*)"%s\n"," int Posn=0;");
fprintf(Outfile,(char*)"%s\n"," int Find=0;");
fprintf(Outfile,(char*)"%s\n"," int LenSrc=strlen(Source);");
fprintf(Outfile,(char*)"%s\n"," RetVal=(char*)calloc(LenSrc+1,1);");
fprintf(Outfile,(char*)"%s\n"," Copy=Source;");
fprintf(Outfile,(char*)"%s\n"," if(tally(Source,TokenChar)==0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," BCX_RetStr=BCX_TmpStr(1);");
fprintf(Outfile,(char*)"%s\n"," if(RetVal)free(RetVal);");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(n==1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," BCX_RetStr=BCX_TmpStr(LenSrc);");
fprintf(Outfile,(char*)"%s\n"," strcpy(BCX_RetStr,(char*)extract(Source,TokenChar));");
fprintf(Outfile,(char*)"%s\n"," if(RetVal)free(RetVal);");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(n>tally(Source,TokenChar)+1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," BCX_RetStr=BCX_TmpStr(1);");
fprintf(Outfile,(char*)"%s\n"," if(RetVal)free(RetVal);");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," while(*Copy)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(*Copy==TokenChar[0]) Find++;");
fprintf(Outfile,(char*)"%s\n"," if(Find==n) break;");
fprintf(Outfile,(char*)"%s\n"," Copy++;");
fprintf(Outfile,(char*)"%s\n"," Posn++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(n==tally(Source,TokenChar)+1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," Posn=LenSrc;");
fprintf(Outfile,(char*)"%s\n"," Copy=Source+Posn;");
fprintf(Outfile,(char*)"%s\n"," while(*Copy&&Source[Posn]!=TokenChar[0])");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," Posn--;");
fprintf(Outfile,(char*)"%s\n"," Copy--;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," strcpy(RetVal,(char*)mid(Source,1,Posn));");
fprintf(Outfile,(char*)"%s\n"," strcpy(RetVal,(char*)mid(RetVal,InstrRev(RetVal,TokenChar)));");
fprintf(Outfile,(char*)"%s\n"," BCX_RetStr=BCX_TmpStr(LenSrc);");
fprintf(Outfile,(char*)"%s\n"," strcpy(BCX_RetStr,(char*)RemoveStr(RetVal,TokenChar));");
fprintf(Outfile,(char*)"%s\n"," if(RetVal)free(RetVal);");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_iReplace)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char *iReplace (char *src, char *pat, char *rep)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," size_t patsz, repsz, tmpsz, delta;");
fprintf(Outfile,(char*)"%s\n"," char *strtmp, *p, *q, *r;");
fprintf(Outfile,(char*)"%s\n"," if (!pat || !*pat)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," strtmp = BCX_TmpStr(strlen(src));");
fprintf(Outfile,(char*)"%s\n"," if (!strtmp) return NULL;");
fprintf(Outfile,(char*)"%s\n"," return strcpy(strtmp, src);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," repsz = strlen(rep);");
fprintf(Outfile,(char*)"%s\n"," patsz = strlen(pat);");
fprintf(Outfile,(char*)"%s\n"," for (tmpsz=0, p=src;(q=_stristr_(p,pat))!=0; p=q+patsz)");
fprintf(Outfile,(char*)"%s\n"," tmpsz += (size_t) (q - p) + repsz;");
fprintf(Outfile,(char*)"%s\n"," tmpsz += strlen(p);");
fprintf(Outfile,(char*)"%s\n"," strtmp = BCX_TmpStr(tmpsz);");
fprintf(Outfile,(char*)"%s\n"," if (!strtmp) return NULL;");
fprintf(Outfile,(char*)"%s\n"," for (r=strtmp,p=src;(q=_stristr_(p,pat))!=0;p=q+patsz)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," delta = (size_t) (q-p);");
fprintf(Outfile,(char*)"%s\n"," memcpy(r,p,delta); r += delta;");
fprintf(Outfile,(char*)"%s\n"," strcpy(r,rep); r += repsz;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," strcpy(r,p);");
fprintf(Outfile,(char*)"%s\n"," return strtmp;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_WideToAnsi)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","char* WideToAnsi (wchar_t *WideStr, UINT CodePage,DWORD dwFlags)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," char *BCX_RetStr={0};");
fprintf(Outfile,(char*)"%s\n"," UINT uLen;");
fprintf(Outfile,(char*)"%s\n"," uLen=wcstombs(NULL, WideStr, 0); //WideCharToMultiByte(CodePage,dwFlags,WideStr,-1,0,0,0,0);");
fprintf(Outfile,(char*)"%s\n"," BCX_RetStr=(char*)BCX_TmpStr(uLen);");
fprintf(Outfile,(char*)"%s\n"," wcstombs(BCX_RetStr, WideStr, uLen); //WideCharToMultiByte(CodePage,dwFlags,WideStr,-1,BCX_RetStr,uLen,0,0);");
fprintf(Outfile,(char*)"%s\n"," return BCX_RetStr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_SysStr)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","BSTR SysStr (char * szIn, int widstr, int bfree)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static BSTR bStr[32];");
fprintf(Outfile,(char*)"%s\n"," static int index;");
fprintf(Outfile,(char*)"%s\n"," if(bfree)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," for(index=0; index<32; index+=1) ");
fprintf(Outfile,(char*)"%s\n"," SysFreeString(bStr[index]);");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," index=(++index & 31);");
fprintf(Outfile,(char*)"%s\n"," SysFreeString(bStr[index]);");
fprintf(Outfile,(char*)"%s\n"," int length=strlen(szIn);");
fprintf(Outfile,(char*)"%s\n"," if(widstr)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," bStr[index]=SysAllocStringLen(NULL, (2*length));");
fprintf(Outfile,(char*)"%s\n"," MultiByteToWideChar(CP_ACP,0,szIn,-1,bStr[index],(2*length+1));");
fprintf(Outfile,(char*)"%s\n"," }else{");
fprintf(Outfile,(char*)"%s\n"," bStr[index]=SysAllocStringByteLen(szIn, length);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return bStr[index];");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_AnsiToWide)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","wchar_t *AnsiToWide (char *AnsiStr, UINT CodePage,DWORD dwFlags)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," UINT uLen;");
fprintf(Outfile,(char*)"%s\n"," wchar_t *WideStr;");
fprintf(Outfile,(char*)"%s\n"," uLen=mbstowcs(NULL, AnsiStr, 0); //MultiByteToWideChar(CodePage,dwFlags,AnsiStr,-1,0,0);");
fprintf(Outfile,(char*)"%s\n"," if(uLen<=1) return (wchar_t*)BCX_TmpStr(2);");
fprintf(Outfile,(char*)"%s\n"," WideStr = (wchar_t*)BCX_TmpStr(2*uLen);");
fprintf(Outfile,(char*)"%s\n"," mbstowcs(WideStr, AnsiStr, uLen); //MultiByteToWideChar(CodePage,dwFlags,AnsiStr,uLen,WideStr,uLen);");
fprintf(Outfile,(char*)"%s\n"," return WideStr;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_FileLocked)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int FileLocked (char *Filename)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s%s%s\n"," FILE *FP=fopen(Filename,",enc("rb+"),");");
fprintf(Outfile,(char*)"%s\n"," if(FP==0) return 1;");
fprintf(Outfile,(char*)"%s\n"," fclose(FP);");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_ContainedIn)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int containedin(char * Token,char **Contain ,int c)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," int i=0;");
fprintf(Outfile,(char*)"%s\n"," while(Contain[i][0])");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if(0 == ((c == 0 || c == 2) ? strcmp(Contain[i],Token) : strcasecmp(Contain[i],Token)))");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," return ((c < 2) ? 0 : i);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," i++;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return -1;");
fprintf(Outfile,(char*)"%s\n"," }\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_FindInType)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int FindInType(char *Token,char *StOffset,int StSize,int start,int finish,int c,int *idx)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," int j;");
fprintf(Outfile,(char*)"%s\n"," char *Srch;");
fprintf(Outfile,(char*)"%s\n"," int (*cmp)(const char*,const char*);");
fprintf(Outfile,(char*)"%s\n"," cmp = ((c == 0 || c == 2) ? strcmp : strcasecmp);");
fprintf(Outfile,(char*)"%s\n"," for(j=start; j<=finish; j++)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," Srch = StOffset + ((idx==0) ? j*StSize : idx[j]*StSize);");
fprintf(Outfile,(char*)"%s\n"," if(cmp(Srch,Token)==0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," return ((c < 2) ? 0 : j);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return -1;");
fprintf(Outfile,(char*)"%s\n"," }\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_StartupCode)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int BCX_StartupCode_(void)");
fprintf(Outfile,(char*)"%s\n","{");
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(i=1; i<=StartNdx; i+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n"," ",StartSub[i],"();");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n"," return 1;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_ExitCode)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","int BCX_ExitCode_(void)");
fprintf(Outfile,(char*)"%s\n","{");
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int i;
Initial Code Commit
2022-07-28 18:29:51 +00:00
for(i=1; i<=ExitNdx; i+=1)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s\n"," atexit(",ExitSub[i],");");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n"," return 1;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_Socket)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","sockaddr_in sock_addr (char *ServerName,int port)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," in_addr iaHost;");
fprintf(Outfile,(char*)"%s\n"," hostent* lpHostEntry;");
fprintf(Outfile,(char*)"%s\n"," sockaddr_in saServer;");
fprintf(Outfile,(char*)"%s\n"," iaHost.s_addr=inet_addr(ServerName);");
fprintf(Outfile,(char*)"%s\n"," if(iaHost.s_addr==INADDR_NONE)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," lpHostEntry=gethostbyname(ServerName);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," lpHostEntry=gethostbyaddr((char*)&iaHost,sizeof(in_addr),AF_INET);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," if(lpHostEntry==NULL)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s%s%s\n"," printf(",enc("Error! HOST NOT FOUND: %s\\n"),", ServerName);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," saServer.sin_port=htons(port);");
fprintf(Outfile,(char*)"%s\n"," saServer.sin_family=AF_INET;");
fprintf(Outfile,(char*)"%s\n"," saServer.sin_addr=*(in_addr*)lpHostEntry->h_addr;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return saServer;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
fprintf(Outfile,(char*)"%s\n","int connect_socket (sockaddr_in saServer)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," int Socket, nRet;");
fprintf(Outfile,(char*)"%s\n"," Socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);");
fprintf(Outfile,(char*)"%s\n"," if(Socket==-1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," return Socket;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," nRet=connect(Socket,(sockaddr*)&saServer,sizeof(sockaddr_in));");
fprintf(Outfile,(char*)"%s\n"," if(nRet==-1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," close(Socket);");
fprintf(Outfile,(char*)"%s\n"," return nRet;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return Socket;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
fprintf(Outfile,(char*)"%s\n","int BcxSocket (char *ServerName,int port)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," sockaddr_in saServer;");
fprintf(Outfile,(char*)"%s\n"," saServer=sock_addr(ServerName,port);");
fprintf(Outfile,(char*)"%s\n"," return connect_socket(saServer);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
fprintf(Outfile,(char*)"%s\n","int BcxSocketSend (int Socket, char *szBuffer)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static int nRet;");
fprintf(Outfile,(char*)"%s\n"," nRet=send(Socket,szBuffer,strlen(szBuffer),0);");
fprintf(Outfile,(char*)"%s\n"," if(nRet==-1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," close(Socket);");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," return nRet;");
fprintf(Outfile,(char*)"%s\n","}\n\n");
fprintf(Outfile,(char*)"%s\n","int BcxSocketRead (int Socket, char *szBuffer)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," return read(Socket,szBuffer,strlen(szBuffer));");
fprintf(Outfile,(char*)"%s\n","}\n\n");
fprintf(Outfile,(char*)"%s\n","void BcxSocketClose(int Socket) {");
fprintf(Outfile,(char*)"%s\n"," close(Socket);");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
if(Use_RegEx)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s\n","bool regmatch (char *buffer, char *pattern, REGEX* retval)");
fprintf(Outfile,(char*)"%s\n","{");
fprintf(Outfile,(char*)"%s\n"," static int t;");
fprintf(Outfile,(char*)"%s\n"," static int i;");
fprintf(Outfile,(char*)"%s\n"," static regex_t re;");
fprintf(Outfile,(char*)"%s\n"," t=regcomp( &re,pattern,REG_ICASE|REG_EXTENDED);");
fprintf(Outfile,(char*)"%s\n"," if(t)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," regerror(t, &re,buffer,sizeof(buffer));");
fprintf(Outfile,(char*)"%s%s%s\n"," printf(",enc("regex error: %s %s"),",buffer,pattern);");
fprintf(Outfile,(char*)"%s\n"," return 0;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," t=regexec( &re,buffer,1023,(*retval).matches,0);");
fprintf(Outfile,(char*)"%s\n"," (*retval).count=re.re_nsub;");
fprintf(Outfile,(char*)"%s\n"," if(!t)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," for(i=1; i<=(*retval).count; i+=1)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," if((*retval).matches[i].rm_so>=0)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," (*retval).results[i]=peekstr( &buffer[(*retval).matches[i].rm_so],((*retval).matches[i].rm_eo-(*retval).matches[i].rm_so));");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," regfree( &re);");
fprintf(Outfile,(char*)"%s\n"," if(!t)");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," return TRUE;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n"," else");
fprintf(Outfile,(char*)"%s\n"," {");
fprintf(Outfile,(char*)"%s\n"," return FALSE;");
fprintf(Outfile,(char*)"%s\n"," }");
fprintf(Outfile,(char*)"%s\n","}\n\n");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
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--;
}
Fixes applied to address C++17 warnings. See section in mbc4.bas for details
2022-07-28 19:40:08 +00:00
{int BCX_REPEAT;
Initial Code Commit
2022-07-28 18:29:51 +00:00
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);
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fpdef,(char*)"%s%s\n","LIBRARY ",enc(fname));
fprintf(fpdef,(char*)"%s\n","EXPORTS");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(fpdef,(char*)"%s%s%s%s%s\n",funcname," = _",funcname,"@",ltrim(str(sz)));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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;
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s",Scoot,CondType,"(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
Tmp=2;
while(str_cmp(Stk[Tmp],"(")==0 || str_cmp(Stk[Tmp],"!")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Stk[Tmp]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","str_cmp(");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
*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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s",szTest,Stk[Tmp]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
*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
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[Tmp]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
TestString=FALSE;
goto NXTTOKEN;
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[Tmp]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
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;
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[Tmp]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
goto NXTTOKEN;
}
}
if(str_cmp(Stk[Tmp],"!")==0)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Stk[Tmp]);
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
else
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s",Clean(Stk[Tmp]));
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s","=");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
}
}
}
NXTTOKEN:;
Tmp++;
if(!IsWhile)
{
if(iMatchWrd(Stk[Tmp],"then"))
{
break;
}
else if(Tmp>Ndx)
{
Abort("If Without THEN");
}
}
if(Tmp>Ndx)
{
break;
}
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",szTest,")");
Initial Code Commit
2022-07-28 18:29:51 +00:00
BumpUp();
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s\n",Scoot,"{");
Initial Code Commit
2022-07-28 18:29:51 +00:00
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,"@"));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Storage,"FILE *",P,VarName,VarDim,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(A==vt_UDT||A==vt_STRUCT||A==vt_UNION)
{
strcpy(VAR,TypeDefs[GlobalVars[idx].VarDef].VarName);
strcpy(VAR,rpad(VAR,7));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(A==vt_BOOL)
{
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s\n",Storage,"bool ",VarName,VarDim,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(A==vt_STRVAR)
{
if(VarDim[0]==0)
{
strcpy(VarDim,"[65535]");
}
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s\n",Storage,"char ",P,VarName,VarDim,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
break;
}
if(A>=vt_VarMin&&A<=vt_VarMax)
{
strcpy(VAR,GetVarTypeName(GlobalVars[idx].VarType));
strcpy(VAR,rpad(VAR,7));
Began addressing -Wwrite-strings warnings
2022-07-30 02:44:10 +00:00
fprintf(Outfile,(char*)"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
Initial Code Commit
2022-07-28 18:29:51 +00:00
}
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);
}
Reference in New Issue Copy Permalink