You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
20628 lines
602 KiB
20628 lines
602 KiB
// *********************************************************************
|
|
// Created with MBC (V) 4.0-Beta4 (2022/07/26)Ported to OSX by Armando Rivera
|
|
// Ported from BCX32 BASIC To C/C++ Translator (V) 5.12
|
|
// BCX (c) 1999 - 2018 by Kevin Diggins
|
|
// LinuxBC (c) 2009 by Mike Henning
|
|
// MBC (c) 2009 - 2018 by Armando Rivera
|
|
// *********************************************************************
|
|
// Translated for compiling with the g++ Compiler
|
|
// g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$.cc -ldl -o $FILE$
|
|
// *********************************************************************
|
|
#include <stdbool.h>
|
|
#include <ctype.h>
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <string.h>
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <setjmp.h>
|
|
#include <time.h>
|
|
#include <stdarg.h>
|
|
#include <dirent.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
#include <dlfcn.h>
|
|
|
|
|
|
// ***************************************************
|
|
// Compiler Defines
|
|
// ***************************************************
|
|
#define C_EXPORT extern "C"
|
|
#define C_IMPORT extern "C"
|
|
|
|
#ifndef stat
|
|
#define lstat stat
|
|
#endif
|
|
#ifndef _fcloseall
|
|
#define _fcloseall _fcloseall
|
|
#endif
|
|
#ifndef HWND
|
|
#define HWND GHWND
|
|
#endif
|
|
#ifndef MAX_PATH
|
|
#define MAX_PATH 2048
|
|
#endif
|
|
#ifndef CALLBACK
|
|
#define CALLBACK
|
|
#endif
|
|
typedef unsigned int HINSTANCE;
|
|
typedef void* LPVOID;
|
|
typedef char* PCHAR;
|
|
typedef unsigned char BYTE;
|
|
typedef unsigned int UINT;
|
|
typedef unsigned char UCHAR;
|
|
typedef unsigned char* PUCHAR;
|
|
typedef unsigned long ULONG;
|
|
typedef unsigned long* ULONG_PTR;
|
|
typedef unsigned long DWORD;
|
|
|
|
#ifndef TRUE
|
|
#define TRUE 1
|
|
#endif
|
|
|
|
#ifndef FALSE
|
|
#define FALSE 0
|
|
#endif
|
|
#define BOOL bool
|
|
|
|
// ***************************************************
|
|
|
|
typedef long (*CPP_FARPROC)(char *);
|
|
|
|
|
|
// *************************************************
|
|
// User Defined Constants
|
|
// *************************************************
|
|
|
|
#define Version "4.0-Beta4 (2022/07/26)"
|
|
#define __BCX__ 1
|
|
#define vt_VarMin 2
|
|
#define vt_VarMax vt_VARIANT
|
|
#define fprintf ReDirectFPrint
|
|
#define MaxElements 128
|
|
#define MaxTypes 512
|
|
#define MaxLocalVars 512
|
|
#define MaxGlobalVars 4096
|
|
#define MaxLib 64
|
|
#define c_SglQt 39
|
|
#define c_DblQt 34
|
|
#define c_LPar 40
|
|
#define c_RPar 41
|
|
#define c_Komma 44
|
|
#define c_LtBkt 91
|
|
#define c_RtBkt 93
|
|
#define BCX_STR_RUNTIME "Runtime Functions"
|
|
#define BCX_STR_MAIN_PROG "Main Program"
|
|
#define BCX_STR_SYS_VARS "System Variables"
|
|
#define BCX_STR_STD_MACROS "Standard Macros"
|
|
#define BCX_STR_STD_PROTOS "Standard Prototypes"
|
|
#define BCX_STR_USR_PROCS "User Subs and Functions"
|
|
#define BCX_STR_USR_VARS "User Global Variables"
|
|
#define BCX_STR_USR_PROTOS "User Prototypes"
|
|
#define BCX_STR_USR_CONST "User Defined Constants"
|
|
#define BCX_STR_USR_TYPES "User Defined Types, Classes (CPP Mode), And Unions"
|
|
#define FUNCTIONPARSE_CLASS struct _FUNCTIONPARSE*
|
|
#define VarTypes "%$#!@¦"
|
|
#define ARGTYPE_CLASS struct _ARGTYPE*
|
|
#define PROTOSTORE_CLASS struct _PROTOSTORE*
|
|
#define ELEMENT_CLASS struct _ELEMENT*
|
|
#define USERTYPEDEFS_CLASS struct _USERTYPEDEFS*
|
|
#define VARINFO_CLASS struct _VARINFO*
|
|
#define VARCODE_CLASS struct _VARCODE*
|
|
#define iMatchLft(A,B) iMatch (A ,B ,0)
|
|
#define iMatchWrd(A,B) iMatch (A ,B ,1)
|
|
#define iMatchRgt(A,B) iMatch (A ,B ,2)
|
|
// *************************************************
|
|
// User's GLOBAL ENUM blocks
|
|
// *************************************************
|
|
|
|
enum
|
|
{
|
|
vt_UNKNOWN,
|
|
vt_STRLIT,
|
|
vt_INTEGER,
|
|
vt_SINGLE,
|
|
vt_DOUBLE,
|
|
vt_LDOUBLE,
|
|
VT_LLONG,
|
|
vt_STRVAR,
|
|
vt_DECFUNC,
|
|
vt_NUMBER,
|
|
vt_FILEPTR,
|
|
vt_UDT,
|
|
vt_STRUCT,
|
|
vt_UNION,
|
|
vt_BOOL,
|
|
vt_CHAR,
|
|
vt_LPSTRPTR,
|
|
vt_PCHAR,
|
|
vt_CHARPTR,
|
|
vt_VOID,
|
|
vt_LONG,
|
|
vt_DWORD,
|
|
vt_FARPROC,
|
|
vt_LPBYTE,
|
|
vt_LRESULT,
|
|
vt_BYTE,
|
|
vt_SHORT,
|
|
vt_USHORT,
|
|
vt_UINT,
|
|
vt_ULONG,
|
|
vt_HWND,
|
|
vt_HDC,
|
|
vt_COLORREF,
|
|
vt_HANDLE,
|
|
vt_HINSTANCE,
|
|
vt_WNDCLASSEX,
|
|
vt_HFONT,
|
|
vt_VARIANT
|
|
};
|
|
|
|
|
|
enum
|
|
{
|
|
mt_ProcessSetCommand,
|
|
mt_FuncSubDecC_Dec,
|
|
mt_FuncSubDecC_Dec2,
|
|
mt_Opts,
|
|
mt_Opts2,
|
|
mt_Opts3,
|
|
mt_OverLoad,
|
|
mt_OverLoad2,
|
|
mt_FuncSubx1,
|
|
mt_FuncSubx2
|
|
};
|
|
|
|
|
|
|
|
// *************************************************
|
|
// User Defined Types, Classes (CPP Mode), And Unions
|
|
// *************************************************
|
|
|
|
typedef struct _functionParse
|
|
{
|
|
int NumArgs;
|
|
int CommaPos[128];
|
|
}functionParse, *LPFUNCTIONPARSE;
|
|
|
|
|
|
typedef struct _ARGTYPE
|
|
{
|
|
char Arg[2048];
|
|
int ArgType;
|
|
}ARGTYPE, *LPARGTYPE;
|
|
|
|
|
|
typedef struct _ProtoStore
|
|
{
|
|
char Prototype[2048];
|
|
char Condition[512];
|
|
int CondLevel;
|
|
}ProtoStore, *LPPROTOSTORE;
|
|
|
|
|
|
typedef struct _Element
|
|
{
|
|
int ElementType;
|
|
int ElementID;
|
|
int ElementDynaPtr;
|
|
char ElementName[64];
|
|
}Element, *LPELEMENT;
|
|
|
|
|
|
typedef struct _UserTypeDefs
|
|
{
|
|
int TypeofDef;
|
|
int EleCnt;
|
|
struct _Element Elements[MaxElements];
|
|
char VarName[64];
|
|
}UserTypeDefs, *LPUSERTYPEDEFS;
|
|
|
|
|
|
typedef struct _VarInfo
|
|
{
|
|
int VarLine;
|
|
int VarType;
|
|
int VarDef;
|
|
int VarPntr;
|
|
int VarSF;
|
|
int VarExtn;
|
|
int VarCondLevel;
|
|
int VarEmitFlag;
|
|
int VarConstant;
|
|
char VarName[64];
|
|
char VarDim[128];
|
|
char VarModule[300];
|
|
char VarCondDef[128];
|
|
}VarInfo, *LPVARINFO;
|
|
|
|
|
|
typedef struct _VARCODE
|
|
{
|
|
int VarNo;
|
|
int Method;
|
|
int IsPtrFlag;
|
|
char Header[2048];
|
|
char Proto[2048];
|
|
char Functype[2048];
|
|
char StaticOut[2048];
|
|
char Token[2048];
|
|
char AsToken[2048];
|
|
}VARCODE, *LPVARCODE;
|
|
|
|
|
|
// *************************************************
|
|
// System Variables
|
|
// *************************************************
|
|
|
|
char TAB [2]={9,0}; // Horz Tab
|
|
char LF [2]={10,0}; // Line Feed
|
|
char ESC [2]={27,0}; // Escape
|
|
char SPC [2]={32,0}; // Space
|
|
char DQ [2]={34,0}; // Double-Quote
|
|
char DDQ [3]={34,34,0}; // Double-Double-Quote
|
|
char CRLF[3]={13,10,0}; // Carr Rtn & Line Feed
|
|
char *AR_fgets_retval;
|
|
|
|
// *************************************************
|
|
// User Global Variables
|
|
// *************************************************
|
|
|
|
static PCHAR *G_argv;
|
|
static int G_argc;
|
|
static int NoRT;
|
|
static int ByrefCnt;
|
|
static char CurLine[65535];
|
|
static int gLinesWritten;
|
|
static int LoopLocalCnt;
|
|
static int GlobalVarCnt;
|
|
static int TypeDefsCnt;
|
|
static int LocalVarCnt;
|
|
static int LocalDynArrCount;
|
|
static int LocalDynaCnt;
|
|
static int GlobalDynaCnt;
|
|
static int ModuleNdx;
|
|
static int FPtrNdx;
|
|
static int SplitCnt;
|
|
static int SplitCur;
|
|
static char SrcTmp[65535];
|
|
static int StartNdx;
|
|
static int ExitNdx;
|
|
static VARCODE VarCode;
|
|
static int UmQt;
|
|
static char LD_FLAGS[65535];
|
|
static char Accelerator[65535];
|
|
static char CallType[65535];
|
|
static int CaseFlag;
|
|
static char CaseVar[65535];
|
|
static char Cmd[65535];
|
|
static char Compiler[65535];
|
|
static char CmdLineConst[65535];
|
|
static char CmdLineFileOut[65535];
|
|
static int CurrentFuncType;
|
|
static char DimType[65535];
|
|
static int DllCnt;
|
|
static int LoadLibsCnt;
|
|
static float Elapsed;
|
|
static int EndOfProgram;
|
|
static int EntryCnt;
|
|
static int ErrFile;
|
|
static char szFile[65535];
|
|
static char Filnam[65535];
|
|
static int ForceMainToFunc;
|
|
static char Funcname[65535];
|
|
static char Handl[65535];
|
|
static int HFileCnt;
|
|
static char HFile[65535];
|
|
static int InConditional;
|
|
static char InIfDef[65535];
|
|
static int Indent;
|
|
static int InFunc;
|
|
static int InMain;
|
|
static int IsCallBack;
|
|
static int TurboSize;
|
|
static int UseCProto;
|
|
static int InTypeDef;
|
|
static int IsAuto;
|
|
static int NoTypeDeclare;
|
|
static int IsDim;
|
|
static int IsExported;
|
|
static int IsRegister;
|
|
static int IsStatic;
|
|
static int IsStdFunc;
|
|
static int IsLocal;
|
|
static int IsRaw;
|
|
static int IsApple;
|
|
static int KillCFile;
|
|
static char Keyword1[65535];
|
|
static int LastCmd;
|
|
static int LinesRead;
|
|
static char Linker[65535];
|
|
static char Lookup[65535];
|
|
static int MakeDLL;
|
|
static int Ndx;
|
|
static int NoMain;
|
|
static int NoDllMain;
|
|
static int OkayToSend;
|
|
static char Op[65535];
|
|
static int OptionBase;
|
|
static char OutfileClone[65535];
|
|
static int PassOne;
|
|
static int ProtoCnt;
|
|
static int Pusher;
|
|
static int Quiet;
|
|
static int ReDirect;
|
|
static FILE *SaveOutfileNum;
|
|
static char Scoot[65535];
|
|
static int ShowStatus;
|
|
static int SrcCnt;
|
|
static int SrcFlag;
|
|
static int TrcFlag;
|
|
static int TestForBcxIni;
|
|
static char FileIn[65535];
|
|
static char FileOut[65535];
|
|
static char FileErr[65535];
|
|
static char T[65535];
|
|
static int Test;
|
|
static int Statements;
|
|
static int TestState;
|
|
static char Tipe[65535];
|
|
static int TranslateSlash;
|
|
static int UseCpp;
|
|
static int UseFlag;
|
|
static int InNameSpace;
|
|
static int Use_Virtual;
|
|
static char vproc[65535];
|
|
static int UseStdCall;
|
|
static int UseLCaseTbl;
|
|
static char Var[65535];
|
|
static int XitCount;
|
|
static char Z[65535];
|
|
static char ConstLastDef[65535];
|
|
static int Use_AnsiToWide;
|
|
static int Use_Asc;
|
|
static int Use_AppExeName;
|
|
static int Use_AppExePath;
|
|
static int Use_Boolstr;
|
|
static int Use_Bor;
|
|
static int Use_Band;
|
|
static int Use_Bnot;
|
|
static int Use_BcxSplitPath;
|
|
static int Use_Bin;
|
|
static int Use_Bin2dec;
|
|
static int Use_Osx;
|
|
static int Use_Cvd;
|
|
static int Use_Cvld;
|
|
static int Use_Cvi;
|
|
static int Use_Cvl;
|
|
static int Use_Cvs;
|
|
static int Use_Chr;
|
|
static int Use_Cdbl;
|
|
static int Use_Cldbl;
|
|
static int Use_Csng;
|
|
static int Use_Clear;
|
|
static int Use_Cbool;
|
|
static int Use_Cint;
|
|
static int Use_Clng;
|
|
static int Use_Cls;
|
|
static int Use_Color;
|
|
static int Use_Command;
|
|
static int Use_ContainedIn;
|
|
static int Use_Console;
|
|
static int Use_CopyFile;
|
|
static int Use_Static;
|
|
static int Use_Crlf;
|
|
static int Use_Curdir;
|
|
static int Use_Del;
|
|
static int Use_Download;
|
|
static int Use_Dynacall;
|
|
static int Use_DynamicA;
|
|
static int Use_Embed;
|
|
static int Use_Enclose;
|
|
static int Use_Environ;
|
|
static int Use_EnumFile;
|
|
static int Use_Eof;
|
|
static int Use_Exist;
|
|
static int Use_ExitCode;
|
|
static int Use_Extract;
|
|
static int Use_LoadFile;
|
|
static int Use_FillArray;
|
|
static int Use_Findfirst;
|
|
static int Use_Findnext;
|
|
static int Use_FindInType;
|
|
static int Use_Fint;
|
|
static int Use_Fix;
|
|
static int Use_FileLocked;
|
|
static int Use_Frac;
|
|
static int Use_Fracl;
|
|
static int Use_Freefile;
|
|
static int Use_Get;
|
|
static int Use_GetCh;
|
|
static int Use_GenFree;
|
|
static int Use_Gosub;
|
|
static int Use_Gtk;
|
|
static int Use_Glib;
|
|
static int Use_Hex;
|
|
static int Use_Hex2Dec;
|
|
static int Use_Iif;
|
|
static int Use_Imod;
|
|
static int Use_Inkey;
|
|
static int Use_InkeyD;
|
|
static int Use_Ins;
|
|
static int Use_Instr;
|
|
static int Use_Inchr;
|
|
static int Use_Isptr;
|
|
static int Use_iReplace;
|
|
static int Use_IRemove;
|
|
static int Use_Instrrev;
|
|
static int Use_Join;
|
|
static int Use_Keypress;
|
|
static int Use_Lcase;
|
|
static int Use_Ldouble;
|
|
static int Use_Left;
|
|
static int Use_Like;
|
|
static int Use_Lineinput;
|
|
static int Use_Loc;
|
|
static int Use_Locate;
|
|
static int Use_Lof;
|
|
static int Use_Lpad;
|
|
static int Use_Ltrim;
|
|
static int Use_Mcase;
|
|
static int Use_Mid;
|
|
static int Use_Midstr;
|
|
static int Use_Mkd;
|
|
static int Use_Mkld;
|
|
static int Use_Mki;
|
|
static int Use_Mkl;
|
|
static int Use_Mks;
|
|
static int Use_Min;
|
|
static int Use_Max;
|
|
static int Use_Now;
|
|
static int Use_Numqsortdint;
|
|
static int Use_Numqsortaint;
|
|
static int Use_Numqsortdfloat;
|
|
static int Use_Numqsortafloat;
|
|
static int Use_Numqsortddouble;
|
|
static int Use_Numqsortadouble;
|
|
static int Use_Idxqsort;
|
|
static int Use_IdxqsortSt;
|
|
static int Use_PtrqsortSt;
|
|
static int Use_Oct;
|
|
static int Use_Overloaded;
|
|
static int Use_OSVersion;
|
|
static int Use_Pause;
|
|
static int Use_PeekStr;
|
|
static int Use_Put;
|
|
static int Use_QBColor;
|
|
static int Use_Randomize;
|
|
static int Use_Rec;
|
|
static int Use_RecCount;
|
|
static int Use_Remain;
|
|
static int Use_Remove;
|
|
static int Use_Repeat;
|
|
static int Use_Replace;
|
|
static int Use_Reverse;
|
|
static int Use_Right;
|
|
static int Use_Rpad;
|
|
static int Use_Rnd;
|
|
static int Use_Exp;
|
|
static int Use_Retain;
|
|
static int Use_Round;
|
|
static int Use_Rtrim;
|
|
static int Use_Run;
|
|
static int Use_Scan;
|
|
static int Use_Inputbuffer;
|
|
static int Use_SearchPath;
|
|
static int Use_StrUpLow;
|
|
static int Use_Shell;
|
|
static int Use_Sgn;
|
|
static int Use_SingleFile;
|
|
static int Use_Space;
|
|
static int Use_Split;
|
|
static int Use_DSplit;
|
|
static int Use_StartupCode;
|
|
static int Use_Stristr;
|
|
static int Use_StrStr;
|
|
static int Use_Str;
|
|
static int Use_Strl;
|
|
static int Use_Str_Cmp;
|
|
static int Use_Strim;
|
|
static int Use_String;
|
|
static int Use_Strptr;
|
|
static int Use_Strqsorta;
|
|
static int Use_Strqsortd;
|
|
static int Use_Strtoken;
|
|
static int Use_DynStrqsorta;
|
|
static int Use_DynStrqsortd;
|
|
static int Use_Swap;
|
|
static int Use_Sysdir;
|
|
static int Use_SysStr;
|
|
static int Use_sziif;
|
|
static int Use_Tally;
|
|
static int Use_Tempdir;
|
|
static int Use_TempFileName;
|
|
static int Use_Threads;
|
|
static int Use_Time;
|
|
static int Use_Timer;
|
|
static int Use_Trim;
|
|
static int Use_Turbo;
|
|
static int Use_Ubound;
|
|
static int Use_Ucase;
|
|
static int Use_Using;
|
|
static int Use_VChr;
|
|
static int Use_Verify;
|
|
static int Use_Val;
|
|
static int Use_Vall;
|
|
static int Use_WideToAnsi;
|
|
static int Use_Wx;
|
|
static int Use_WxC;
|
|
static int Use_Ctor;
|
|
static int Use_Instat;
|
|
static int Use_Socket;
|
|
static int Use_IOS;
|
|
static int Use_RegEx;
|
|
static int Use_BEL;
|
|
static int Use_BS;
|
|
static int Use_CR;
|
|
static int Use_DDQ;
|
|
static int Use_DQ;
|
|
static int Use_EOF;
|
|
static int Use_ESC;
|
|
static int Use_FF;
|
|
static int Use_LF;
|
|
static int Use_NUL;
|
|
static int Use_SPC;
|
|
static int Use_TAB;
|
|
static int Use_VT;
|
|
static char prcFile[65535];
|
|
static char udtFile[65535];
|
|
static char datFile[65535];
|
|
static char cstFile[65535];
|
|
static char ovrFile[65535];
|
|
static char hdrFile[65535];
|
|
static char setFile[65535];
|
|
static char enuFile[65535];
|
|
static char *szTmp;
|
|
static char *Src;
|
|
static char *AbortSrc;
|
|
static char *WarnMsg;
|
|
static char *RmLibs;
|
|
static FILE *SourceFile;
|
|
static FILE *FP2;
|
|
static FILE *FP3;
|
|
static FILE *FP4;
|
|
static FILE *FP5;
|
|
static FILE *FP6;
|
|
static FILE *FP7;
|
|
static FILE *FP8;
|
|
static FILE *FP9;
|
|
static FILE *FP11;
|
|
static FILE *Outfile;
|
|
static FILE *FP1;
|
|
static int DoCountLines;
|
|
static FILE *FP10;
|
|
static FILE *ResIn;
|
|
static FILE *ResOut;
|
|
static FILE *UserResIn;
|
|
static FILE *fpErr;
|
|
static FILE *fpHFile;
|
|
static FILE *FP68;
|
|
static FILE *fpdef;
|
|
static int SFPOINTER;
|
|
static int WithCnt;
|
|
static char ByrefVars[1024][65535];
|
|
static int LoopLocalVar[256];
|
|
static int BaseTypeDefsCnt[16];
|
|
static char Modules[256][65535];
|
|
static int ModuleLineNos[256];
|
|
static FILE *FPtr[256];
|
|
static char Stk[4096][65535];
|
|
static ProtoStore ProtoType[1024];
|
|
static char SrcStk[128][65535];
|
|
static char SplitStk[128][65535];
|
|
static char CaseStk[256][65535];
|
|
static int CaseElseFlag[256];
|
|
static char Entry[256][65535];
|
|
static char Xit[256][65535];
|
|
static char LocalDynArrName[256][65535];
|
|
static char GlobalDynaStr[256][65535];
|
|
static char DynaStr[256][65535];
|
|
static char StartSub[32][65535];
|
|
static char ExitSub[32][65535];
|
|
static char Library[MaxLib][65535];
|
|
static int GlobalVarHash[MaxGlobalVars];
|
|
static VarInfo GlobalVars[MaxGlobalVars];
|
|
static VarInfo LocalVars[MaxLocalVars];
|
|
static UserTypeDefs TypeDefs[MaxTypes];
|
|
static char DllDecl[800][512];
|
|
static char Loadlibs[128][512];
|
|
static char HFiles[128][65535];
|
|
static char TypeName[16][65535];
|
|
static char WithVar[8][65535];
|
|
|
|
|
|
|
|
// *************************************************
|
|
// Standard Macros
|
|
// *************************************************
|
|
|
|
#define FDRV 2
|
|
#define FPATH 4
|
|
#define FNAME 8
|
|
#define FEXT 16
|
|
#define BAND &
|
|
#define BOR |
|
|
#define imod(a,b)((a)%(b))
|
|
#define VAL(a)(double)atof(a)
|
|
|
|
|
|
// *************************************************
|
|
// Standard Prototypes
|
|
// *************************************************
|
|
|
|
int str_cmp(char*, char*);
|
|
int EoF (FILE*);
|
|
void cls(void);
|
|
void locate (int,int,int=1,int=12);
|
|
void midstr (char*, int, int, char *);
|
|
char* BCX_TmpStr(size_t);
|
|
char* sziif (bool,char*,char*);
|
|
char* TempFileName (char*,char*);
|
|
char* AppExePath (void);
|
|
char* AppExeName (void);
|
|
char* lcase (char*);
|
|
char* ucase (char*);
|
|
char* mid (char*, int, int=-1);
|
|
char* ltrim (char*,char=32);
|
|
char* rtrim (char*,char=32);
|
|
char* trim (char*);
|
|
char* strim (char*);
|
|
char* left (char*,int);
|
|
char* right (char*,int);
|
|
char* rpad (char*,int,int=32);
|
|
char* lpad (char*,int,int=32);
|
|
char* stringx (int,int);
|
|
char* extract (char*,char*);
|
|
char* remain (char*,char*);
|
|
char* command (int=-1);
|
|
char* replace (char*,char*,char*);
|
|
char* iReplace (char*,char*,char*);
|
|
void Shell (char *);
|
|
char* space (int a);
|
|
char* str (double);
|
|
char* curdir (void);
|
|
char* tempdir (void);
|
|
char* Environ (char*);
|
|
char* _strupr_(char *);
|
|
char* _strlwr_(char *);
|
|
char* BcxSplitPath (char *, int);
|
|
void _splitpath_(const char* path, char* drv, char* dir, char* name, char* ext);
|
|
char* StrToken (char*,char*,int);
|
|
char* RemoveStr (char*,char*);
|
|
char* IRemoveStr (char*,char*);
|
|
char* join (int, ... );
|
|
char* enc (char*, int=0, int=0);
|
|
char* chr(int,int=0,int=0,int=0,int=0,int=0,int=0,int=0,int=0,int=0);
|
|
char* vchr (int,...);
|
|
int InstrRev (char*,char*,int=0,int=0);
|
|
int instr_b(char*,char*,int=0,int=0);
|
|
char *MakeLCaseTbl(void);
|
|
char *_stristr_(char*,char*);
|
|
char *_strstr_(char*,char*);
|
|
int inchr (char*,char*);
|
|
int tally (char*,char*,int=0);
|
|
BOOL Exist (char*);
|
|
char* ins (char *S, int i, char *a);
|
|
char* del (char*,int,int);
|
|
DWORD lof (char*);
|
|
double Round (double,int);
|
|
float rnd (void);
|
|
double _MIN_ (double,double);
|
|
double _MAX_ (double,double);
|
|
int containedin(char * ,char **,int=0);
|
|
|
|
// *************************************************
|
|
// User Prototypes
|
|
// *************************************************
|
|
|
|
int main (int, PCHAR* );
|
|
void EmitCmdLineConst (void);
|
|
void EmitCompilerDefines (void);
|
|
void MakeFreeGlobals (void);
|
|
void ProcessSetCommand (int);
|
|
int Directives (void);
|
|
int SubVarType (int);
|
|
char * PrintWriteFormat (int);
|
|
void EmitInputCode (void);
|
|
void EmitFileInputCode (void);
|
|
void AddFuncs (void);
|
|
int CheckLocal (char *, int* );
|
|
int CheckGlobal (char *, int* );
|
|
int CheckType (char *);
|
|
void ExportInternalConst (void);
|
|
int RestrictedWords (char *);
|
|
int DataType (char *);
|
|
void CloseAll (void);
|
|
char * Clean (char *);
|
|
void RemoveAll (char* ,char* ,int=0);
|
|
void Warning (char* ,int=0);
|
|
PCHAR GetVarTypeName (int);
|
|
int HashNumber (char *);
|
|
void AddLibrary (char *);
|
|
void RemoveLibrary (char *);
|
|
void EmitLibs (void);
|
|
void AddGlobal (char* ,int,int,char* ,int,int,int,int,int=0);
|
|
void AddLocal (char* ,int,int,char* ,int,int,int,int=0);
|
|
int IsNumber (char *);
|
|
int IsNumberEx (char *);
|
|
void StripTabs (void);
|
|
void PushFileIO (void);
|
|
void PopFileIO (void);
|
|
int Inset (char *, char *);
|
|
void CheckParQuotes (void);
|
|
void ClearIfThenStacks (void);
|
|
int IsQuoted (char *);
|
|
void PostProcess (void);
|
|
void XParse (char *);
|
|
void TokenSubstitutions (void);
|
|
void JoinStrings (int, int);
|
|
void Transforms (void);
|
|
void Parse (char *);
|
|
void FuncSubDecs1 (char *);
|
|
void RemEmptyTokens (void);
|
|
void FuncSubDecs2 (char *, int);
|
|
void FuncSubDecs3 (VARCODE* );
|
|
void AddTypeDefs (char *, int);
|
|
int DefsID (char *);
|
|
void GetTypeInfo (char *, int* , int* , int* );
|
|
void AddTypedefElement (int, int, char *, char *, int);
|
|
char * GetElement (int, int* , int* , int);
|
|
int GetElementInfo (int* , int* , char *);
|
|
void HandleNonsense (void);
|
|
void ValidVar (char *);
|
|
void PointerFix (void);
|
|
void DimDynaString (char *, int, int);
|
|
int SubFuncTest (void);
|
|
int DimSubFunc (int);
|
|
void Emit (void);
|
|
void Abort (char *);
|
|
void BumpDown (void);
|
|
void BumpUp (void);
|
|
int BraceCount (char *);
|
|
char* BracketHandler (char *, int);
|
|
void Push (char *);
|
|
void Pop (char *);
|
|
void EmitEpilog (void);
|
|
void EmitProlog (void);
|
|
void DeclareVariables (void);
|
|
int GetNumArgs (int,int* =NULL);
|
|
void GetVarCode (VARCODE* );
|
|
void AddProtos (void);
|
|
void RunTimeFunctions (void);
|
|
int JoinLines (char *);
|
|
void StripCode (char *);
|
|
void ProcSingleLineIf (int* );
|
|
int SplitLines (char *);
|
|
int iMatch (char *, char *, int);
|
|
int iMatchNQ (char *, char *);
|
|
int SpecialCaseHandler (char *);
|
|
void FastLexer (char* ,char* ,char* ,int=1);
|
|
void InsertTokens (int, int, ...);
|
|
void EmitExportDef (char *);
|
|
char * GetArg (int, functionParse* );
|
|
int SepFuncArgs (int, functionParse* , int);
|
|
PCHAR MakeDecProto (functionParse* );
|
|
void AsmUnknownStructs (int);
|
|
void EmitIfCond (char *);
|
|
void PrintGlobal (int, int, char *, char *, char *, char *);
|
|
void ReDirectFPrint (FILE*, char *, ...);
|
|
int IsReservedWord (char *);
|
|
int GetAsPos (void);
|
|
void FreeGlobals (void);
|
|
|
|
|
|
// *************************************************
|
|
// User Global Initialized Arrays
|
|
// *************************************************
|
|
|
|
|
|
// *************************************************
|
|
// User GLOBAL SET Statements
|
|
// *************************************************
|
|
|
|
static char* VarTypeLookup[]=
|
|
{
|
|
"int","int","char *","double","float","FILE *","long double"
|
|
};
|
|
|
|
static char VarConst[2][8]=
|
|
{
|
|
"",
|
|
"const "
|
|
};
|
|
|
|
static char VarStorage[6][18]=
|
|
{
|
|
"static ",
|
|
"extern ",
|
|
"",
|
|
"static volatile ",
|
|
"extern volatile ",
|
|
"volatile "
|
|
};
|
|
|
|
static char* ReservedWord[]=
|
|
{
|
|
"IF",
|
|
"ELSEIF",
|
|
"THEN",
|
|
"ELSE",
|
|
"AND",
|
|
"OR",
|
|
"NOT",
|
|
"BOR",
|
|
"BAND",
|
|
"XOR",
|
|
""
|
|
};
|
|
|
|
|
|
// *******************************************************************************
|
|
// Developer Guidelines
|
|
// *******************************************************************************
|
|
// Code should be written in BCX Basic. If it can not be written in BCX Basic for
|
|
// some reason or results in code that seems too inefficient then this may be a
|
|
// cue that a new Basic function is needed.
|
|
// * All KEYWORDS should be capitalized
|
|
// * Use two space indentation
|
|
// * Use spaces not tabs
|
|
// * Record all notes in reverse chronological order
|
|
// * And most importantly....Have fun!
|
|
// ******************************************************************************************
|
|
// This section is used to communicate to-do 's, changes, ideas, suggestions, etc.
|
|
// ******************************************************************************************
|
|
// -------------------------------------------
|
|
// 2022-07-26 Armando Rivera
|
|
// After a LONG time away....
|
|
// * Changed max size of szTmp$, Src$, and AbortSrc$ (65535)to avoid potential buffer overflows
|
|
// * Changed max size of WarnMsg$ (65536) to avoid potential buffer overflow
|
|
// * Removed the "register" decorator from EOF function to comply with C++17 standard
|
|
// * The above addressed warnings thrown by C++17, which is the standard on modern Linux.
|
|
// * Removed cdecl/stdcall from "Declare Function" (dynamic linking), since cdecl is the standard on *nix systems
|
|
// -------------------------------------------
|
|
// 2018-12-12 Armando Rivera
|
|
// * Changed BcxRegEx function to REGMATCH
|
|
// * Changed BcxRegEx keyword to REGMATCH
|
|
// * Added $MODULE as alias to $INCLUDE to support external modules. ** MUST BE AT TOP OF MAIN SOURCE FILE **
|
|
// * Added $LDFLAGS directive to support external modules
|
|
// -------------------------------------------
|
|
// -------------------------------------------
|
|
// 2016-02-15 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Changed default string size to 65K from
|
|
// 2k, which was limiting.
|
|
// * Updated output of PRINT command, eliminating
|
|
// leading spaces from numbers.
|
|
// -------------------------------------------
|
|
// 2015-07-03 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Changed $OSX flag to use Cocoa instead of Carbon in MacOS
|
|
// This is in preparation of the new custom libcocoa library
|
|
// that I'm currently creating that will allow mbc
|
|
// to create 64bit GUI applications in OSX
|
|
// -------------------------------------------
|
|
// 2013-06-26 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Added BcxRegex keyword, based on Posix Regex in Libc
|
|
// * Broke up main source file into files containing Runtime, Declarations, etc.
|
|
// * Added BYTE type
|
|
//
|
|
// -------------------------------------------
|
|
// 2013-06-17 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Tweaked HEX$ so that it will emit 2-digit hex numbers
|
|
// * Added PUCHAR (unsigned char*) typedef
|
|
// -------------------------------------------
|
|
// 2011-03-11 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Added Wayne's suggestion to support Reference Variables as return types.
|
|
//
|
|
// -------------------------------------------
|
|
// 2011-03-10 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Ported $PROJECT directive from ConsoleBC. This doesn't emit the RTL yet, but it's a start.
|
|
// It's the first step towards re-writing the RT code to leverage CPP/WX.
|
|
//
|
|
// * Fixed bug where BCX_TmpStr sometimes wasn't emitted when returning a string from a function
|
|
//
|
|
// * Added Named Enum support. Syntax:
|
|
// myenum AS ENUM
|
|
// …
|
|
// END ENUM
|
|
//
|
|
// This required moving the Enum emit code to before the User Prototype emit code
|
|
// to allow passing the named enum to user defined functions.
|
|
//
|
|
// -------------------------------------------
|
|
// 2011-01-23 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Initial Beta1 Release
|
|
//
|
|
// * Fixed bug in INPUT statement to remove trailing newlines (James Fuller)
|
|
//
|
|
// * Removed COLOR statements to avoid terminal output issues with redirected
|
|
// translator output (James Fuller)
|
|
//
|
|
// * Added CONST keyword when declaring variables (Global, Local, and as Function/Sub parameters)
|
|
// At the moment, this is experimental (meaning I haven't fully tested it) but it seems to work
|
|
//
|
|
// * Added PRIVATE keyword for CPP classes
|
|
// -------------------------------------------
|
|
// 2010/12/21 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Cleaned up code emission so that unneeded defines/global vars are not emitted
|
|
//
|
|
// * Added new $IOS directive, which is MAC ONLY, to compile source for iDevices (iPhone/iTouch/AppleTV2)
|
|
// At this point in time, running binaries built this way requires a jailbroken iDevice.
|
|
// This is experimental, and for console apps only for now.
|
|
// A simple console example is in the Examples/IOS folder
|
|
// -------------------------------------------
|
|
// 2010/12/11 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Add new Socket keywords: BcxSocket, BcxSocketSend, BcxSocketRead, and BcxSocketClose
|
|
// See the BcxSocket.bas demo in the Examples/Socket folder for info.
|
|
//
|
|
// * Added kbhit() , which doesn't exist outside of Windows
|
|
// This is a custom sub which emulates what kbhit() does
|
|
//
|
|
// * Changed the conditional emission of term.h to only be emitted when
|
|
// Use_Keypress is TRUE (InKey)
|
|
//
|
|
// -------------------------------------------
|
|
// 2010/12/01 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Changed wxApp emission to use BCXPLITHPATH$, per James Fuller's suggestion.
|
|
//
|
|
// * Added support for Abstract Classes (gcc doesn't have the INTERFACE keyword)
|
|
//
|
|
// Example:
|
|
// Class MyAbstractClass
|
|
// public
|
|
//
|
|
// virtual sub Proc1() = 0
|
|
// Virtual sub Proc2()=0
|
|
// virtual function Proc3(a$,b$) as integer = 0
|
|
//
|
|
// End Class
|
|
// -------------------------------------------
|
|
// 2010/11/30 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Removed $CLASS/$ENDCLASS $NAMESPACE/$ENDNAMESPACE
|
|
// Using either will emit a message stating that they have been replaced.
|
|
//
|
|
// * Addded NAMESPACE / END NAMESPACE
|
|
// This allows creating methods within the NAMESPACE like so:
|
|
//
|
|
// $CPP
|
|
// $NOMAIN
|
|
// $EXECON
|
|
// '==============================================================================
|
|
// NAMESPACE Dlg_01
|
|
// Sub DoIt()
|
|
// Print "Dlg_01"
|
|
// End Sub
|
|
//
|
|
// Function GetString$(A$) as string
|
|
// function = "The String you Passed Was: " + enc$(A$)
|
|
// end function
|
|
// END NAMESPACE
|
|
// '==============================================================================
|
|
// Function main(argc as INTEGER, argv as PCHAR ptr) as INTEGER
|
|
// Print "James"
|
|
// Dlg_01::DoIt()
|
|
// print Dlg_01::GetString$("Hello, World!")
|
|
// End Function
|
|
//
|
|
// * If using $WX, the #define for Clear() will not be emitted due to conflict
|
|
// with Classes that have that method defined
|
|
//
|
|
// * Made the inclusion of "term.h" conditional based on whether $WX/$WXC
|
|
// is used. "term.h" is required for the implementation of
|
|
// the PAUSE keyword in CONSOLE apps.
|
|
//
|
|
// -------------------------------------------
|
|
// 2010/11/25 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Changed code so that in $CPP mode, the case of the emitted
|
|
// .cpp filename is preserved (James Fuller bug report)
|
|
//
|
|
// -------------------------------------------
|
|
// 2010/11/24 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Minor change in StripCode() to correct
|
|
// possible overflow issue under 64bit Linux (James Fuller bug report)
|
|
//
|
|
// * Added $WXC Directive to support WX Console-Based Apps
|
|
// Using this switch, neither a wxApp or the IMPLEMENT_APP() macro are
|
|
// auto added to the translated source (James Fuller request)
|
|
// -------------------------------------------
|
|
// 2010/11/20 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Changed $DLL directive so that it would generate *nix Shared Libraries.
|
|
// * Added $DLL support to $EXECON
|
|
// * Added required flags to LD_FLAGS$ for creating *nix Shared Libraries
|
|
// Example:
|
|
// $dll
|
|
// $execon
|
|
//
|
|
// function printdemo() export
|
|
// print "This was called from a Dynamic Library"
|
|
// end function
|
|
//
|
|
// Note that this is currently only useful for creating shared libraries
|
|
// for **OTHER** languages; it won't work with MBC created apps because of
|
|
// duplicate naming conflicts.
|
|
//
|
|
// -------------------------------------------
|
|
// 2010/11/18 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Removed "-Os" compiler optimization flag from $EXECON for fastest tranlator compliation
|
|
// during Alpha testing stage.
|
|
//
|
|
// This will be re-added when translator is not longer in Alpha status
|
|
//
|
|
// * Added USE_CTOR global as flag for supporting Constructor/Destructor syntax
|
|
//
|
|
// * Added "USING" keyword for CONSTRUCTOR/DESTRUCTOR methods. It is used like this:
|
|
//
|
|
// CONSTRUCTOR MainWin::MainWin(title as wxString, winStyle as long) USING wxFrame( 0, -1, title, wxPoint(50,50), wxSize(490,296), winStyle )
|
|
//
|
|
// Which will emit:
|
|
//
|
|
// MainWin::MainWin (wxString title, long winStyle)
|
|
// : wxFrame( 0, -1, title, wxPoint(50,50), wxSize(490,296), winStyle )
|
|
// {
|
|
//
|
|
// * Added code to extract and emit derived class methods
|
|
//
|
|
// -------------------------------------------
|
|
// 2010/11/17 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Added new CLASS / END CLASS / PUBLIC / PROTECTED / CONSTRUCTOR / DESTRUCTOR keywords.
|
|
// These additions flesh out Basic-Like C++ CLASS support, superceding $CLASS/$ENDCLASS,
|
|
// and now allows syntax like the following:
|
|
//
|
|
// $CPP
|
|
// $NOMAIN
|
|
// $execon
|
|
//
|
|
// class MyClass
|
|
//
|
|
// protected
|
|
// first as string
|
|
// secnd$
|
|
// third%
|
|
//
|
|
// public
|
|
// type ATest
|
|
// a as PCHAR
|
|
// b as long
|
|
// c as single
|
|
// d as float
|
|
// end type
|
|
//
|
|
// Constructor MyClass(a$, b)
|
|
// Destructor MyClass()
|
|
// end class
|
|
//
|
|
// FUNCTION main(argc as INTEGER, argv as PCHAR ptr) as INTEGER
|
|
// RAW theClass as MyClass PTR
|
|
//
|
|
// theClass = new MyClass("Hello", 12)
|
|
//
|
|
// print (char*)theClass->ATest.a
|
|
// print theClass->ATest.b
|
|
// END FUNCTION
|
|
//
|
|
// Constructor MyClass::MyClass(a$,b)
|
|
// ATest.a = a$
|
|
// ATest.b = b
|
|
// END Constructor
|
|
// '
|
|
// Destructor MyClass::~MyClass()
|
|
//
|
|
// END Destructor
|
|
//
|
|
// -------------------------------------------
|
|
// 2010/11/12 Armando Rivera
|
|
// -------------------------------------------
|
|
// * Added code that (mostly) eliminates the need for a trailing ";" in $class/$endclass
|
|
//
|
|
// * Added code to allow the use of "SUB" in $class/$endclass. It just substitutes "void" for "sub"
|
|
// at this point.
|
|
//
|
|
// * Fixed "THIS" keyword code so that it emits a lowercase "this". Linux/OSX aren't affected
|
|
// by this breaking COM statements. :-P Thanks to JCFULLER for the tip!
|
|
//
|
|
// * For $CPP mode, added typedefs for std::string (CSTRING) and std::fstream (CFILE)
|
|
// These are direct replacements for STRING and FILE, and allows the full use of each
|
|
// C++ object/class.
|
|
//
|
|
// So instead of "dim mystring as string", for example, you would do "dim mystring as CSTRING".
|
|
// You would then have access to all of std::string's methods like .replace, .substr, .compare, etc.
|
|
//
|
|
// I'm considering doing the same with the other toolkit directives ($OSX, $GTK, etc) but we'll see...
|
|
//
|
|
// * Added "inherits" in $CPP mode so that subclassing can be done like so:
|
|
//
|
|
// $class MyClass inherits AnotherClass
|
|
//
|
|
// * For $WX mode, added code to automatically emit the required derived wxApp class.
|
|
// Note that it will be named the same as your sourcefile (minus the extension), and you MUST provide
|
|
// a "FUNCTION ::OnInit() as bool" for it:
|
|
//
|
|
// FUNCTION TestApp::OnInit() as bool
|
|
// <initialize app here>
|
|
// END FUNCTION
|
|
//
|
|
// * For $WX mode, made "$NOMAIN" the default, so no need to pass that directive
|
|
//
|
|
// * Colorized some of the compiler output text. Just because I can.
|
|
//
|
|
// * Back-ported Wayne's changes to "WITH" to allow the use of "->" syntax
|
|
//
|
|
// * TODO:
|
|
// Finish off the $class/$endclass code to allow full basic syntax for method and variable
|
|
// declarations.
|
|
//
|
|
// Remove ALL remaining WIN32 related code and ifdefs.
|
|
// No need for that stuff under Linux/OSX, the Windows version of BCX can handle all
|
|
// of the Windows stuff one might need.
|
|
//
|
|
// Other stuff I can't remember right now…..
|
|
// -------------------------------------------
|
|
// 2010/03/31 Armando Rivera
|
|
// Beginning with this version of the console compiler,
|
|
// the goal is to have a 100% unified code-base, because
|
|
// I'm fracking tired of trying to maintain separate builds
|
|
// for different Operating Systems.
|
|
// -------------------------------------------
|
|
//
|
|
// * Added $OSX, $GTK¸$GLIB and $WX Directives
|
|
// (Use_Osx, Use_Wx, Use_Gtk, Use_Glib and LD_FLAGS$ Globals added)
|
|
//
|
|
// $OSX will automatically enable Carbon GUI support, and if $EXECON is invoked
|
|
// will also build a Universal Binary with 32bit and 64bit support
|
|
//
|
|
// $GTK will automatically enable GTK/GLIB support, and if $EXECON is invoked
|
|
// will build the executable linking in libgtk and it's support libraries.
|
|
//
|
|
// $GLIB will automatically enable >GLIB ONLY< support, and if $EXECON is invoked
|
|
// will build the executable linking in libglib and it's support libraries.
|
|
//
|
|
// $WX will automatically enable wxWidgets with $CPP set to "TRUE", and if $EXECON
|
|
// is invoked will build the executable linking in libwx and it's support libraries
|
|
//
|
|
// This is, in part, in preparation for moving the GTK support from the core of the
|
|
// LinuxBC translator to an external library which will be linked in as required. This
|
|
// will GREATLY simplify maintenence of the translator core once the lib is ready.
|
|
//
|
|
// * Changed alls instances of byte* to UCHAR* in SWAP() Function
|
|
//
|
|
// * Added internal return values for PUT/GET to get rid of ALL compiler warnings.
|
|
//
|
|
// * Updated runtime functions calling PUT()/GET()/fread()/fwrite so that they
|
|
// will not trigger compiler warnings
|
|
//
|
|
// * Reworked the way functions declared using C_DECLARE with the LIB and ALIAS keywords
|
|
// are emitted. This is so that you can dynamically load functions from a shared
|
|
// library at runtime via dlopen/dlsym.
|
|
//
|
|
// The syntax is:
|
|
// C_DECLARE FUNCTION <YOUR FUNCTION NAME> LIB <shared library> ALIAS <quoted name of actual function (<parameters>) AS <return type>
|
|
//
|
|
// For example:
|
|
// C_DECLARE FUNCTION b64encode LIB "libglib-2.0.so" ALIAS "g_base64_encode" (txt AS char*, length AS integer) AS string
|
|
// C_DECLARE FUNCTION g_base64_decode LIB "libglib-2.0.so" ALIAS "g_base64_decode" (txt AS char*, length AS INTEGER PTR) AS string
|
|
//
|
|
// NOTE that the ALIAS is the actual name of the function you want to call from the shared library.
|
|
// This is so you avoid redeclaration errors if you attempt to link to a library (libm is a good example)
|
|
// that is already compile-time linked with g++.
|
|
//
|
|
// NOTE 2: There is currently no checking whether the function was loaded without error. It is on the TODO list.
|
|
//
|
|
// * Changed compiler invocation to include -Wformat and -D_FORTIFY_SOURCE=2 (Ubuntu Standard)
|
|
//
|
|
// * Fixed User Include File handling in order to support mixed case filenames
|
|
//
|
|
// * Updated the CURDIR$, TEMPDIR$, AND SHELL code to eliminate warnings emitted when compiling on
|
|
// a system that has "_FORTIFY_SOURCE=2" enabled by default in GCC/G++ (Ubuntu)
|
|
//
|
|
// * Fixed a potential overflow problem with LINE INPUT that would also cause G++ to emit
|
|
// warnings as above.
|
|
//
|
|
// *Re-coded the $RESOURCE directive and the GETRESOURCE$ function to allow
|
|
// linking of Resources under Linux/Unix. Using $RESOURCE generates a #define
|
|
// allowing you to reference the embedded resource using an arbitrary IDENTIFIER.
|
|
//
|
|
// For example:
|
|
//
|
|
// DIRECTIVE FILE IDENTIFIER
|
|
// -------------------------------
|
|
// $RESOURCE "file.txt" "myres"
|
|
//
|
|
//
|
|
// Note that you reference the resource using the identifier you passed as the
|
|
// SECOND parameter to the $RESOURCE directive, minus the quotes.
|
|
//
|
|
// "file.txt" above can be any arbitrary file on one's system
|
|
//
|
|
// At the moment, the resource is returned as a string with the GETRESOURCE$ function.
|
|
// *****************************************************************************************************
|
|
// ** YOU WILL HAVE TO ENSURE THAT A BUFFER WITH ENOUGH SPACE TO HOLD THE RESOURCE HAS BEEN ALLOCATED **
|
|
// *****************************************************************************************************
|
|
// To aid in this, a constant is automatically created with the size of the resource. It will have the
|
|
// name you specified as the second parameter to $RESOURCE, with _SIZE appended.
|
|
// Using the example above, the constant would be defined as: myres_SIZE
|
|
//
|
|
//
|
|
// You should be able to manually cast the reference *itself* to what you require, since it is
|
|
// merely a pointer to the location of the resource itself.
|
|
//
|
|
// The resource will be converted to an object file, named using the filename provided with ".o" apppended.
|
|
// "file.txt" will be converted to "file.txt.o" in the above example, which can then be linked
|
|
// to the final executable via $EXECON "file.txt.o" or $EXEGUI "file.txt.o"
|
|
//
|
|
// * Tweaked $GUI directive and GUI keyword so that one can use the directive without
|
|
// having all of the support for BCX_* form objects automatically added to one's app.
|
|
//
|
|
// This is usefull when using GtkBuilder or Glade to build the user interface.
|
|
//
|
|
// -------------------------------------------
|
|
// 2010-01-17 Armando Rivera
|
|
// -------------------------------------------
|
|
// modified the $CLASS/$ENDCLASS directives to allow creation and inheritance of C++ Classes
|
|
//
|
|
// modified the Function/Sub prototype emitter so that it would not emit prototypes
|
|
// for C++ Class Methods, which are supposed to be prototyped within the Class itself
|
|
//
|
|
// made the inclusion of <term.h> conditional based on whether UseCPP is true/false
|
|
// it will not be included if UseCpp is "true" because some C++ toolkits (wxWidgets)
|
|
// throw a "redefined" error when it's included
|
|
//
|
|
// -------------------------------------------
|
|
// 2010-01-15 Armando Rivera
|
|
// -------------------------------------------
|
|
// per wmhalsdorf's recommendation, modified SplitLines and Emit procs to support
|
|
// C++ Method syntax (CLASSNAME::METHOD) [see Yahoo group Message #40282]
|
|
//
|
|
// -------------------------------------------
|
|
// 2010-01-10 Armando Rivera
|
|
// -------------------------------------------
|
|
// changed $CPP directive to output lowercase filenames
|
|
//
|
|
// -------------------------------------------
|
|
// 2009-10-18 Armando Rivera
|
|
// -------------------------------------------
|
|
// added Carbon.h as a default include, to support Carbon/CoreFoundation calls
|
|
// added Carbon framework to $execon section
|
|
// removed TRUE and FALSE defines, which are now provided by Carbon.h
|
|
// changed Handle$ to Handl$ to resolve conflict with Carbon.h
|
|
//
|
|
// -------------------------------------------
|
|
// 2009-10-13 Armando Rivera
|
|
// -------------------------------------------
|
|
// added typedef for "byte" type (typedef unsigned char byte;)
|
|
//
|
|
|
|
// *************************************************
|
|
// Runtime Functions
|
|
// *************************************************
|
|
|
|
char *BCX_TmpStr (size_t Bites)
|
|
{
|
|
static int StrCnt;
|
|
static char *StrFunc[512];
|
|
StrCnt=((StrCnt+1) &511);
|
|
#if defined BCX_MAX_VAR_SIZE
|
|
if(Bites*sizeof(char)>BCX_MAX_VAR_SIZE)
|
|
{
|
|
printf("Buffer Overflow caught in BCX_TmpStr - requested space of %d EXCEEDS %d\n",(int)(Bites*sizeof(char)),BCX_MAX_VAR_SIZE);
|
|
abort();
|
|
}
|
|
#endif
|
|
StrFunc[StrCnt]=(char*)realloc(StrFunc[StrCnt],Bites + 128);
|
|
return (char*)memset(StrFunc[StrCnt],0,Bites+128);
|
|
}
|
|
|
|
|
|
int str_cmp (char *a, char *b)
|
|
{
|
|
int counter=0;
|
|
for(;;)
|
|
{
|
|
if((a[counter]^b[counter]))
|
|
{
|
|
if((UINT) a[counter]>= (UINT) b[counter])
|
|
return 1;
|
|
return -1;
|
|
}
|
|
if(!a[counter]) return 0;
|
|
counter++;
|
|
}
|
|
}
|
|
|
|
|
|
int EoF (FILE* stream)
|
|
{
|
|
int c, status = ((c = fgetc(stream)) == EOF);
|
|
ungetc(c,stream);
|
|
return status;
|
|
}
|
|
|
|
|
|
char *left (char *S, int length)
|
|
{
|
|
int tmplen = strlen(S);
|
|
if(length<1) return BCX_TmpStr(1);
|
|
if(length<tmplen) tmplen=length;
|
|
char *strtmp = BCX_TmpStr(tmplen);
|
|
return (char*)memcpy(strtmp,S,tmplen);
|
|
}
|
|
|
|
|
|
char *right (char *S, int length)
|
|
{
|
|
int tmplen = strlen(S);
|
|
char *BCX_RetStr = BCX_TmpStr(tmplen);
|
|
tmplen -= length;
|
|
if (tmplen<0) tmplen = 0;
|
|
return strcpy(BCX_RetStr, &S[tmplen]);
|
|
}
|
|
|
|
|
|
char *rpad (char *a, int L, int c)
|
|
{
|
|
char *strtmp;
|
|
int s = strlen(a);
|
|
if((L-s)<1) return a;
|
|
strtmp=BCX_TmpStr(L);
|
|
strcpy(strtmp,a);
|
|
memset(&strtmp[s],c,(L-s));
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
char *lpad (char *a, int L, int c)
|
|
{
|
|
char *strtmp;
|
|
L=L-strlen(a);
|
|
if(L<1) return a;
|
|
strtmp = BCX_TmpStr(L);
|
|
memset(strtmp,c,L);
|
|
return strcat(strtmp,a);
|
|
}
|
|
|
|
|
|
char *mid (char *S, int start, int length)
|
|
{
|
|
char *strtmp;
|
|
int tmplen = strlen(S);
|
|
if(start>tmplen||start<1) return BCX_TmpStr(1);
|
|
if (length<0 || length>(tmplen-start)+1)
|
|
length = (tmplen-start)+1;
|
|
strtmp = BCX_TmpStr(length);
|
|
return (char*)memcpy(strtmp,&S[start-1],length);
|
|
}
|
|
|
|
|
|
char *trim (char *S)
|
|
{
|
|
while(*S==32 || *S==9 || *S==10 || *S==11 || *S==13)
|
|
S++;
|
|
int i = strlen(S);
|
|
while( i>0 && (S[i-1]==32 || S[i-1]==9 || S[i-1]==10
|
|
|| S[i-1]==11 || S[i-1]==13))
|
|
i--;
|
|
char *strtmp=BCX_TmpStr(i);
|
|
return (char*)memcpy(strtmp,S,i);
|
|
}
|
|
|
|
|
|
char *ltrim (char *S, char c)
|
|
{
|
|
if(S[0]==0) return S;
|
|
while((*S==32 || *S==c) && *S !=0) S++;
|
|
char *strtmp = BCX_TmpStr(strlen(S));
|
|
return strcpy(strtmp,S);
|
|
}
|
|
|
|
|
|
char *rtrim (char *S,char c)
|
|
{
|
|
if(S[0]==0) return S;
|
|
int i = strlen(S);
|
|
while(i>0 && (S[i-1]==c || S[i-1]==32))
|
|
i--;
|
|
char *strtmp = BCX_TmpStr(i);
|
|
return (char*)memcpy(strtmp,S,i);
|
|
}
|
|
|
|
|
|
char *strim (char *src)
|
|
{
|
|
char *strtmp = BCX_TmpStr(strlen(src));
|
|
char *dst = strtmp;
|
|
while (isspace((unsigned char)*src)) src++;
|
|
do
|
|
{
|
|
while (*src && !isspace((unsigned char)*src)) *dst++ = *src++;
|
|
if (*src)
|
|
{
|
|
*dst++ = *src++;
|
|
while (isspace((unsigned char)*src)) src++;
|
|
}
|
|
} while (*src);
|
|
if (isspace((unsigned char)*(--dst))) *dst = 0;
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
char *command (int nArg)
|
|
{
|
|
int i = 0;
|
|
char *retstr=BCX_TmpStr(1);
|
|
if(nArg < i) // return entire commandline
|
|
{
|
|
retstr = BCX_TmpStr(G_argc * 2048);
|
|
for(i=1; i < G_argc; i++)
|
|
{
|
|
strcat(retstr, G_argv[i]);
|
|
strcat(retstr, SPC);
|
|
}
|
|
}
|
|
else if(nArg < G_argc)
|
|
{
|
|
retstr = BCX_TmpStr(strlen(G_argv[nArg]) + 1);
|
|
strcpy(retstr, G_argv[nArg]);
|
|
}
|
|
return retstr;
|
|
}
|
|
|
|
|
|
char *extract (char *mane, char *match)
|
|
{
|
|
char *a;
|
|
char *strtmp = BCX_TmpStr(strlen(mane));
|
|
if(*match!=0)
|
|
{
|
|
a=_strstr_(mane,match);
|
|
if(a) return (char*)memcpy(strtmp,mane,a-mane);
|
|
}
|
|
return strcpy(strtmp,mane);
|
|
}
|
|
|
|
|
|
char *remain (char *mane, char *mat)
|
|
{
|
|
char *p = strstr(mane,mat);
|
|
if(p)
|
|
{
|
|
p+=(strlen(mat));
|
|
return p;
|
|
}
|
|
return mane;
|
|
}
|
|
|
|
|
|
char *replace (char *src, char *pat, char *rep)
|
|
{
|
|
size_t patsz, repsz, tmpsz, delta;
|
|
char *strtmp, *p, *q, *r;
|
|
if (!pat || !*pat)
|
|
{
|
|
strtmp = BCX_TmpStr(strlen(src));
|
|
if (!strtmp) return NULL;
|
|
return strcpy(strtmp, src);
|
|
}
|
|
repsz = strlen(rep);
|
|
patsz = strlen(pat);
|
|
for (tmpsz=0, p=src; (q=_strstr_(p,pat))!=0; p=q+patsz)
|
|
tmpsz += (size_t) (q - p) + repsz;
|
|
tmpsz += strlen(p);
|
|
strtmp = BCX_TmpStr(tmpsz);
|
|
if (!strtmp) return NULL;
|
|
for (r=strtmp,p=src; (q=_strstr_(p,pat))!=0;p=q+patsz)
|
|
{
|
|
delta = (size_t) (q-p);
|
|
memcpy(r,p,delta); r += delta;
|
|
strcpy(r,rep); r += repsz;
|
|
}
|
|
strcpy(r,p);
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
char *ucase (char *S)
|
|
{
|
|
char *strtmp = BCX_TmpStr(strlen(S));
|
|
return _strupr_(strcpy(strtmp,S));
|
|
}
|
|
|
|
|
|
char *lcase (char *S)
|
|
{
|
|
char *strtmp = BCX_TmpStr(strlen(S));
|
|
return _strlwr_(strcpy(strtmp,S));
|
|
}
|
|
|
|
|
|
char *RemoveStr (char *a, char *b)
|
|
{
|
|
char *strtmp, *p, *d;
|
|
int tmplen;
|
|
strtmp = d = BCX_TmpStr(strlen(a));
|
|
if(!b || !*b) return strcpy(strtmp,a);
|
|
p=_strstr_(a,b); tmplen = strlen(b);
|
|
while(p)
|
|
{
|
|
memcpy(d,a,p-a);
|
|
d+= (p-a);
|
|
a=p+tmplen;
|
|
p=_strstr_(a,b);
|
|
}
|
|
strcpy(d,a);
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
char *IRemoveStr (char *a, char *b)
|
|
{
|
|
char *strtmp, *p, *d;
|
|
int tmplen;
|
|
strtmp = d = BCX_TmpStr(strlen(a));
|
|
if(!b || !*b) return strcpy(strtmp,a);
|
|
p=_stristr_(a,b); tmplen = strlen(b);
|
|
while(p)
|
|
{
|
|
memcpy(d,a,p-a);
|
|
d+= (p-a);
|
|
a=p+tmplen;
|
|
p=_stristr_(a,b);
|
|
}
|
|
strcpy(d,a);
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
char *ins (char *S, int i, char *a)
|
|
{
|
|
int j = strlen(S);
|
|
if(i<1 || i>j+1) return S;
|
|
char *strtmp = BCX_TmpStr(j + strlen(a));
|
|
memcpy(strtmp,S,--i);
|
|
strcpy(&strtmp[i],a);
|
|
return strcat(strtmp,&S[i]);
|
|
}
|
|
|
|
|
|
char *del (char *S, int i, int j)
|
|
{
|
|
int ln = strlen(S);
|
|
if(i<1 || i>ln) return S;
|
|
char *strtmp = BCX_TmpStr(ln);
|
|
memcpy(strtmp,S,--i);
|
|
return strcat(strtmp,&S[i+j]);
|
|
}
|
|
|
|
|
|
char *str (double d)
|
|
{
|
|
char *strtmp = BCX_TmpStr(16);
|
|
sprintf(strtmp,"% .15G",d);
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
char *curdir (void)
|
|
{
|
|
char *strtmp = BCX_TmpStr(2048);
|
|
char *res=getcwd(strtmp, 1024);
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
char *tempdir (void)
|
|
{
|
|
char *strtmp = BCX_TmpStr(2048);
|
|
if(!Exist("/tmp/mbc.compiler")) {
|
|
mkdir ("/tmp/mbc.compiler",0755);
|
|
}
|
|
strcpy(strtmp,"/tmp/mbc.compiler");
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
char *stringx (int count, int a)
|
|
{
|
|
if(count<1) return BCX_TmpStr(1);
|
|
char *strtmp = BCX_TmpStr(count);
|
|
return (char*)memset(strtmp,a,count);
|
|
}
|
|
|
|
|
|
void Shell (char *cmd)
|
|
{
|
|
int res=system(cmd);
|
|
}
|
|
|
|
|
|
char *space (int count)
|
|
{
|
|
if(count<1) return BCX_TmpStr(1);
|
|
char *strtmp = BCX_TmpStr(count);
|
|
return (char*)memset(strtmp,32,count);
|
|
}
|
|
|
|
|
|
char *enc (char *A, int L, int R)
|
|
{
|
|
char *BCX_RetStr = BCX_TmpStr(strlen(A)+3);
|
|
if(L==0) L=34;
|
|
if(R==0) R=L;
|
|
sprintf(BCX_RetStr,"%c%s%c%s",L,A,R,"");
|
|
return BCX_RetStr;
|
|
}
|
|
|
|
|
|
char *chr (int a,int b,int c,int d,int e,int f,int g,int h,int i,int j)
|
|
{
|
|
char *strtmp = BCX_TmpStr(11);
|
|
strtmp[0] = a;
|
|
strtmp[1] = b;
|
|
strtmp[2] = c;
|
|
strtmp[3] = d;
|
|
strtmp[4] = e;
|
|
strtmp[5] = f;
|
|
strtmp[6] = g;
|
|
strtmp[7] = h;
|
|
strtmp[8] = i;
|
|
strtmp[9] = j;
|
|
strtmp[10] = 0;
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
char *vchr(int charcount, ...)
|
|
{
|
|
int c = 0, i = charcount;
|
|
char *s_ = BCX_TmpStr(charcount + 1);
|
|
va_list marker;
|
|
s_[i] = 0;
|
|
va_start(marker, charcount);
|
|
while(i-- > 0) s_[c++] = va_arg(marker,int);
|
|
va_end(marker);
|
|
return s_;
|
|
}
|
|
|
|
|
|
char * join(int n, ...)
|
|
{
|
|
int i = n, tmplen = 0;
|
|
char *strtmp, *s_;
|
|
|
|
va_list marker;
|
|
va_start(marker, n); // Initialize variable arguments
|
|
while(i-- > 0)
|
|
{
|
|
s_ = va_arg(marker, char *);
|
|
if(s_) tmplen += strlen(s_);
|
|
}
|
|
strtmp = BCX_TmpStr(tmplen);
|
|
va_end(marker); // Reset variable arguments
|
|
i = n;
|
|
va_start(marker, n); // Initialize variable arguments
|
|
while(i-- > 0)
|
|
{
|
|
s_ = va_arg(marker, char *);
|
|
if(s_) strcat(strtmp, s_);
|
|
}
|
|
va_end(marker); // Reset variable arguments
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
char* Environ(char *S)
|
|
{
|
|
char *strtmp, *tmp;
|
|
|
|
tmp = getenv(S);
|
|
if(tmp != NULL) {
|
|
strtmp = BCX_TmpStr(strlen(tmp)+1);
|
|
return strcpy(strtmp, tmp);
|
|
}
|
|
return BCX_TmpStr(1);
|
|
}
|
|
|
|
|
|
char *AppExePath (void)
|
|
{
|
|
char fullpath[MAX_PATH];
|
|
int length;
|
|
length = readlink("/proc/self/exe", fullpath, MAX_PATH);
|
|
if(length < 1) return BCX_TmpStr(1);
|
|
|
|
fullpath[length] = 0;
|
|
return BcxSplitPath(fullpath, FDRV|FPATH);
|
|
}
|
|
|
|
|
|
char *AppExeName (void)
|
|
{
|
|
return BcxSplitPath(G_argv[0], FNAME|FEXT);
|
|
}
|
|
|
|
|
|
char * TempFileName (char *dr, char *prefix)
|
|
{
|
|
static unsigned int count;
|
|
char *f, *tmpstr = BCX_TmpStr(MAX_PATH);
|
|
int i, length;
|
|
|
|
if(!count) srand(time(0));
|
|
|
|
if(dr) strcpy(tmpstr, dr);
|
|
length = strlen(tmpstr);
|
|
if(length && (tmpstr[length-1] != '\\' && tmpstr[length-1] != '/'))
|
|
tmpstr[length++] = '/';
|
|
if(prefix) strcpy(&tmpstr[length], prefix);
|
|
f = &tmpstr[strlen(tmpstr)];
|
|
|
|
do {
|
|
count++;
|
|
for(i=0; i<5; i+=1)
|
|
{
|
|
do {
|
|
f[i]=(char)(rnd()*122);
|
|
}while((f[i]<65)||(f[i]>90&&f[i]<97));
|
|
}
|
|
snprintf(&f[5],3,"%x", count);
|
|
} while (Exist(tmpstr));
|
|
|
|
return tmpstr;
|
|
}
|
|
|
|
|
|
int InstrRev (char *s, char *p, int os, int sens)
|
|
{
|
|
int sl, pl, ox;
|
|
int (*cmp)(const char *, const char *, size_t );
|
|
|
|
if (!s || !p) return 0;
|
|
sl = strlen(s); pl = strlen(p);
|
|
if (os > sl || sl == 0 || pl == 0 || (ox = sl - pl) < 0)
|
|
return 0;
|
|
|
|
if (os <= 0)
|
|
os = ox ;
|
|
else if(os >= pl)
|
|
os = os - pl ;
|
|
else
|
|
return 0;
|
|
|
|
cmp = (sens ? strncasecmp : strncmp);
|
|
do { if (cmp(s + os , p, pl) == 0)
|
|
return os+1;
|
|
} while (os--);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int instr_b(char* mane,char* match,int offset,int sensflag)
|
|
{
|
|
char *s;
|
|
if (!mane || !match || ! *match || offset>(int)strlen(mane)) return 0;
|
|
if (sensflag)
|
|
s = _stristr_(offset>0 ? mane+offset-1 : mane,match);
|
|
else
|
|
s = _strstr_(offset>0 ? mane+offset-1 : mane,match);
|
|
return s ? (int)(s-mane)+1 : 0;
|
|
}
|
|
|
|
|
|
char *MakeLCaseTbl (void)
|
|
{
|
|
static char tbl[256];
|
|
if(!tbl['a'])
|
|
{
|
|
int i; for (i=0; i < 256; i++)
|
|
tbl[i] = (char)(int)tolower(i);
|
|
}
|
|
return tbl;
|
|
}
|
|
|
|
|
|
char *_stristr_(char *String, char *Pattern)
|
|
{
|
|
int mi=-1;
|
|
char *LowCase = MakeLCaseTbl();
|
|
while(Pattern[++mi])
|
|
{
|
|
if(String[mi]==0) return 0;
|
|
if(LowCase[(unsigned char)String[mi]]!=LowCase[(unsigned char)Pattern[mi]])
|
|
{ String++; mi=-1; }
|
|
}
|
|
return String;
|
|
}
|
|
|
|
|
|
char *_strstr_(char *String, char *Pattern)
|
|
{
|
|
int mi=-1;
|
|
while(Pattern[++mi])
|
|
{
|
|
if(String[mi]==0) return 0;
|
|
if(String[mi]!=Pattern[mi])
|
|
{ String++; mi=-1; }
|
|
}
|
|
return String;
|
|
}
|
|
|
|
|
|
int inchr (char *A, char *B)
|
|
{
|
|
char* C=A;
|
|
while(*C)
|
|
{
|
|
if(*C==*B) return C-A+1;
|
|
C++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
double Round (double n, int d)
|
|
{
|
|
return (floor((n)*pow(10.0,(d))+0.5)/pow(10.0,(d)));
|
|
}
|
|
|
|
|
|
bool Exist (char *szFilePath)
|
|
{
|
|
int retstat;
|
|
struct stat sb;
|
|
retstat = stat(szFilePath, &sb);
|
|
if(retstat != -1)
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
int tally (char *szLine, char *szChar, int sensflag)
|
|
{
|
|
if(!*szChar) return 0;
|
|
int mlen = strlen(szChar);
|
|
int iCount = 0;
|
|
char *p = (sensflag == 0 ? _strstr_(szLine, szChar) : _stristr_(szLine, szChar));
|
|
while (p)
|
|
{
|
|
iCount++;
|
|
p+=mlen;
|
|
p = (sensflag == 0 ? _strstr_(p, szChar) : _stristr_(p, szChar));
|
|
}
|
|
return iCount;
|
|
}
|
|
|
|
|
|
float rnd (void)
|
|
{
|
|
return (float)rand()/RAND_MAX;
|
|
}
|
|
|
|
|
|
double _MAX_ (double a, double b)
|
|
{
|
|
if(a>b)
|
|
return a;
|
|
return b;
|
|
}
|
|
|
|
|
|
double _MIN_ (double a, double b)
|
|
{
|
|
if(a<b)
|
|
return a;
|
|
return b;
|
|
}
|
|
|
|
|
|
void locate (int row,int col,int show,int shape)
|
|
{
|
|
printf("%c%s%u%s%u%s",27,"[",row,";",col,"H");
|
|
// find cursor size/shape function!
|
|
}
|
|
|
|
|
|
void cls (void)
|
|
{
|
|
printf("%s%s%s%s",ESC,"[2J",ESC,"[H");
|
|
}
|
|
|
|
|
|
void midstr (char *src, int st, int length, char *rep)
|
|
{
|
|
int srclen = strlen(src);
|
|
if(st>srclen++ || st<1) return;
|
|
int replen = strlen(rep);
|
|
if(replen < length || length==-1) length=replen;
|
|
if((st+length) > srclen) length=srclen-st;
|
|
memcpy(&src[st-1],rep,length);
|
|
}
|
|
|
|
|
|
DWORD lof (char *FileName)
|
|
{
|
|
|
|
int retstat;
|
|
struct stat sb;
|
|
retstat = stat(FileName, &sb);
|
|
if(retstat != -1)
|
|
return sb.st_size;
|
|
return 0;
|
|
}
|
|
|
|
|
|
char * sziif (bool i, char *a, char *b)
|
|
{
|
|
if(i) return a;
|
|
return b;
|
|
}
|
|
|
|
|
|
char *BcxSplitPath (char *FPath, int mask)
|
|
{
|
|
if(!FPath) return BCX_TmpStr(1);
|
|
char *BCX_RetStr=BCX_TmpStr(strlen(FPath));
|
|
char tmp[MAX_PATH*4];
|
|
_splitpath_(FPath,tmp,&tmp[MAX_PATH],&tmp[MAX_PATH*2],&tmp[MAX_PATH*3]);
|
|
if(mask & FDRV) strcat(BCX_RetStr,tmp);
|
|
if(mask & FPATH)strcat(BCX_RetStr,&tmp[MAX_PATH]);
|
|
if(mask & FNAME)strcat(BCX_RetStr,&tmp[MAX_PATH*2]);
|
|
if(mask & FEXT) strcat(BCX_RetStr,&tmp[MAX_PATH*3]);
|
|
return BCX_RetStr;
|
|
}
|
|
|
|
|
|
void _splitpath_(const char* path, char* drv, char* dir, char* name, char* ext)
|
|
{
|
|
const char* pend; /* end of processed string */
|
|
const char* p; /* search pointer */
|
|
const char* s; /* copy pointer */
|
|
|
|
/* extract drive name */
|
|
if (path[0] && path[1]==':') {
|
|
if (drv) {
|
|
*drv++ = *path++;
|
|
*drv++ = *path++;
|
|
*drv = 0;
|
|
}
|
|
} else if (drv)
|
|
*drv = 0;
|
|
|
|
/* search for end of string or stream separator */
|
|
for(pend=path; *pend && *pend!=':'; )
|
|
pend++;
|
|
|
|
/* search for begin of file extension */
|
|
for(p=pend; p > path && *--p != '\\' && *p!='/'; )
|
|
if (*p == '.') {
|
|
pend = p;
|
|
break;
|
|
}
|
|
|
|
if (ext)
|
|
{
|
|
s=pend;
|
|
do{ *ext++ = *s; } while(*s++);
|
|
}
|
|
/* search for end of directory name */
|
|
for(p=pend; p > path; )
|
|
if (*--p == '\\' || *p == '/') {
|
|
p++;
|
|
break;
|
|
}
|
|
|
|
if (name) {
|
|
for(s=p; s<pend; )
|
|
*name++ = *s++;
|
|
|
|
*name = 0;
|
|
}
|
|
|
|
if (dir) {
|
|
for(s=path; s<p; )
|
|
*dir++ = *s++;
|
|
|
|
*dir = 0;
|
|
}
|
|
}
|
|
|
|
char *_strupr_(char *string)
|
|
{
|
|
char *s;
|
|
|
|
if (string)
|
|
{
|
|
for(s = string; *s; ++s)
|
|
*s = toupper(*s);
|
|
}
|
|
return string;
|
|
}
|
|
|
|
char *_strlwr_(char *string)
|
|
{
|
|
char *s;
|
|
|
|
if (string)
|
|
{
|
|
for (s = string; *s; ++s)
|
|
*s = tolower(*s);
|
|
}
|
|
return string;
|
|
}
|
|
|
|
char * StrToken (char *Source, char *TokenChar, int n)
|
|
{
|
|
char *BCX_RetStr={0};
|
|
char *RetVal;
|
|
char *Copy;
|
|
int Posn=0;
|
|
int Find=0;
|
|
int LenSrc=strlen(Source);
|
|
RetVal=(char*)calloc(LenSrc+1,1);
|
|
Copy=Source;
|
|
if(tally(Source,TokenChar)==0)
|
|
{
|
|
BCX_RetStr=BCX_TmpStr(1);
|
|
if(RetVal)free(RetVal);
|
|
return BCX_RetStr;
|
|
}
|
|
if(n==1)
|
|
{
|
|
BCX_RetStr=BCX_TmpStr(LenSrc);
|
|
strcpy(BCX_RetStr,(char*)extract(Source,TokenChar));
|
|
if(RetVal)free(RetVal);
|
|
return BCX_RetStr;
|
|
}
|
|
if(n>tally(Source,TokenChar)+1)
|
|
{
|
|
BCX_RetStr=BCX_TmpStr(1);
|
|
if(RetVal)free(RetVal);
|
|
return BCX_RetStr;
|
|
}
|
|
while(*Copy)
|
|
{
|
|
if(*Copy==TokenChar[0]) Find++;
|
|
if(Find==n) break;
|
|
Copy++;
|
|
Posn++;
|
|
}
|
|
if(n==tally(Source,TokenChar)+1)
|
|
{
|
|
Posn=LenSrc;
|
|
Copy=Source+Posn;
|
|
while(*Copy&&Source[Posn]!=TokenChar[0])
|
|
{
|
|
Posn--;
|
|
Copy--;
|
|
}
|
|
}
|
|
strcpy(RetVal,(char*)mid(Source,1,Posn));
|
|
strcpy(RetVal,(char*)mid(RetVal,InstrRev(RetVal,TokenChar)));
|
|
BCX_RetStr=BCX_TmpStr(LenSrc);
|
|
strcpy(BCX_RetStr,(char*)RemoveStr(RetVal,TokenChar));
|
|
if(RetVal)free(RetVal);
|
|
return BCX_RetStr;
|
|
}
|
|
|
|
|
|
char *iReplace (char *src, char *pat, char *rep)
|
|
{
|
|
size_t patsz, repsz, tmpsz, delta;
|
|
char *strtmp, *p, *q, *r;
|
|
if (!pat || !*pat)
|
|
{
|
|
strtmp = BCX_TmpStr(strlen(src));
|
|
if (!strtmp) return NULL;
|
|
return strcpy(strtmp, src);
|
|
}
|
|
repsz = strlen(rep);
|
|
patsz = strlen(pat);
|
|
for (tmpsz=0, p=src;(q=_stristr_(p,pat))!=0; p=q+patsz)
|
|
tmpsz += (size_t) (q - p) + repsz;
|
|
tmpsz += strlen(p);
|
|
strtmp = BCX_TmpStr(tmpsz);
|
|
if (!strtmp) return NULL;
|
|
for (r=strtmp,p=src;(q=_stristr_(p,pat))!=0;p=q+patsz)
|
|
{
|
|
delta = (size_t) (q-p);
|
|
memcpy(r,p,delta); r += delta;
|
|
strcpy(r,rep); r += repsz;
|
|
}
|
|
strcpy(r,p);
|
|
return strtmp;
|
|
}
|
|
|
|
|
|
int containedin(char * Token,char **Contain ,int c)
|
|
{
|
|
int i=0;
|
|
while(Contain[i][0])
|
|
{
|
|
if(0 == ((c == 0 || c == 2) ? strcmp(Contain[i],Token) : strcasecmp(Contain[i],Token)))
|
|
{
|
|
return ((c < 2) ? 0 : i);
|
|
}
|
|
i++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
// ************************************
|
|
// User Subs and Functions
|
|
// ************************************
|
|
|
|
|
|
int main (int argc, PCHAR* argv)
|
|
{
|
|
G_argc=argc;
|
|
G_argv=argv;
|
|
szTmp=(char*)calloc(256+65535,1);
|
|
Src=(char*)calloc(256+65535,1);
|
|
AbortSrc=(char*)calloc(256+65535,1);
|
|
WarnMsg=(char*)calloc(256+65535+1,1);
|
|
RmLibs=(char*)calloc(256+32767,1);
|
|
static int bitz;
|
|
memset(&bitz,0,sizeof(bitz));
|
|
ProtoCnt=0;
|
|
TranslateSlash=TRUE;
|
|
OkayToSend=TRUE;
|
|
Use_SingleFile=TRUE;
|
|
Use_StartupCode=FALSE;
|
|
StartNdx=0;
|
|
Use_ExitCode=FALSE;
|
|
ExitNdx=0;
|
|
*HFile=0;
|
|
*CmdLineFileOut=0;
|
|
*RmLibs=0;
|
|
InMain=TRUE;
|
|
TestState=FALSE;
|
|
*CmdLineConst=0;
|
|
bitz=sizeof(long)*8;
|
|
if(command(-1)[0]==0)
|
|
{
|
|
#if defined (__APPLE__)
|
|
printf("%s\n","MBC4: Ported to Mac OSX by Armando Rivera (c) 2009-2018");
|
|
#else
|
|
printf("%s\n","MBC4: Based on Linux BCX by Mike Henning (c) 2009");
|
|
printf("%s%s\n","(c) 2009-2018 Armando Rivera with additional code (c) 2009 John Jacques",LF);
|
|
#endif
|
|
printf("%s%s%s","Version ",Version," Compiled with ");
|
|
// FP3
|
|
#if defined __BCPLUSPLUS__// OUTFILE
|
|
printf("%s\n","Borland C++");
|
|
#elif defined __BORLANDC__
|
|
printf("%s\n","Borland C");
|
|
#elif defined __POCC__
|
|
printf("%s\n","Pelles C");
|
|
#elif defined __GNUG__
|
|
printf("%s\n","GNU G++");
|
|
#else
|
|
printf("%s\n","Unknown");
|
|
#endif // Main
|
|
if(bitz==64)
|
|
{
|
|
printf("\n");
|
|
printf("%s\n","********************");
|
|
printf("%s\n","** 64 BIT VERSION **");
|
|
printf("%s%s\n","********************",LF);
|
|
}
|
|
printf("%s%s%s\n"," Usage: ",AppExeName()," infile [.bas] [options]");
|
|
printf("%s\n"," [-c] Generate C++ Compatible code");
|
|
printf("%s%s%s\n"," [-d] DEFINE a constant ... ex. ",AppExeName()," MyFile -D:MyConst[=SomeValue]");
|
|
printf("%s\n"," [-e] Write ERRORS to BCX.ERR file");
|
|
printf("%s%s%s\n"," [-f] Output FILENAME... ex. ",AppExeName()," MyFile -f:/MyFiles/MyFile.c");
|
|
printf("%s\n"," [-k] KILL the generated BCX generated 'C' file");
|
|
printf("%s\n"," [-o] OUTPUT a copy of the generated C file to STDOUT");
|
|
printf("%s\n"," [-q] QUIET - No output to screen during translation");
|
|
printf("%s\n"," [-s] Show STATUS of translation by line number");
|
|
printf("%s\n"," [-w] Enable WARNINGS during translation");
|
|
printf("%s%s%s\n"," [-t] TURBO Mode ON w/optional size ... ex. ",AppExeName()," MyFile -t[:1024]");
|
|
printf("%s\n"," [-u] Turn UNICODE Support ON");
|
|
FreeGlobals();
|
|
fflush(stdout);
|
|
exit(0);
|
|
}
|
|
Quiet=FALSE;
|
|
{int i;
|
|
for(i=2; i<=argc-1; i+=1)
|
|
{
|
|
if(instr_b(lcase(argv[i]),"-f"))
|
|
{
|
|
strcpy(CmdLineFileOut,mid(argv[i],4));
|
|
}
|
|
if(instr_b(lcase(argv[i]),"-d"))
|
|
{
|
|
strcpy(CmdLineConst, join(3,CmdLineConst,mid(argv[i],4),chr(1)));
|
|
}
|
|
if(str_cmp(lcase(argv[i]),"-c")==0)
|
|
{
|
|
UseCpp=TRUE;
|
|
}
|
|
if(str_cmp(lcase(argv[i]),"-e")==0)
|
|
{
|
|
ErrFile=TRUE;
|
|
}
|
|
if(str_cmp(lcase(argv[i]),"-q")==0)
|
|
{
|
|
Quiet=TRUE;
|
|
}
|
|
if(str_cmp(lcase(argv[i]),"-k")==0)
|
|
{
|
|
KillCFile=TRUE;
|
|
}
|
|
if(str_cmp(lcase(argv[i]),"-o")==0)
|
|
{
|
|
ReDirect=TRUE;
|
|
}
|
|
if(str_cmp(lcase(argv[i]),"-s")==0)
|
|
{
|
|
ShowStatus=TRUE;
|
|
}
|
|
if(str_cmp(lcase(argv[i]),"-w")==0)
|
|
{
|
|
TestState=TRUE;
|
|
}
|
|
if(instr_b(lcase(argv[i]),"-t"))
|
|
{
|
|
Use_Turbo=TRUE;
|
|
TurboSize=VAL(mid(argv[i],4));
|
|
if(TurboSize!=0)
|
|
{
|
|
if((TurboSize&(TurboSize-1))!=0)
|
|
{
|
|
TurboSize=512;
|
|
Warning("Invalid $Turbo size - defaulting to 512");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TurboSize=512;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(ShowStatus)
|
|
{
|
|
cls();
|
|
}
|
|
if(!Quiet)
|
|
{
|
|
cls();
|
|
printf("%s%s\n","MBC Version ",Version);
|
|
#if defined (__APPLE__)
|
|
IsApple=TRUE;
|
|
printf("%s%s\n","MBC4: Ported to Mac OSX by Armando Rivera (c) 2009-2018",LF);
|
|
#else
|
|
printf("%s\n","MBC4: Based on Linux BCX by Mike Henning (c) 2009");
|
|
printf("%s%s\n","(c) 2009-2018 Armando Rivera with additional code (c) 2009 John Jacques",LF);
|
|
#endif
|
|
if(bitz==64)
|
|
{
|
|
printf("\n");
|
|
printf("%s\n","********************");
|
|
printf("%s\n","** 64 BIT VERSION **");
|
|
printf("%s%s\n","********************",LF);
|
|
}
|
|
}
|
|
if(inchr(command(1),"."))
|
|
{
|
|
strcpy(Cmd,command(1));
|
|
}
|
|
else
|
|
{
|
|
if(Exist(join(2,command(1),".bas")))
|
|
{
|
|
strcpy(Cmd, join(2,command(1),".bas"));
|
|
}
|
|
else if(Exist(join(2,command(1),".BAS")))
|
|
{
|
|
strcpy(Cmd, join(2,command(1),".BAS"));
|
|
}
|
|
}
|
|
if(!Exist(Cmd))
|
|
{
|
|
printf("\n");
|
|
printf("%s%s\n","FILE NOT FOUND: ",command(1));
|
|
FreeGlobals();
|
|
fflush(stdout);
|
|
exit(0);
|
|
}
|
|
strcpy(FileIn,Cmd);
|
|
if(CmdLineFileOut[0]==0)
|
|
{
|
|
strcpy(FileOut, join(2,left(Cmd,InstrRev(Cmd,".",0)-1),".cc"));
|
|
}
|
|
else
|
|
{
|
|
strcpy(FileOut,CmdLineFileOut);
|
|
}
|
|
strcpy(FileErr, join(2,left(Cmd,InstrRev(Cmd,".",0)-1),".ERR"));
|
|
if(Exist(FileErr))
|
|
{
|
|
remove (FileErr);
|
|
}
|
|
strcpy(prcFile,TempFileName(tempdir(),"prc"));
|
|
strcpy(udtFile,TempFileName(tempdir(),"udt"));
|
|
strcpy(datFile,TempFileName(tempdir(),"dat"));
|
|
strcpy(cstFile,TempFileName(tempdir(),"cst"));
|
|
strcpy(ovrFile,TempFileName(tempdir(),"ovr"));
|
|
strcpy(hdrFile,TempFileName(tempdir(),"hdr"));
|
|
strcpy(setFile,TempFileName(tempdir(),"set"));
|
|
strcpy(enuFile,TempFileName(tempdir(),"enu"));
|
|
if((SourceFile=fopen(FileIn,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",FileIn);
|
|
exit(1);
|
|
}
|
|
if((FP2=fopen(FileOut,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",FileOut);
|
|
exit(1);
|
|
}
|
|
Outfile=FP2;
|
|
if((FP3=fopen(prcFile,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",prcFile);
|
|
exit(1);
|
|
}
|
|
if((FP4=fopen(udtFile,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",udtFile);
|
|
exit(1);
|
|
}
|
|
if((FP5=fopen(datFile,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",datFile);
|
|
exit(1);
|
|
}
|
|
if((FP6=fopen(cstFile,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",cstFile);
|
|
exit(1);
|
|
}
|
|
if((FP7=fopen(hdrFile,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",hdrFile);
|
|
exit(1);
|
|
}
|
|
if((FP8=fopen(ovrFile,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",ovrFile);
|
|
exit(1);
|
|
}
|
|
if((FP9=fopen(setFile,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",setFile);
|
|
exit(1);
|
|
}
|
|
if((FP11=fopen(enuFile,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",enuFile);
|
|
exit(1);
|
|
}
|
|
ModuleNdx=1;
|
|
strcpy(Modules[ModuleNdx],FileIn);
|
|
ModuleLineNos[ModuleNdx]=0;
|
|
EmitProlog();
|
|
ClearIfThenStacks();
|
|
EmitCmdLineConst();
|
|
AddGlobal("G_argv",vt_PCHAR,0,"",1,0,0,0);
|
|
AddGlobal("G_argc",vt_INTEGER,0,"",0,0,0,0);
|
|
|
|
READSRCLINE:;
|
|
while(!EoF(SourceFile)||SplitCnt)
|
|
{
|
|
if(SplitCnt==0)
|
|
{
|
|
Src[0]=0;
|
|
AR_fgets_retval=fgets(Src,65535,SourceFile);
|
|
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
|
|
ModuleLineNos[ModuleNdx]++;
|
|
StripCode(Src);
|
|
if(*Src==0)
|
|
{
|
|
continue;
|
|
}
|
|
if(JoinLines(Src)==1)
|
|
{
|
|
continue;
|
|
}
|
|
if(inchr(Src,"["))
|
|
{
|
|
BracketHandler(Src,0);
|
|
}
|
|
if(SplitLines(Src))
|
|
{
|
|
strcpy(Src,SplitStk[++SplitCur]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
strcpy(Src,SplitStk[++SplitCur]);
|
|
}
|
|
if(SplitCur==SplitCnt)
|
|
{
|
|
SplitCur=SplitCnt=0;
|
|
}
|
|
if(*Src==0)
|
|
{
|
|
continue;
|
|
}
|
|
strcpy(AbortSrc,Src);
|
|
if(TrcFlag&&InFunc)
|
|
{
|
|
if(!iMatchLft(Src,"$trace"))
|
|
{
|
|
if(!iMatchLft(Src,"end ")&&instr_b(Src,"FUNCTION",0,1)==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n","// [",trim(Modules[ModuleNdx])," - ",trim(str(ModuleLineNos[ModuleNdx])),"] ",Src);
|
|
strcpy(Z,trim(Modules[ModuleNdx]));
|
|
strcpy(Z,replace(Z,"\\","\\\\"));
|
|
strcpy(Z, join(5," ",Z," - ",str(ModuleLineNos[ModuleNdx])," \\n"));
|
|
strcpy(Z, join(3,"printf(",enc(Z),");"));
|
|
fprintf(Outfile,"%s\n",Z);
|
|
}
|
|
}
|
|
}
|
|
if(SrcFlag)
|
|
{
|
|
if(!iMatchLft(Src,"$sourc")&&*Src!=33)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n","// [",trim(Modules[ModuleNdx])," - ",trim(str(ModuleLineNos[ModuleNdx])),"] ",Src);
|
|
}
|
|
}
|
|
if(ShowStatus)
|
|
{
|
|
locate (2,1,0);
|
|
printf("%s%s%s%d\n","Processing Module: ",trim(Modules[ModuleNdx])," - Line:",(int)ModuleLineNos[ModuleNdx]);
|
|
}
|
|
if(Src[0]==33)
|
|
{
|
|
Src[0]=32;
|
|
fprintf(Outfile,"%s\n",Src);
|
|
*Src=0;
|
|
}
|
|
if(*Src==0)
|
|
{
|
|
continue;
|
|
}
|
|
int di;
|
|
di=Directives();
|
|
if(di==0)
|
|
{
|
|
goto READNEXTLINE;
|
|
}
|
|
if(di==1)
|
|
{
|
|
goto READSRCLINE;
|
|
}
|
|
if(iMatchLft(Src,"set "))
|
|
{
|
|
ProcessSetCommand(0);
|
|
}
|
|
if(iMatchLft(Src,"sharedset "))
|
|
{
|
|
ProcessSetCommand(1);
|
|
}
|
|
PassOne=TRUE;
|
|
CheckParQuotes();
|
|
if(SpecialCaseHandler(Src))
|
|
{
|
|
continue;
|
|
}
|
|
Parse(Src);
|
|
PassOne=FALSE;
|
|
if(Ndx)
|
|
{
|
|
Emit();
|
|
}
|
|
|
|
READNEXTLINE:;
|
|
}
|
|
if(CmdLineConst[0]>0)
|
|
{
|
|
strcpy(Src, join(2,"CONST ",CmdLineConst));
|
|
Parse(Src);
|
|
Emit();
|
|
*CmdLineConst=0;
|
|
}
|
|
if(TestForBcxIni==FALSE)
|
|
{
|
|
TestForBcxIni=TRUE;
|
|
strcpy(szFile, join(2,curdir(),"\\bcx.ini"));
|
|
if(!Exist(szFile))
|
|
{
|
|
strcpy(szFile, join(2,AppExePath(),"bcx.ini"));
|
|
}
|
|
if(Exist(szFile))
|
|
{
|
|
PushFileIO();
|
|
if((SourceFile=fopen(szFile,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",szFile);
|
|
exit(1);
|
|
}
|
|
strcpy(Modules[++ModuleNdx],szFile);
|
|
ModuleLineNos[ModuleNdx]=0;
|
|
goto READSRCLINE;
|
|
}
|
|
}
|
|
fflush(Outfile);
|
|
if(FPtrNdx)
|
|
{
|
|
PopFileIO();
|
|
goto READSRCLINE;
|
|
}
|
|
if(Use_GenFree&&GlobalDynaCnt)
|
|
{
|
|
MakeFreeGlobals();
|
|
}
|
|
ExportInternalConst();
|
|
EmitEpilog();
|
|
CloseAll();
|
|
AddProtos();
|
|
DeclareVariables();
|
|
AddFuncs();
|
|
CloseAll();
|
|
if(UseCpp&&str_cmp(CmdLineFileOut,"")==0)
|
|
{
|
|
strcpy(szTmp, join(2,extract(FileOut,"."),".cpp"));
|
|
remove (szTmp);
|
|
rename (FileOut,szTmp);
|
|
strcpy(FileOut,szTmp);
|
|
}
|
|
if(Use_Osx&&str_cmp(CmdLineFileOut,"")==0)
|
|
{
|
|
strcpy(szTmp, join(2,extract(FileOut,"."),".mm"));
|
|
remove (szTmp);
|
|
rename (FileOut,szTmp);
|
|
strcpy(FileOut,szTmp);
|
|
}
|
|
if((FP1=fopen(FileOut,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",FileOut);
|
|
exit(1);
|
|
}
|
|
if((FP2=fopen(hdrFile,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",hdrFile);
|
|
exit(1);
|
|
}
|
|
if((FP3=fopen("$temp$","w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n","$temp$");
|
|
exit(1);
|
|
}
|
|
DoCountLines=TRUE;
|
|
fprintf(FP3,"%s\n","// *********************************************************************");
|
|
fprintf(FP3,"%s%s%s\n","// Created with MBC (V) ",Version,"Ported to OSX by Armando Rivera");
|
|
fprintf(FP3,"%s\n","// Ported from BCX32 BASIC To C/C++ Translator (V) 5.12");
|
|
fprintf(FP3,"%s\n","// BCX (c) 1999 - 2018 by Kevin Diggins");
|
|
fprintf(FP3,"%s\n","// LinuxBC (c) 2009 by Mike Henning ");
|
|
fprintf(FP3,"%s\n","// MBC (c) 2009 - 2018 by Armando Rivera");
|
|
fprintf(FP3,"%s\n","// *********************************************************************");
|
|
fprintf(FP3,"%s\n","// Translated for compiling with the g++ Compiler");
|
|
if(UseCpp)
|
|
{
|
|
fprintf(FP3,"%s\n","// g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$.cpp -ldl -o $FILE$");
|
|
}
|
|
else
|
|
{
|
|
fprintf(FP3,"%s\n","// g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$.cc -ldl -o $FILE$");
|
|
}
|
|
fprintf(FP3,"%s\n","// *********************************************************************");
|
|
if(NoRT==FALSE)
|
|
{
|
|
if(Use_Osx)
|
|
{
|
|
fprintf(FP3,"%s\n","#import <Cocoa/Cocoa.h>");
|
|
}
|
|
/*****2010-11-24AddedWxCFORWXCONSOLEApps-AIR*****/;
|
|
if(Use_Wx||Use_WxC)
|
|
{
|
|
fprintf(FP3,"%s\n","// WXWIDGETS HEADER FILES //");
|
|
fprintf(FP3,"%s\n","#include <wx/wx.h>");
|
|
fprintf(FP3,"%s\n","#include <wx/process.h>");
|
|
fprintf(FP3,"%s\n","#include <wx/txtstrm.h>");
|
|
fprintf(FP3,"%s\n","#include <wx/msgdlg.h>");
|
|
fprintf(FP3,"%s\n","#include <wx/stdpaths.h>");
|
|
fprintf(FP3,"%s\n","#include <wx/event.h>");
|
|
fprintf(FP3,"%s\n","// ******************* //");
|
|
fprintf(FP3,"%s\n","");
|
|
}
|
|
if(Use_Gtk)
|
|
{
|
|
fprintf(FP3,"%s\n","#include <gtk/gtk.h>");
|
|
}
|
|
if(Use_Glib)
|
|
{
|
|
fprintf(FP3,"%s\n","#include <glib.h>");
|
|
}
|
|
fprintf(FP3,"%s\n","#include <stdbool.h>");
|
|
fprintf(FP3,"%s\n","#include <ctype.h>");
|
|
fprintf(FP3,"%s\n","#include <math.h>");
|
|
fprintf(FP3,"%s\n","#include <stdio.h>");
|
|
fprintf(FP3,"%s\n","#include <iostream>");
|
|
fprintf(FP3,"%s\n","#include <fstream>");
|
|
fprintf(FP3,"%s\n","#include <string.h>");
|
|
fprintf(FP3,"%s\n","#include <stddef.h>");
|
|
fprintf(FP3,"%s\n","#include <stdlib.h>");
|
|
fprintf(FP3,"%s\n","#include <setjmp.h>");
|
|
fprintf(FP3,"%s\n","#include <time.h>");
|
|
fprintf(FP3,"%s\n","#include <stdarg.h>");
|
|
fprintf(FP3,"%s\n","#include <dirent.h>");
|
|
fprintf(FP3,"%s\n","#include <sys/types.h>");
|
|
fprintf(FP3,"%s\n","#include <sys/stat.h>");
|
|
fprintf(FP3,"%s\n","#include <sys/wait.h>");
|
|
fprintf(FP3,"%s\n","#include <unistd.h>");
|
|
fprintf(FP3,"%s\n","#include <dlfcn.h>");
|
|
#if defined (__APPLE__)
|
|
fprintf(FP3,"%s\n","#include <libproc.h>");
|
|
#endif
|
|
if(UseCpp)
|
|
{
|
|
fprintf(FP3,"%s\n","#include <iostream>");
|
|
fprintf(FP3,"%s\n","#include <fstream>");
|
|
}
|
|
if(Use_Instat)
|
|
{
|
|
Use_Keypress=TRUE;
|
|
fprintf(FP3,"%s\n","#include <fcntl.h>");
|
|
}
|
|
if(Use_Keypress)
|
|
{
|
|
fprintf(FP3,"%s\n","#include <term.h>");
|
|
}
|
|
if(Use_Socket)
|
|
{
|
|
fprintf(FP3,"%s\n","#include <sys/socket.h>");
|
|
fprintf(FP3,"%s\n","#include <netinet/in.h>");
|
|
fprintf(FP3,"%s\n","#include <netdb.h>");
|
|
fprintf(FP3,"%s\n","#include <errno.h>");
|
|
fprintf(FP3,"%s\n","#include <arpa/inet.h>");
|
|
}
|
|
if(Use_RegEx)
|
|
{
|
|
fprintf(FP3,"%s\n","#include <regex.h>");
|
|
}
|
|
fprintf(FP3,"%s\n","");
|
|
EmitCompilerDefines();
|
|
}
|
|
while(!EoF(FP2))
|
|
{
|
|
Z[0]=0;
|
|
AR_fgets_retval=fgets(Z,65535,FP2);
|
|
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
|
|
fprintf(FP3,"%s\n",Z);
|
|
}
|
|
char Lastlyne[2048];
|
|
*Lastlyne=0;
|
|
while(!EoF(FP1))
|
|
{
|
|
static int bMainOut=0;
|
|
Z[0]=0;
|
|
AR_fgets_retval=fgets(Z,65535,FP1);
|
|
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
|
|
if(iMatchLft(Lastlyne,"#if"))
|
|
{
|
|
if(iMatchLft(Z,"#endif"))
|
|
{
|
|
*Lastlyne=0;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
fprintf(FP3,"%s\n",Lastlyne);
|
|
}
|
|
}
|
|
strcpy(Lastlyne,Z);
|
|
if(iMatchLft(Lastlyne,"#if"))
|
|
{
|
|
continue;
|
|
}
|
|
fprintf(FP3,"%s\n",Z);
|
|
if(bMainOut)
|
|
{
|
|
continue;
|
|
}
|
|
if(str_cmp(left(ltrim(Z),8),"int main")==0)
|
|
{
|
|
while(str_cmp(trim(Z),"{")!=0)
|
|
{
|
|
Z[0]=0;
|
|
AR_fgets_retval=fgets(Z,65535,FP1);
|
|
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
|
|
fprintf(FP3,"%s\n",Z);
|
|
}
|
|
if(Use_StartupCode)
|
|
{
|
|
fprintf(FP3,"%s%s\n",Scoot,"int BCX_SUCode = BCX_StartupCode_(); // execute user's startup code");
|
|
}
|
|
if(Use_ExitCode)
|
|
{
|
|
fprintf(FP3,"%s%s\n",Scoot,"int BCX_EXCode = BCX_ExitCode_(); // Prepare for user's exit code");
|
|
}
|
|
bMainOut++;
|
|
}
|
|
}
|
|
DoCountLines=FALSE;
|
|
CloseAll();
|
|
remove (hdrFile);
|
|
remove (FileOut);
|
|
rename ("$temp$",FileOut);
|
|
if(ShowStatus)
|
|
{
|
|
locate (2,1,1);
|
|
}
|
|
if(!Quiet)
|
|
{
|
|
LinesRead+=(ModuleLineNos[1]);
|
|
Elapsed=Round((float)clock()/(float)CLOCKS_PER_SEC,2);
|
|
printf("%s%d%s%d%s","[Lines In:",(int)LinesRead,"] [Lines Out:",(int)gLinesWritten,"] ");
|
|
printf("%s%d%s%.7G%s\n","[Statements:",(int)Statements,"] [Time:",(float)Elapsed," sec's]");
|
|
strcpy(Z, join(4,"BCX translated ",RemoveStr(FileIn," ")," to ",RemoveStr(FileOut," ")));
|
|
printf("%s\n",Z);
|
|
}
|
|
PostProcess();
|
|
if(WarnMsg[0]>0)
|
|
{
|
|
printf("%s%s%s\n","Warnings! :",CRLF,WarnMsg);
|
|
}
|
|
if(KillCFile)
|
|
{
|
|
remove (FileOut);
|
|
}
|
|
FreeGlobals();
|
|
return 0;
|
|
}
|
|
|
|
|
|
void EmitCmdLineConst (void)
|
|
{
|
|
if(CmdLineConst[0]>0)
|
|
{
|
|
static FILE* Ftmp;
|
|
fprintf(FP7,"%s\n","");
|
|
fprintf(FP7,"%s\n","// ***************************************************");
|
|
fprintf(FP7,"%s\n","// Commandline Defines");
|
|
fprintf(FP7,"%s\n","// ***************************************************");
|
|
fprintf(FP7,"%s\n","");
|
|
Ftmp=FP6;
|
|
FP6=FP7;
|
|
{int i;
|
|
for(i=1; i<=tally(CmdLineConst,chr(1)); i+=1)
|
|
{
|
|
strcpy(Src,StrToken(CmdLineConst,chr(1),i));
|
|
if(Src[0]==0)
|
|
{
|
|
break;
|
|
}
|
|
strcpy(Src, join(2,"CONST ",Src));
|
|
Parse(Src);
|
|
Emit();
|
|
}
|
|
}
|
|
*CmdLineConst=0;
|
|
FP6=Ftmp;
|
|
fprintf(FP7,"%s\n","");
|
|
}
|
|
}
|
|
|
|
|
|
void EmitCompilerDefines (void)
|
|
{
|
|
fprintf(FP3,"%s\n","");
|
|
fprintf(FP3,"%s\n","// ***************************************************");
|
|
fprintf(FP3,"%s\n","// Compiler Defines");
|
|
fprintf(FP3,"%s\n","// ***************************************************");
|
|
fprintf(FP3,"%s%s\n"," #define C_EXPORT extern ",enc("C"));
|
|
fprintf(FP3,"%s%s\n"," #define C_IMPORT extern ",enc("C"));
|
|
fprintf(FP3,"%s\n","");
|
|
fprintf(FP3,"%s\n","#ifndef stat");
|
|
fprintf(FP3,"%s\n"," #define lstat stat");
|
|
fprintf(FP3,"%s\n","#endif");
|
|
fprintf(FP3,"%s\n","#ifndef _fcloseall");
|
|
fprintf(FP3,"%s\n"," #define _fcloseall _fcloseall");
|
|
fprintf(FP3,"%s\n","#endif");
|
|
fprintf(FP3,"%s\n","#ifndef HWND");
|
|
fprintf(FP3,"%s\n"," #define HWND GHWND");
|
|
fprintf(FP3,"%s\n","#endif");
|
|
fprintf(FP3,"%s\n","#ifndef MAX_PATH");
|
|
fprintf(FP3,"%s\n"," #define MAX_PATH 2048");
|
|
fprintf(FP3,"%s\n","#endif");
|
|
fprintf(FP3,"%s\n","#ifndef CALLBACK");
|
|
fprintf(FP3,"%s\n"," #define CALLBACK");
|
|
fprintf(FP3,"%s\n","#endif");
|
|
fprintf(FP3,"%s\n","typedef unsigned int HINSTANCE;");
|
|
fprintf(FP3,"%s\n","typedef void* LPVOID;");
|
|
fprintf(FP3,"%s\n","typedef char* PCHAR;");
|
|
fprintf(FP3,"%s\n","typedef unsigned char BYTE;");
|
|
fprintf(FP3,"%s\n","typedef unsigned int UINT;");
|
|
fprintf(FP3,"%s\n","typedef unsigned char UCHAR;");
|
|
fprintf(FP3,"%s\n","typedef unsigned char* PUCHAR;");
|
|
fprintf(FP3,"%s\n","typedef unsigned long ULONG;");
|
|
fprintf(FP3,"%s\n","typedef unsigned long* ULONG_PTR;");
|
|
fprintf(FP3,"%s\n","typedef unsigned long DWORD;");
|
|
fprintf(FP3,"%s\n","");
|
|
fprintf(FP3,"%s\n","#ifndef TRUE");
|
|
fprintf(FP3,"%s\n"," #define TRUE 1");
|
|
fprintf(FP3,"%s\n","#endif");
|
|
fprintf(FP3,"%s\n","");
|
|
fprintf(FP3,"%s\n","#ifndef FALSE");
|
|
fprintf(FP3,"%s\n"," #define FALSE 0");
|
|
fprintf(FP3,"%s\n","#endif");
|
|
if(!Use_Osx)
|
|
{
|
|
fprintf(FP3,"%s\n","#define BOOL bool");
|
|
}
|
|
fprintf(FP3,"%s\n","");
|
|
if(UseCpp)
|
|
{
|
|
fprintf(FP3,"%s\n","#define println(a) (std::cout << a << std::endl)");
|
|
fprintf(FP3,"%s\n"," typedef std::string CSTRING;");
|
|
fprintf(FP3,"%s\n"," typedef std::fstream CFILE;");
|
|
}
|
|
}
|
|
|
|
|
|
void MakeFreeGlobals (void)
|
|
{
|
|
strcpy(Src,"SUB FreeGlobals");
|
|
PassOne=1;
|
|
Parse(Src);
|
|
Emit();
|
|
while(GlobalDynaCnt)
|
|
{
|
|
fprintf(Outfile,"%s%s\n"," ",GlobalDynaStr[GlobalDynaCnt]);
|
|
GlobalDynaCnt--;
|
|
}
|
|
strcpy(Src,"END SUB");
|
|
PassOne=1;
|
|
Parse(Src);
|
|
Emit();
|
|
}
|
|
|
|
|
|
void ProcessSetCommand (int GS)
|
|
{
|
|
int i;
|
|
int ii;
|
|
int j;
|
|
int SetString=0;
|
|
char CVar[2048];
|
|
int vt;
|
|
static FILE *SaveFP;
|
|
memset(&SaveFP,0,sizeof(SaveFP));
|
|
SaveFP=Outfile;
|
|
if(!InFunc)
|
|
{
|
|
Outfile=FP9;
|
|
}
|
|
if(inchr(Src,"$")&&tally(Src,"[")>1)
|
|
{
|
|
strcpy(Src,strim(Src));
|
|
strcpy(Src,IRemoveStr(Src,"as string"));
|
|
strcpy(Src,IRemoveStr(Src,"as char"));
|
|
strcat(Src," AS char");
|
|
}
|
|
strcat(Src,"=");
|
|
PassOne=1;
|
|
Parse(Src);
|
|
*Tipe=0;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"as"))
|
|
{
|
|
strcpy(Tipe,Stk[i+1]);
|
|
*Stk[i]=0;
|
|
*Stk[i+1]=0;
|
|
break;
|
|
}
|
|
}
|
|
if(Tipe[0]==0)
|
|
{
|
|
strcpy(szTmp,Stk[2]);
|
|
SetString=DataType(Stk[2]);
|
|
j=SetString;
|
|
VarCode.Method=mt_ProcessSetCommand;
|
|
strcpy(VarCode.Token,szTmp);
|
|
VarCode.VarNo=j;
|
|
GetVarCode( &VarCode);
|
|
if(GS)
|
|
{
|
|
fprintf(Outfile,"%s%s",Scoot,RemoveStr(VarCode.StaticOut,"static "));
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s",Scoot,VarCode.StaticOut);
|
|
}
|
|
char lszTmp[65535];
|
|
*lszTmp=0;
|
|
strcpy(CVar,Clean(Stk[2]));
|
|
ValidVar(CVar);
|
|
vt=DataType(Stk[2]);
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcat(lszTmp,Stk[i]);
|
|
}
|
|
if(vt==vt_STRVAR&&str_cmp(lszTmp,"")!=0)
|
|
{
|
|
strcat(lszTmp,"[65535]");
|
|
}
|
|
if(!InFunc)
|
|
{
|
|
AddGlobal(CVar,vt,0,lszTmp,0,0,0,1);
|
|
}
|
|
else
|
|
{
|
|
AddLocal(CVar,vt,0,lszTmp,0,0,1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
strcpy(CVar,Clean(Stk[2]));
|
|
if(GS)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s",Scoot,Tipe," ",CVar);
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s",Scoot,"static ",Tipe," ",CVar);
|
|
}
|
|
char DimType[2048];
|
|
int IsPointer;
|
|
int id;
|
|
strcpy(DimType,RemoveStr(Tipe,"*"));
|
|
GetTypeInfo(Tipe, &IsPointer, &id, &vt);
|
|
if(vt==vt_STRVAR)
|
|
{
|
|
strcat(DimType,"[65535]");
|
|
}
|
|
if(!InFunc)
|
|
{
|
|
AddGlobal(CVar,vt,id,DimType,IsPointer,0,0,1);
|
|
}
|
|
else
|
|
{
|
|
AddLocal(CVar,vt,id,DimType,IsPointer,0,1);
|
|
}
|
|
}
|
|
i=2;
|
|
j=0;
|
|
for(;;)
|
|
{
|
|
i++;
|
|
if(str_cmp(Stk[i],"=")==0)
|
|
{
|
|
j=1;
|
|
}
|
|
if(SetString==vt_STRVAR&&j==1)
|
|
{
|
|
fprintf(Outfile,"%s","[65535]=");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s",Stk[i]);
|
|
}
|
|
if(str_cmp(Stk[i],"=")==0)
|
|
{
|
|
break;
|
|
}
|
|
if(i==Ndx)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","{");
|
|
while(!EoF(SourceFile))
|
|
{
|
|
Src[0]=0;
|
|
AR_fgets_retval=fgets(Src,65535,SourceFile);
|
|
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
|
|
ModuleLineNos[ModuleNdx]++;
|
|
StripCode(Src);
|
|
if(JoinLines(Src)==1)
|
|
{
|
|
continue;
|
|
}
|
|
PassOne=TRUE;
|
|
XParse(Src);
|
|
PassOne=FALSE;
|
|
TokenSubstitutions();
|
|
if(iMatchLft(Src,"end "))
|
|
{
|
|
break;
|
|
}
|
|
if(strlen(Src))
|
|
{
|
|
fprintf(Outfile,"%s"," ");
|
|
for(ii=1; ii<=Ndx; ii+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[ii]));
|
|
}
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n","};\n");
|
|
*Src=0;
|
|
Outfile=SaveFP;
|
|
}
|
|
|
|
|
|
int Directives (void)
|
|
{
|
|
char lszTmp[2048];
|
|
int i;
|
|
char COutputFile[2048];
|
|
if(*Src==35||*Src==36)
|
|
{
|
|
strcpy(Z,rtrim(lcase(left(Src,6))));
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Z,"$proje")==0)
|
|
{
|
|
NoRT=TRUE;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$accel")==0)
|
|
{
|
|
XParse(Src);
|
|
strcpy(Accelerator,RemoveStr(Stk[2],DQ));
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$bcxve")==0)
|
|
{
|
|
strcpy(Src,trim(mid(Src,12)));
|
|
strcpy(Src,RemoveStr(Src,DQ));
|
|
if(str_cmp(lcase(Version),lcase(Src))==-1)
|
|
{
|
|
Abort(join(10,CRLF,"Your Translator needs updating.",CRLF,"This program ",enc(Modules[ModuleNdx])," requires BCX Version: ",Src," or later.",CRLF,CRLF));
|
|
}
|
|
else
|
|
{
|
|
printf("%s\n","");
|
|
printf("%s%s\n","Program written for BCX Version ",Src);
|
|
printf("%s\n","");
|
|
}
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$compi")==0)
|
|
{
|
|
PassOne=1;
|
|
XParse(Src);
|
|
PassOne=0;
|
|
strcpy(Compiler,Stk[2]);
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$execo")==0)
|
|
{
|
|
static char SrcExt[2048];
|
|
memset(&SrcExt,0,sizeof(SrcExt));
|
|
PassOne=1;
|
|
XParse(Src);
|
|
PassOne=0;
|
|
XitCount++;
|
|
if(UseCpp)
|
|
{
|
|
strcpy(SrcExt,".cpp");
|
|
}
|
|
else if(Use_Osx)
|
|
{
|
|
strcpy(SrcExt,".mm");
|
|
}
|
|
else
|
|
{
|
|
strcpy(SrcExt,".cc");
|
|
}
|
|
if(MakeDLL)
|
|
{
|
|
strcpy(Xit[XitCount], join(7,"g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$",SrcExt," -ldl ",LD_FLAGS,SPC,Stk[2]," -o lib$FILE$.so"));
|
|
*SrcExt=0;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(Use_IOS)
|
|
{
|
|
static char IOS_COMPILER[2048];
|
|
memset(&IOS_COMPILER,0,sizeof(IOS_COMPILER));
|
|
strcpy(IOS_COMPILER,"/Developer/Platforms/iPhoneOS.platform/Developer/usr/bin/g++");
|
|
if(strlen(Stk[2])>0)
|
|
{
|
|
strcpy(Xit[XitCount], join(8,IOS_COMPILER," -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$",SrcExt," -ldl ",LD_FLAGS,SPC,Stk[2]," -o $FILE$"));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Xit[XitCount], join(6,IOS_COMPILER," -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$",SrcExt," -ldl ",LD_FLAGS," -o $FILE$"));
|
|
}
|
|
*SrcExt=0;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(strlen(Stk[2])>0)
|
|
{
|
|
strcpy(Xit[XitCount], join(7,"g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$",SrcExt," -ldl ",LD_FLAGS,SPC,Stk[2]," -o $FILE$"));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Xit[XitCount], join(5,"g++ -Wformat -D_FORTIFY_SOURCE=2 -Wno-write-strings $FILE$",SrcExt," -ldl ",LD_FLAGS," -o $FILE$"));
|
|
}
|
|
*SrcExt=0;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$exest")==0)
|
|
{
|
|
PassOne=1;
|
|
XParse(Src);
|
|
PassOne=0;
|
|
XitCount++;
|
|
if(IsApple)
|
|
{
|
|
strcpy(Xit[XitCount],"strip $FILE$");
|
|
}
|
|
else
|
|
{
|
|
strcpy(Xit[XitCount],"strip -s -R .comment -R .note -R .note.ABI-tag $FILE$");
|
|
}
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$genfr")==0)
|
|
{
|
|
Use_GenFree=TRUE;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$osx")==0)
|
|
{
|
|
Use_Osx=TRUE;
|
|
strcpy(LD_FLAGS,join(2,LD_FLAGS," -fobjc-arc -framework Cocoa"));
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$ios")==0)
|
|
{
|
|
#if !defined __APPLE__
|
|
Abort(join(3,CRLF,"The $IOS Directive REQUIRES an Apple OSX Operating System",CRLF));
|
|
#endif
|
|
Use_IOS=TRUE;
|
|
PassOne=1;
|
|
XParse(Src);
|
|
PassOne=0;
|
|
strcpy(LD_FLAGS,join(2,LD_FLAGS," -arch armv6 -arch armv7 -mthumb -isysroot /Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS4.2.sdk -framework Foundation -framework CoreFoundation"));
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$gtk")==0)
|
|
{
|
|
Use_Gtk=TRUE;
|
|
strcpy(LD_FLAGS,join(2,LD_FLAGS," $(pkg-config --libs --cflags gtk+-2.0)"));
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$ldfla")==0)
|
|
{
|
|
strcpy(LD_FLAGS,join(2,LD_FLAGS,remain(Src," ")));
|
|
return 0;
|
|
/*****2010-11-24AddedWxCFORWXCONSOLEApps-AIR*****/;
|
|
break;
|
|
}
|
|
if(str_cmp(Z,"$wxc")==0)
|
|
{
|
|
Use_WxC=UseCpp=NoMain=TRUE;
|
|
strcpy(LD_FLAGS,join(2,LD_FLAGS," $(wx-config --libs --cppflags)"));
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$wx")==0)
|
|
{
|
|
Use_Wx=UseCpp=NoMain=TRUE;
|
|
strcpy(LD_FLAGS,join(2,LD_FLAGS," $(wx-config --libs --cppflags)"));
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$glib")==0)
|
|
{
|
|
Use_Glib=TRUE;
|
|
strcpy(LD_FLAGS,join(2,LD_FLAGS," $(pkg-config --libs --cflags glib-2.0)"));
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$noini")==0)
|
|
{
|
|
*Src=0;
|
|
TestForBcxIni=TRUE;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$linke")==0)
|
|
{
|
|
PassOne=1;
|
|
XParse(Src);
|
|
PassOne=0;
|
|
strcpy(Linker,Stk[2]);
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$onexi")==0)
|
|
{
|
|
PassOne=1;
|
|
XParse(Src);
|
|
PassOne=0;
|
|
XitCount++;
|
|
strcpy(Xit[XitCount],Stk[2]);
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$onent")==0)
|
|
{
|
|
PassOne=1;
|
|
XParse(Src);
|
|
PassOne=0;
|
|
EntryCnt++;
|
|
strcpy(Entry[EntryCnt],Stk[2]);
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$pack")==0 || str_cmp(Z,"$pack(")==0)
|
|
{
|
|
strcpy(Src,mid(Src,6));
|
|
fprintf(FP4,"%s%s\n","#pragma pack ",ltrim(Src));
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$nodll")==0)
|
|
{
|
|
NoDllMain=TRUE;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$pelle")==0)
|
|
{
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$stdca")==0)
|
|
{
|
|
UseStdCall=TRUE;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$iprin")==0)
|
|
{
|
|
if(instr_b(lcase(Src),"_on"))
|
|
{
|
|
TranslateSlash=TRUE;
|
|
}
|
|
else
|
|
{
|
|
TranslateSlash=FALSE;
|
|
}
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$nomai")==0)
|
|
{
|
|
NoMain=TRUE;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$test")==0)
|
|
{
|
|
TestState=!TestState;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$typed")==0)
|
|
{
|
|
fprintf(FP7,"%s%s%s\n","typedef ",remain(Src," "),";");
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$resou")==0)
|
|
{
|
|
static char resAlias[2048];
|
|
memset(&resAlias,0,sizeof(resAlias));
|
|
static char resFile[2048];
|
|
memset(&resFile,0,sizeof(resFile));
|
|
Use_Embed=TRUE;
|
|
PassOne=1;
|
|
XParse(Src);
|
|
PassOne=0;
|
|
EntryCnt++;
|
|
strcpy(Entry[EntryCnt], join(5,"ld -r -b binary ",Stk[2]," -o ",Stk[2],".o"));
|
|
strcpy(Stk[2],replace(Stk[2],".","_"));
|
|
strcpy(resFile,RemoveStr(Stk[2],DQ));
|
|
strcpy(resAlias,RemoveStr(Stk[3],DQ));
|
|
AddGlobal(join(3,"_binary_",resFile,"_start"),vt_INTEGER,0,"",0,0,1,0);
|
|
AddGlobal(join(3,"_binary_",resFile,"_size"),vt_INTEGER,0,"",0,0,1,0);
|
|
strcpy(Src, join(5,"CONST ",resAlias,"= &_binary_",resFile,"_start"));
|
|
Parse(Src);
|
|
Emit();
|
|
strcpy(Src, join(5,"CONST ",resAlias,"_SIZE = (int)&_binary_",resFile,"_size"));
|
|
Parse(Src);
|
|
Emit();
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$turbo")==0)
|
|
{
|
|
strcpy(Src,ltrim(mid(Src,7)));
|
|
if(*Src!=0)
|
|
{
|
|
TurboSize=VAL(Src);
|
|
if((TurboSize&(TurboSize-1))!=0)
|
|
{
|
|
TurboSize=512;
|
|
Warning("Invalid $Turbo size - defaulting to 512");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TurboSize=512;
|
|
}
|
|
Use_Turbo=TRUE;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$sourc")==0)
|
|
{
|
|
SrcFlag=!SrcFlag;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$fssta")==0)
|
|
{
|
|
Use_Static=!Use_Static;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$trace")==0)
|
|
{
|
|
TrcFlag=!TrcFlag;
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$inclu")==0 || str_cmp(Z,"$modul")==0)
|
|
{
|
|
char orgfileName[2048];
|
|
strcpy(szFile,trim(RemoveStr(mid(Src,9),DQ)));
|
|
strcpy(orgfileName,szFile);
|
|
if(str_cmp(left(szFile,1),"<")==0)
|
|
{
|
|
strcpy(szFile,mid(szFile,2,strlen(szFile)-2));
|
|
strcpy(szFile, join(2,Environ("BCXLIB"),szFile));
|
|
}
|
|
if(!Exist(szFile))
|
|
{
|
|
strcpy(szFile,BcxSplitPath(szFile,FNAME|FEXT));
|
|
strcpy(szFile, join(2,BcxSplitPath(FileIn,FDRV|FPATH),szFile));
|
|
}
|
|
if(!Exist(szFile))
|
|
{
|
|
Abort(join(2,"Unable to locate ",orgfileName));
|
|
}
|
|
PushFileIO();
|
|
if((SourceFile=fopen(szFile,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",szFile);
|
|
exit(1);
|
|
}
|
|
strcpy(Modules[++ModuleNdx],szFile);
|
|
ModuleLineNos[ModuleNdx]=0;
|
|
return 1;
|
|
}
|
|
if(str_cmp(Z,"$try")==0)
|
|
{
|
|
fprintf(Outfile,"%s\n","try {");
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$throw")==0)
|
|
{
|
|
strcpy(szTmp,mid(Src,8));
|
|
if(szTmp[0]==0)
|
|
{
|
|
strcpy(szTmp,enc("An Exception has occured!"));
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"throw ",szTmp,";");
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$catch")==0)
|
|
{
|
|
strcpy(szTmp,mid(Src,8));
|
|
if(szTmp[0]==0)
|
|
{
|
|
strcpy(szTmp,"char *str");
|
|
}
|
|
fprintf(Outfile,"%s\n","}");
|
|
fprintf(Outfile,"%s%s%s\n","catch (",szTmp,")");
|
|
fprintf(Outfile,"%s\n","{");
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$endtr")==0)
|
|
{
|
|
fprintf(Outfile,"%s\n","}");
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$endna")==0)
|
|
{
|
|
InNameSpace--;
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$names")==0)
|
|
{
|
|
Abort("$NAMESPACE/$ENDNAMESPACE have been removed from this version. Use NAMESPACE / END NAMESPACE instead.");
|
|
break;
|
|
}
|
|
if(str_cmp(Z,"$usena")==0)
|
|
{
|
|
UseCpp=TRUE;
|
|
strcpy(szTmp,mid(Src,inchr(Src," ")+1));
|
|
if(str_cmp(right(trim(szTmp),1),";")!=0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n","using namespace ",szTmp,";");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s\n","using namespace ",szTmp);
|
|
}
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$class")==0)
|
|
{
|
|
Abort("$CLASS has been removed from this version. Use CLASS instead.");
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$inter")==0)
|
|
{
|
|
static int BeenHere;
|
|
UseCpp=TRUE;
|
|
strcpy(szTmp,remain(Src,SPC));
|
|
if(!BeenHere)
|
|
{
|
|
BeenHere++;
|
|
fprintf(FP4,"%s\n","#ifndef __cplusplus");
|
|
fprintf(FP4,"%s\n"," #error A C++ compiler is required");
|
|
fprintf(FP4,"%s\n","#endif");
|
|
}
|
|
fprintf(FP4,"%s%s%s\n","interface ",szTmp," {");
|
|
for(;;)
|
|
{
|
|
if(EoF(SourceFile))
|
|
{
|
|
Abort("$Interface Without $EndInterface");
|
|
}
|
|
Src[0]=0;
|
|
AR_fgets_retval=fgets(Src,65535,SourceFile);
|
|
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
|
|
ModuleLineNos[ModuleNdx]++;
|
|
if(iMatchLft(ltrim(Src),"$endinterface"))
|
|
{
|
|
break;
|
|
}
|
|
fprintf(FP4,"%s\n",Src);
|
|
}
|
|
fprintf(FP4,"%s%s%s\n","}",trim(join(2,Src,13)),";");
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$comme")==0)
|
|
{
|
|
*Src=0;
|
|
for(;;)
|
|
{
|
|
if(EoF(SourceFile))
|
|
{
|
|
Abort("Unbalanced $Comment");
|
|
}
|
|
Src[0]=0;
|
|
AR_fgets_retval=fgets(Src,65535,SourceFile);
|
|
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
|
|
ModuleLineNos[ModuleNdx]++;
|
|
StripTabs();
|
|
if(iMatchLft(ltrim(Src),"$comment"))
|
|
{
|
|
break;
|
|
}
|
|
fprintf(Outfile,"%s%s\n","// ",Src);
|
|
}
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$ccode")==0)
|
|
{
|
|
*Src=0;
|
|
for(;;)
|
|
{
|
|
if(EoF(SourceFile))
|
|
{
|
|
Abort("Unbalanced $Ccode");
|
|
}
|
|
Src[0]=0;
|
|
AR_fgets_retval=fgets(Src,65535,SourceFile);
|
|
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
|
|
ModuleLineNos[ModuleNdx]++;
|
|
StripTabs();
|
|
if(iMatchLft(ltrim(Src),"$ccode"))
|
|
{
|
|
if(SrcFlag)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s\n","// [",trim(Modules[ModuleNdx])," - ",trim(str(ModuleLineNos[ModuleNdx])),"] End of $CCODE Block");
|
|
}
|
|
break;
|
|
}
|
|
fprintf(Outfile,"%s\n",rtrim(Src));
|
|
}
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$cprot")==0)
|
|
{
|
|
FastLexer(Src,SPC,"!");
|
|
if(iMatchWrd(Stk[2],"!"))
|
|
{
|
|
ProtoCnt++;
|
|
strcpy(ProtoType[ProtoCnt].Prototype,remain(Src,"!"));
|
|
*ProtoType[ProtoCnt].Condition=0;
|
|
ProtoType[ProtoCnt].CondLevel=0;
|
|
}
|
|
else
|
|
{
|
|
i=iMatchNQ(Src,"function");
|
|
if(i==0)
|
|
{
|
|
i=iMatchNQ(Src,"sub");
|
|
}
|
|
if(i)
|
|
{
|
|
strcpy(Src, join(2,"c_declare ",mid(Src,i)));
|
|
}
|
|
else
|
|
{
|
|
i=iMatchNQ(Src,"$cproto");
|
|
strcpy(Src, join(2,"c_declare function ",mid(Src,i+7)));
|
|
}
|
|
UseCProto=TRUE;
|
|
return 2;
|
|
}
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$heade")==0)
|
|
{
|
|
*Src=0;
|
|
fprintf(FP7,"%s\n","// ***************************************************");
|
|
fprintf(FP7,"%s\n","");
|
|
for(;;)
|
|
{
|
|
if(EoF(SourceFile))
|
|
{
|
|
Abort("Unbalanced $Header");
|
|
}
|
|
Src[0]=0;
|
|
AR_fgets_retval=fgets(Src,65535,SourceFile);
|
|
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
|
|
ModuleLineNos[ModuleNdx]++;
|
|
StripTabs();
|
|
strcpy(Src,trim(Src));
|
|
if(iMatchLft(Src,"$heade"))
|
|
{
|
|
break;
|
|
}
|
|
fprintf(FP7,"%s\n",Src);
|
|
}
|
|
*Src=0;
|
|
fprintf(FP7,"%s\n","");
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$asm")==0)
|
|
{
|
|
if(!iMatchLft(Src,"$asm"))
|
|
{
|
|
Abort(join(2,"Unknown metastatement: ",Src));
|
|
}
|
|
*Src=0;
|
|
for(;;)
|
|
{
|
|
if(EoF(SourceFile))
|
|
{
|
|
Abort("Unbalanced $Asm");
|
|
}
|
|
Src[0]=0;
|
|
AR_fgets_retval=fgets(Src,65535,SourceFile);
|
|
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
|
|
ModuleLineNos[ModuleNdx]++;
|
|
if(SrcFlag)
|
|
{
|
|
fprintf(Outfile,"%s%s\n","// ",Src);
|
|
}
|
|
StripTabs();
|
|
strcpy(Src,trim(Src));
|
|
static int meta_asm_loop;
|
|
memset(&meta_asm_loop,0,sizeof(meta_asm_loop));
|
|
static bool meta_asm_comment_present;
|
|
memset(&meta_asm_comment_present,0,sizeof(meta_asm_comment_present));
|
|
static int Src_Len;
|
|
memset(&Src_Len,0,sizeof(Src_Len));
|
|
Src_Len=strlen(Src);
|
|
meta_asm_comment_present=FALSE;
|
|
for(meta_asm_loop=0; meta_asm_loop<=Src_Len; meta_asm_loop+=1)
|
|
{
|
|
if(Src[meta_asm_loop]==39||Src[meta_asm_loop]==59)
|
|
{
|
|
strcpy(lszTmp,right(Src,Src_Len-meta_asm_loop-1));
|
|
Src[meta_asm_loop]=0;
|
|
meta_asm_comment_present=TRUE;
|
|
break;
|
|
}
|
|
}
|
|
strcpy(Src,trim(Src));
|
|
if(iMatchLft(Src,"$asm"))
|
|
{
|
|
break;
|
|
}
|
|
strcpy(Src,replace(Src,"$","0x"));
|
|
strcpy(Src,iReplace(Src,"&h","0x"));
|
|
if(Src[0]!=0)
|
|
{
|
|
strcpy(Src, join(3,"_asm(",enc(Src),chr(1)));
|
|
if(meta_asm_comment_present)
|
|
{
|
|
strcpy(Src, join(4,Src,TAB,"//",lszTmp));
|
|
}
|
|
strcpy(SrcTmp,Src);
|
|
fprintf(Outfile,"%s\n","#if !defined( __POCC__ ) && !defined (__cplusplus )");
|
|
strcpy(Src,replace(Src,chr(1),")"));
|
|
fprintf(Outfile,"%s\n",Src);
|
|
fprintf(Outfile,"%s\n","#else");
|
|
strcpy(SrcTmp,replace(SrcTmp,"_asm(","__asm{"));
|
|
strcpy(SrcTmp,replace(SrcTmp,chr(1),"}"));
|
|
fprintf(Outfile,"%s\n",RemoveStr(SrcTmp,DQ));
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
}
|
|
}
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"#inclu")==0)
|
|
{
|
|
strcpy(Src,RemoveStr(lcase(Src),"#include"));
|
|
strcpy(Src,trim(Src));
|
|
fprintf(FP7,"%s%s\n","#include ",Src);
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$libra")==0)
|
|
{
|
|
strcpy(Src,replace(Src,"\\","\\\\"));
|
|
strcpy(Src,RemoveStr(lcase(Src),"$library"));
|
|
strcpy(Src,trim(Src));
|
|
AddLibrary(Src);
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
if(str_cmp(Z,"$nolib")==0)
|
|
{
|
|
strcpy(Src,replace(Src,"\\","\\\\"));
|
|
strcpy(Src,RemoveStr(lcase(Src),"$nolibrary"));
|
|
RemoveLibrary(Src);
|
|
*Src=0;
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return 2;
|
|
}
|
|
|
|
|
|
int SubVarType (int TokenNum)
|
|
{
|
|
int k;
|
|
int j=0;
|
|
k=CheckLocal(Stk[TokenNum], &j);
|
|
if(k==vt_CHAR)
|
|
{
|
|
if(*LocalVars[j].VarDim!=91&&LocalVars[j].VarPntr==0)
|
|
{
|
|
k=vt_INTEGER;
|
|
}
|
|
}
|
|
else if(k==vt_UNKNOWN)
|
|
{
|
|
k=CheckGlobal(Stk[TokenNum], &j);
|
|
if(k==vt_CHAR)
|
|
{
|
|
if(*GlobalVars[j].VarDim!=91&&GlobalVars[j].VarPntr==0)
|
|
{
|
|
k=vt_INTEGER;
|
|
}
|
|
}
|
|
}
|
|
j=(UCHAR)*(right(Stk[TokenNum],1));
|
|
for(;;)
|
|
{
|
|
if(k==vt_STRVAR||k==vt_CHAR)
|
|
{
|
|
if(j!=36)
|
|
{
|
|
strcat(Stk[TokenNum],"$");
|
|
}
|
|
break;
|
|
}
|
|
if(k==vt_INTEGER)
|
|
{
|
|
if(j!=37)
|
|
{
|
|
strcat(Stk[TokenNum],"%");
|
|
}
|
|
break;
|
|
}
|
|
if(k==vt_SINGLE)
|
|
{
|
|
if(j!=33)
|
|
{
|
|
strcat(Stk[TokenNum],"!");
|
|
}
|
|
break;
|
|
}
|
|
if(k==vt_DOUBLE)
|
|
{
|
|
if(j!=35)
|
|
{
|
|
strcat(Stk[TokenNum],"#");
|
|
}
|
|
break;
|
|
}
|
|
if(k==vt_LDOUBLE)
|
|
{
|
|
if(j!=166)
|
|
{
|
|
strcat(Stk[TokenNum],"¦");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return k;
|
|
}
|
|
|
|
|
|
char * PrintWriteFormat (int DoWrite)
|
|
{
|
|
char *BCX_RetStr={0};
|
|
ARGTYPE Stak[128];
|
|
char Frmat[2048];
|
|
char Arg[2048];
|
|
char *ZZ;
|
|
ZZ=(char*)calloc(256+65535,1);
|
|
char Cast[2048];
|
|
int NewLineFlag=0;
|
|
int Argcount=0;
|
|
int i=0;
|
|
int j=0;
|
|
int k=0;
|
|
*Frmat=0;
|
|
*Arg=0;
|
|
*ZZ=0;
|
|
if(str_cmp(Stk[Ndx],";")==0)
|
|
{
|
|
NewLineFlag=TRUE;
|
|
Ndx--;
|
|
}
|
|
if(Ndx==1)
|
|
{
|
|
goto PRINTWRITELABEL;
|
|
}
|
|
Stak[1].ArgType=-1;
|
|
j=2;
|
|
while(j<=Ndx)
|
|
{
|
|
if(str_cmp(Clean(Stk[j]),"BCX_DynaCall")!=0)
|
|
{
|
|
i=SubVarType(j);
|
|
if(Stak[Argcount+1].ArgType==-1)
|
|
{
|
|
if(i==vt_CHAR||i==vt_STRVAR||i==vt_INTEGER||i==vt_SINGLE||i==vt_DOUBLE||i==vt_LDOUBLE)
|
|
{
|
|
Stak[Argcount+1].ArgType=i;
|
|
}
|
|
}
|
|
if(str_cmp(Stk[j],"(")==0)
|
|
{
|
|
i=0;
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Stk[j],"(")==0)
|
|
{
|
|
i++;
|
|
}
|
|
if(str_cmp(Stk[j],")")==0)
|
|
{
|
|
i--;
|
|
}
|
|
strcat(Arg,Stk[j]);
|
|
j++;
|
|
if(i<=0||j>=Ndx)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(str_cmp(Stk[j],"[")==0)
|
|
{
|
|
i=0;
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Stk[j],"[")==0)
|
|
{
|
|
i++;
|
|
}
|
|
if(str_cmp(Stk[j],"]")==0)
|
|
{
|
|
i--;
|
|
}
|
|
strcat(Arg,Stk[j]);
|
|
j++;
|
|
if(str_cmp(Stk[j],"[")==0 && i==0)
|
|
{
|
|
continue;
|
|
}
|
|
if(i<=0||j>=Ndx)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(str_cmp(Stk[j],";")==0 || str_cmp(Stk[j],",")==0 || str_cmp(Stk[j],"&")==0)
|
|
{
|
|
Argcount++;
|
|
strcpy(Stak[Argcount].Arg,Arg);
|
|
Stak[Argcount+1].ArgType=-1;
|
|
*Arg=0;
|
|
j++;
|
|
}
|
|
else
|
|
{
|
|
strcat(Arg,Stk[j]);
|
|
j++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
strcat(Arg,Stk[j]);
|
|
j++;
|
|
}
|
|
}
|
|
Argcount++;
|
|
strcpy(Stak[Argcount].Arg,Arg);
|
|
*Arg=0;
|
|
for(i=1; i<=Argcount; i+=1)
|
|
{
|
|
j=Stak[i].ArgType;
|
|
if(j==-1)
|
|
{
|
|
strcpy(ZZ,extract(Stak[i].Arg,"("));
|
|
j=DataType(ZZ);
|
|
}
|
|
for(;;)
|
|
{
|
|
if(j==vt_STRLIT||j==vt_STRVAR||j==vt_CHAR)
|
|
{
|
|
if(DoWrite)
|
|
{
|
|
strcpy(Frmat, join(7,Frmat,"\\",DQ,"%s","\\",DQ,","));
|
|
}
|
|
else
|
|
{
|
|
strcat(Frmat,"%s");
|
|
}
|
|
if(str_cmp(left(ZZ,12),"BCX_DynaCall")==0)
|
|
{
|
|
strcpy(Arg, join(3,Arg,",(char*)",Stak[i].Arg));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Arg, join(3,Arg,",",Stak[i].Arg));
|
|
}
|
|
break;
|
|
}
|
|
if(j==vt_INTEGER||j==vt_DECFUNC)
|
|
{
|
|
if(DoWrite)
|
|
{
|
|
strcpy(Frmat, join(3,Frmat,"%d",","));
|
|
}
|
|
else
|
|
{
|
|
strcat(Frmat,"%d");
|
|
}
|
|
strcpy(Arg, join(3,Arg,",(int)",Stak[i].Arg));
|
|
break;
|
|
}
|
|
if(j==vt_SINGLE)
|
|
{
|
|
if(DoWrite)
|
|
{
|
|
strcpy(Frmat, join(3,Frmat,"%.7G",","));
|
|
}
|
|
else
|
|
{
|
|
strcat(Frmat,"%.7G");
|
|
}
|
|
strcpy(Arg, join(3,Arg,",(float)",Stak[i].Arg));
|
|
break;
|
|
}
|
|
if(j==vt_DOUBLE||j==vt_NUMBER)
|
|
{
|
|
if(DoWrite)
|
|
{
|
|
strcpy(Frmat, join(3,Frmat,"%.15G",","));
|
|
}
|
|
else
|
|
{
|
|
strcat(Frmat,"%.15G");
|
|
}
|
|
strcpy(Arg, join(3,Arg,",(double)",Stak[i].Arg));
|
|
break;
|
|
}
|
|
if(j==vt_LDOUBLE)
|
|
{
|
|
if(DoWrite)
|
|
{
|
|
strcpy(Frmat, join(3,Frmat,"%.19LG",","));
|
|
}
|
|
else
|
|
{
|
|
strcat(Frmat,"%.19LG");
|
|
}
|
|
strcpy(Arg, join(3,Arg,",(LDOUBLE)",Stak[i].Arg));
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
if((UCHAR)*(Stak[i].Arg)==40)
|
|
{
|
|
*ZZ=0;
|
|
strcat(Arg,",");
|
|
for(;;)
|
|
{
|
|
k=instr_b(Stak[i].Arg,")");
|
|
strcpy(Cast,mid(Stak[i].Arg,1,k));
|
|
strcpy(Stak[i].Arg,trim(mid(Stak[i].Arg,k+1)));
|
|
strcpy(Cast,iReplace(Cast,"char*","char *"));
|
|
strcpy(Cast,iReplace(Cast,"integer","int"));
|
|
strcpy(Cast,iReplace(Cast,"single","float"));
|
|
strcpy(Cast,iReplace(Cast,"ldouble","LDOUBLE"));
|
|
if(ZZ[0]==0)
|
|
{
|
|
if(str_cmp(Cast,"(char *)")==0 || str_cmp(Cast,"(int)")==0 || str_cmp(Cast,"(float)")==0 || str_cmp(Cast,"(double)")==0 || str_cmp(Cast,"(LDOUBLE)")==0)
|
|
{
|
|
strcpy(ZZ,Cast);
|
|
}
|
|
else
|
|
{
|
|
strcpy(ZZ,"(double)");
|
|
strcpy(Cast, join(2,ZZ,Cast));
|
|
}
|
|
RemoveAll(ZZ,"()");
|
|
strcpy(ZZ,iReplace(ZZ,"char *","%s"));
|
|
strcpy(ZZ,iReplace(ZZ,"int","%d"));
|
|
strcpy(ZZ,iReplace(ZZ,"float","%.7G"));
|
|
strcpy(ZZ,iReplace(ZZ,"ldouble","%.19LG"));
|
|
strcpy(ZZ,iReplace(ZZ,"double","%.15G"));
|
|
}
|
|
strcat(Arg,Cast);
|
|
if(!((UCHAR)*(Stak[i].Arg)==40))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
strcat(Arg,Stak[i].Arg);
|
|
strcat(Frmat,ZZ);
|
|
if(DoWrite)
|
|
{
|
|
strcat(Frmat,",");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(DoWrite)
|
|
{
|
|
strcpy(Frmat, join(3,Frmat,"%G",","));
|
|
}
|
|
else
|
|
{
|
|
strcat(Frmat,"%G");
|
|
strcpy(Arg, join(3,Arg,",(float)",Stak[i].Arg));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if(DoWrite)
|
|
{
|
|
strcpy(Frmat,left(Frmat,strlen(Frmat)-1));
|
|
}
|
|
|
|
PRINTWRITELABEL:;
|
|
if(NewLineFlag==0)
|
|
{
|
|
strcat(Frmat,"\\n");
|
|
}
|
|
BCX_RetStr=join(4,"printf(",enc(Frmat),Clean(Arg),");");
|
|
if(ZZ)free(ZZ);
|
|
return BCX_RetStr;
|
|
}
|
|
|
|
|
|
void EmitInputCode (void)
|
|
{
|
|
int Argcount=0;
|
|
int VarCnt=0;
|
|
int i=0;
|
|
int j=0;
|
|
int l=0;
|
|
char Arg[2048];
|
|
char Tmp[2048];
|
|
char Frmat[2048];
|
|
static char Stak[128][2048];
|
|
memset(&Stak,0,sizeof(Stak));
|
|
char Y[2048];
|
|
char *ZZ;
|
|
ZZ=(char*)calloc(256+65535,1);
|
|
Use_Inputbuffer=TRUE;
|
|
Use_Scan=TRUE;
|
|
Use_Split=TRUE;
|
|
Use_Remove=TRUE;
|
|
Use_StrStr=TRUE;
|
|
Use_Mid=TRUE;
|
|
Use_Left=TRUE;
|
|
Use_Instr=TRUE;
|
|
Use_Stristr=TRUE;
|
|
UseLCaseTbl=TRUE;
|
|
UseFlag=TRUE;
|
|
Use_Lineinput=TRUE;
|
|
*Arg=0;
|
|
*ZZ=0;
|
|
*Frmat=0;
|
|
strcpy(Tmp, join(7,DQ,",",DQ,",",DQ," ",DQ));
|
|
if(DataType(Stk[2])==vt_STRLIT)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"printf(",Clean(Stk[2]),");");
|
|
}
|
|
if(DataType(Stk[2])==vt_STRLIT)
|
|
{
|
|
j=4;
|
|
}
|
|
else
|
|
{
|
|
j=2;
|
|
}
|
|
l=j;
|
|
while(j<=Ndx)
|
|
{
|
|
if(j==l)
|
|
{
|
|
i=SubVarType(j);
|
|
}
|
|
if(str_cmp(Stk[j],",")==0)
|
|
{
|
|
l=j+1;
|
|
}
|
|
strcat(ZZ,Stk[j]);
|
|
j++;
|
|
}
|
|
FastLexer(ZZ,"",",");
|
|
j=1;
|
|
while(j<=Ndx)
|
|
{
|
|
if(str_cmp(Stk[j],",")==0)
|
|
{
|
|
Argcount++;
|
|
strcpy(Stak[Argcount],Arg);
|
|
*Arg=0;
|
|
j++;
|
|
}
|
|
else
|
|
{
|
|
strcat(Arg,Stk[j]);
|
|
j++;
|
|
if(j<Ndx)
|
|
{
|
|
if(str_cmp(Stk[j],"[")==0)
|
|
{
|
|
i=0;
|
|
for(;;)
|
|
{
|
|
|
|
DOAGAIN:;
|
|
if(str_cmp(Stk[j],"[")==0)
|
|
{
|
|
i++;
|
|
}
|
|
if(str_cmp(Stk[j],"]")==0)
|
|
{
|
|
i--;
|
|
}
|
|
strcat(Arg,Stk[j]);
|
|
j++;
|
|
if(str_cmp(Stk[j],"[")==0 && i==0)
|
|
{
|
|
goto DOAGAIN;
|
|
}
|
|
if(i<=0||j>=Ndx)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Argcount++;
|
|
strcpy(Stak[Argcount],Arg);
|
|
*Arg=0;
|
|
for(i=1; i<=Argcount; i+=1)
|
|
{
|
|
strcpy(Y,Stak[i]);
|
|
j=DataType(Y);
|
|
for(;;)
|
|
{
|
|
if(j==vt_STRVAR)
|
|
{
|
|
strcat(Frmat,"%s");
|
|
strcpy(Arg, join(3,Arg,",",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"*",trim(Clean(Stak[i])),"=0;");
|
|
VarCnt++;
|
|
break;
|
|
}
|
|
if(j==vt_INTEGER)
|
|
{
|
|
strcat(Frmat,"%d");
|
|
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
|
|
VarCnt++;
|
|
break;
|
|
}
|
|
if(j==vt_SINGLE)
|
|
{
|
|
strcat(Frmat,"%g");
|
|
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
|
|
VarCnt++;
|
|
break;
|
|
}
|
|
if(j==vt_DOUBLE)
|
|
{
|
|
strcat(Frmat,"%lG");
|
|
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
|
|
VarCnt++;
|
|
break;
|
|
}
|
|
if(j==vt_LDOUBLE)
|
|
{
|
|
strcat(Frmat,"%lG");
|
|
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
|
|
VarCnt++;
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
strcat(Frmat,"%d");
|
|
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
|
|
VarCnt++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s\n",Scoot,"AR_fgets_retval=fgets(InputBuffer,sizeof(InputBuffer),stdin);");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"InputBuffer[strlen(InputBuffer)-1]=0;");
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Scoot,"ScanError = scan(InputBuffer,",enc(Frmat),Arg,");\n");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"*InputBuffer=0;");
|
|
if(ZZ)free(ZZ);
|
|
}
|
|
|
|
|
|
void EmitFileInputCode (void)
|
|
{
|
|
int Argcount=0;
|
|
int VarCnt=0;
|
|
int i;
|
|
int j;
|
|
char Arg[2048];
|
|
char Frmat[2048];
|
|
char FHandle[2048];
|
|
char Y[2048];
|
|
char *ZZ;
|
|
ZZ=(char*)calloc(256+65535,1);
|
|
static char Stak[128][2048];
|
|
memset(&Stak,0,sizeof(Stak));
|
|
*Arg=0;
|
|
*Frmat=0;
|
|
*ZZ=0;
|
|
*FHandle=0;
|
|
Use_Inputbuffer=TRUE;
|
|
Use_Scan=TRUE;
|
|
Use_Split=TRUE;
|
|
Use_Remove=TRUE;
|
|
Use_StrStr=TRUE;
|
|
Use_Mid=TRUE;
|
|
Use_Left=TRUE;
|
|
Use_Instr=TRUE;
|
|
Use_Stristr=TRUE;
|
|
UseLCaseTbl=TRUE;
|
|
i=4;
|
|
for(j=2; j<=Ndx; j+=1)
|
|
{
|
|
if(*Stk[j]==44)
|
|
{
|
|
i=j+1;
|
|
break;
|
|
}
|
|
strcat(FHandle,Stk[j]);
|
|
}
|
|
for(j=i; j<=Ndx; j+=1)
|
|
{
|
|
if(j==i)
|
|
{
|
|
SubVarType(j);
|
|
}
|
|
if(str_cmp(Stk[j],",")==0)
|
|
{
|
|
SubVarType(j+1);
|
|
}
|
|
strcat(ZZ,Stk[j]);
|
|
}
|
|
FastLexer(ZZ,"",",");
|
|
j=1;
|
|
while(j<=Ndx)
|
|
{
|
|
if(str_cmp(Stk[j],",")==0)
|
|
{
|
|
Argcount++;
|
|
strcpy(Stak[Argcount],Arg);
|
|
*Arg=0;
|
|
j++;
|
|
}
|
|
else
|
|
{
|
|
strcat(Arg,Stk[j]);
|
|
j++;
|
|
if(j<Ndx)
|
|
{
|
|
if(str_cmp(Stk[j],"[")==0)
|
|
{
|
|
i=0;
|
|
for(;;)
|
|
{
|
|
|
|
DOAGAIN:;
|
|
if(str_cmp(Stk[j],"[")==0)
|
|
{
|
|
i++;
|
|
}
|
|
if(str_cmp(Stk[j],"]")==0)
|
|
{
|
|
i--;
|
|
}
|
|
strcat(Arg,Stk[j]);
|
|
j++;
|
|
if(str_cmp(Stk[j],"[")==0 && i==0)
|
|
{
|
|
goto DOAGAIN;
|
|
}
|
|
if(i<=0||j>=Ndx)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Argcount++;
|
|
strcpy(Stak[Argcount],Arg);
|
|
*Arg=0;
|
|
for(i=1; i<=Argcount; i+=1)
|
|
{
|
|
strcpy(Y,Stak[i]);
|
|
j=DataType(Y);
|
|
for(;;)
|
|
{
|
|
if(j==vt_STRVAR)
|
|
{
|
|
strcat(Frmat,"%s");
|
|
strcpy(Arg, join(3,Arg,",",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"*",trim(Clean(Stak[i])),"=0;");
|
|
VarCnt++;
|
|
break;
|
|
}
|
|
if(j==vt_INTEGER)
|
|
{
|
|
strcat(Frmat,"%d");
|
|
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
|
|
VarCnt++;
|
|
break;
|
|
}
|
|
if(j==vt_SINGLE)
|
|
{
|
|
strcat(Frmat,"%g");
|
|
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
|
|
VarCnt++;
|
|
break;
|
|
}
|
|
if(j==vt_DOUBLE)
|
|
{
|
|
strcat(Frmat,"%lG");
|
|
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
|
|
VarCnt++;
|
|
break;
|
|
}
|
|
if(j==vt_LDOUBLE)
|
|
{
|
|
strcat(Frmat,"%lG");
|
|
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
|
|
VarCnt++;
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
strcat(Frmat,"%d");
|
|
strcpy(Arg, join(3,Arg,",&",Clean(Stak[i])));
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stak[i]),"=0;");
|
|
VarCnt++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"AR_fgets_retval=fgets(InputBuffer,65535,",FHandle,");");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"if(InputBuffer[strlen(InputBuffer)-1]== 10)");
|
|
fprintf(Outfile,"%s%s\n",Scoot," InputBuffer[strlen(InputBuffer)-1]=0;");
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Scoot,"ScanError = scan(InputBuffer,",enc(Frmat),Arg,");\n");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"*InputBuffer=0;");
|
|
if(ZZ)free(ZZ);
|
|
}
|
|
|
|
|
|
void AddFuncs (void)
|
|
{
|
|
char *ZZ;
|
|
ZZ=(char*)calloc(256+65535,1);
|
|
char Last[2048];
|
|
*Last=0;
|
|
CloseAll();
|
|
if((FP1=fopen(prcFile,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",prcFile);
|
|
exit(1);
|
|
}
|
|
if((Outfile=fopen(FileOut,"a"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",FileOut);
|
|
exit(1);
|
|
}
|
|
if(ProtoType[1].Prototype[0]>0)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// ************************************");
|
|
fprintf(Outfile,"%s%s\n","// ",BCX_STR_USR_PROCS);
|
|
fprintf(Outfile,"%s\n","// ************************************");
|
|
fprintf(Outfile,"%s\n","\n");
|
|
}
|
|
while(!EoF(FP1))
|
|
{
|
|
ZZ[0]=0;
|
|
AR_fgets_retval=fgets(ZZ,65535,FP1);
|
|
if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
|
|
if(instr_b(ZZ,"DefWindowProc"))
|
|
{
|
|
if(instr_b(Last,"return ")||instr_b(Last,"CallWindowProc")||instr_b(Last,"DefWindowProc")||instr_b(Last,"DefMDIChildProc")||instr_b(Last,"DefFrameProc"))
|
|
{
|
|
*Last=0;
|
|
continue;
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n",ZZ);
|
|
if(str_cmp(left(ZZ,2),"//")!=0)
|
|
{
|
|
strcpy(Last,ZZ);
|
|
}
|
|
}
|
|
CloseAll();
|
|
remove (prcFile);
|
|
remove (udtFile);
|
|
remove (datFile);
|
|
remove (cstFile);
|
|
remove (ovrFile);
|
|
remove (setFile);
|
|
remove (enuFile);
|
|
if(ZZ)free(ZZ);
|
|
}
|
|
|
|
|
|
int CheckLocal (char *ZZ, int* varidx)
|
|
{
|
|
char TT[2048];
|
|
if(LocalVarCnt)
|
|
{
|
|
strcpy(TT,Clean(ZZ));
|
|
RemoveAll(TT," &*()",1);
|
|
if(instr_b(TT,"["))
|
|
{
|
|
strcpy(TT,left(TT,instr_b(TT,"[")-1));
|
|
}
|
|
{int i;
|
|
for(i=1; i<=LocalVarCnt; i+=1)
|
|
{
|
|
if(str_cmp(TT,LocalVars[i].VarName)==0)
|
|
{
|
|
(*varidx)=i;
|
|
return LocalVars[i].VarType;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return vt_UNKNOWN;
|
|
}
|
|
|
|
|
|
int CheckGlobal (char *ZZ, int* varidx)
|
|
{
|
|
int hn;
|
|
int s;
|
|
char TT[2048];
|
|
strcpy(TT,Clean(ZZ));
|
|
RemoveAll(TT," &*()",1);
|
|
if(instr_b(TT,"["))
|
|
{
|
|
strcpy(TT,left(TT,instr_b(TT,"[")-1));
|
|
}
|
|
hn=HashNumber(TT);
|
|
while(GlobalVarHash[hn])
|
|
{
|
|
s=GlobalVarHash[hn];
|
|
if(str_cmp(TT,GlobalVars[s].VarName)==0)
|
|
{
|
|
(*varidx)=s;
|
|
return GlobalVars[s].VarType;
|
|
}
|
|
hn=imod(hn+1,MaxGlobalVars);
|
|
}
|
|
return vt_UNKNOWN;
|
|
}
|
|
|
|
|
|
int CheckType (char *ZZ)
|
|
{
|
|
char Keyword[2048];
|
|
int varid=0;
|
|
int i;
|
|
strcpy(Keyword,lcase(ZZ));
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"int")==0)
|
|
{
|
|
return vt_INTEGER;
|
|
}
|
|
if(str_cmp(Keyword,"string")==0)
|
|
{
|
|
return vt_STRVAR;
|
|
}
|
|
if(str_cmp(Keyword,"char")==0)
|
|
{
|
|
return vt_CHAR;
|
|
}
|
|
if(str_cmp(Keyword,"pchar")==0)
|
|
{
|
|
return vt_PCHAR;
|
|
}
|
|
if(str_cmp(Keyword,"byte")==0)
|
|
{
|
|
return vt_BYTE;
|
|
}
|
|
if(str_cmp(Keyword,"double")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"ldouble")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"file")==0)
|
|
{
|
|
return vt_FILEPTR;
|
|
}
|
|
if(str_cmp(Keyword,"float")==0)
|
|
{
|
|
return vt_SINGLE;
|
|
}
|
|
if(str_cmp(Keyword,"bool")==0 || str_cmp(Keyword,"boolean")==0)
|
|
{
|
|
return vt_BOOL;
|
|
}
|
|
if(str_cmp(Keyword,"long")==0)
|
|
{
|
|
return vt_LONG;
|
|
}
|
|
if(str_cmp(Keyword,"dword")==0)
|
|
{
|
|
return vt_DWORD;
|
|
}
|
|
if(str_cmp(Keyword,"farproc")==0)
|
|
{
|
|
return vt_FARPROC;
|
|
}
|
|
if(str_cmp(Keyword,"void")==0)
|
|
{
|
|
return vt_VOID;
|
|
}
|
|
if(str_cmp(Keyword,"lpbyte")==0)
|
|
{
|
|
return vt_LPBYTE;
|
|
}
|
|
if(str_cmp(Keyword,"lresult")==0)
|
|
{
|
|
return vt_LRESULT;
|
|
}
|
|
if(str_cmp(Keyword,"short")==0)
|
|
{
|
|
return vt_SHORT;
|
|
}
|
|
if(str_cmp(Keyword,"ushort")==0)
|
|
{
|
|
return vt_USHORT;
|
|
}
|
|
if(str_cmp(Keyword,"uint")==0)
|
|
{
|
|
return vt_UINT;
|
|
}
|
|
if(str_cmp(Keyword,"ulong")==0)
|
|
{
|
|
return vt_ULONG;
|
|
}
|
|
if(str_cmp(Keyword,"colorref")==0)
|
|
{
|
|
return vt_COLORREF;
|
|
}
|
|
if(str_cmp(Keyword,"handle")==0)
|
|
{
|
|
return vt_HANDLE;
|
|
}
|
|
if(str_cmp(Keyword,"hdc")==0)
|
|
{
|
|
return vt_HDC;
|
|
}
|
|
if(str_cmp(Keyword,"variant")==0)
|
|
{
|
|
return vt_VARIANT;
|
|
}
|
|
break;
|
|
}
|
|
i=CheckLocal(ZZ, &varid);
|
|
if(i==vt_UNKNOWN)
|
|
{
|
|
i=DefsID(ZZ);
|
|
if(i)
|
|
{
|
|
return TypeDefs[i].TypeofDef;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return i;
|
|
}
|
|
return CheckGlobal(ZZ, &varid);
|
|
}
|
|
|
|
|
|
void ExportInternalConst (void)
|
|
{
|
|
if(Use_FillArray)
|
|
{
|
|
strcpy(Src,"CONST vt_INTEGER = 2");
|
|
PassOne=1;
|
|
Parse(Src);
|
|
Emit();
|
|
strcpy(Src,"CONST vt_SINGLE = 3");
|
|
PassOne=1;
|
|
Parse(Src);
|
|
Emit();
|
|
strcpy(Src,"CONST vt_DOUBLE = 4");
|
|
PassOne=1;
|
|
Parse(Src);
|
|
Emit();
|
|
strcpy(Src,"CONST vt_LDOUBLE = 5");
|
|
PassOne=1;
|
|
Parse(Src);
|
|
Emit();
|
|
}
|
|
}
|
|
|
|
|
|
int RestrictedWords (char *ZZ)
|
|
{
|
|
if(str_cmp(ZZ,"CmdLine")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"CmdShow")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"hInst")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"hPrev")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"hWnd")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"lParam")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"Msg")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"wParam")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"vt_INTEGER")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"vt_SINGLE")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"vt_DOUBLE")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
if(str_cmp(ZZ,"vt_LDOUBLE")==0)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int DataType (char *ZZ)
|
|
{
|
|
char Keyword[2048];
|
|
int i;
|
|
if(ZZ[0]==34)
|
|
{
|
|
return vt_STRLIT;
|
|
}
|
|
if(inchr(ZZ,"$"))
|
|
{
|
|
return vt_STRVAR;
|
|
}
|
|
if(IsNumber(ZZ))
|
|
{
|
|
return vt_NUMBER;
|
|
}
|
|
i=DefsID(ZZ);
|
|
if(i)
|
|
{
|
|
return TypeDefs[i].TypeofDef;
|
|
}
|
|
strcpy(Keyword,lcase(ZZ));
|
|
if(str_cmp(Keyword,"strlen")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"instr")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"inchr")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"sizeof")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"tally")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"band")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"bor")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"lof")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"pos")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"qbcolor")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"split")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"dsplit")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"sgn")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"timer")==0)
|
|
{
|
|
return vt_SINGLE;
|
|
}
|
|
if(str_cmp(Keyword,"keypress()")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"getattr")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"fix")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"instrrev")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"kbhit")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"exp")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"expl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"sinh")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"cosh")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"tanh")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"asinh")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"acosh")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"atanh")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"round")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"val")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"vall")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"iif")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"bin2dec")==0)
|
|
{
|
|
return vt_INTEGER;
|
|
}
|
|
if(str_cmp(Keyword,"hex2dec")==0)
|
|
{
|
|
return vt_INTEGER;
|
|
}
|
|
if(str_cmp(Keyword,"rnd")==0)
|
|
{
|
|
return vt_SINGLE;
|
|
}
|
|
if(str_cmp(Keyword,"frac")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"fracl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"asin")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"asinl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"hypot")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"hypotl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"log")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"logl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"log10")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"log10l")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"acos")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"acosl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"atan")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"atanl")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"sin")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"sinl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"cos")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"cosl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"tan")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"tanl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"pow")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"powl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"sqrt")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"sqrtl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"min")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"max")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"exist")==0)
|
|
{
|
|
return vt_DECFUNC;
|
|
}
|
|
if(str_cmp(Keyword,"abs")==0)
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"absl")==0)
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(str_cmp(Keyword,"freefile")==0)
|
|
{
|
|
return vt_FILEPTR;
|
|
}
|
|
if(str_cmp(Keyword,"fint")==0)
|
|
{
|
|
return vt_INTEGER;
|
|
}
|
|
if(inchr(ZZ,"%"))
|
|
{
|
|
return vt_INTEGER;
|
|
}
|
|
if(inchr(ZZ,"!"))
|
|
{
|
|
return vt_SINGLE;
|
|
}
|
|
if(inchr(ZZ,"#"))
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(inchr(ZZ,"^"))
|
|
{
|
|
return vt_DOUBLE;
|
|
}
|
|
if(inchr(ZZ,"¦"))
|
|
{
|
|
return vt_LDOUBLE;
|
|
}
|
|
if(iMatchRgt(ZZ,"@"))
|
|
{
|
|
return vt_FILEPTR;
|
|
}
|
|
if(inchr(ZZ," "))
|
|
{
|
|
return vt_UDT;
|
|
}
|
|
if(isalpha(*ZZ))
|
|
{
|
|
return vt_INTEGER;
|
|
}
|
|
return vt_UNKNOWN;
|
|
}
|
|
|
|
|
|
void CloseAll (void)
|
|
{
|
|
#if defined (__APPLE__)
|
|
if(SourceFile)
|
|
{
|
|
fclose(SourceFile);
|
|
SourceFile=NULL;
|
|
}
|
|
if(FP2)
|
|
{
|
|
fclose(FP2);
|
|
FP2=NULL;
|
|
}
|
|
if(FP3)
|
|
{
|
|
fclose(FP3);
|
|
FP3=NULL;
|
|
}
|
|
if(FP4)
|
|
{
|
|
fclose(FP4);
|
|
FP4=NULL;
|
|
}
|
|
if(FP5)
|
|
{
|
|
fclose(FP5);
|
|
FP5=NULL;
|
|
}
|
|
if(FP6)
|
|
{
|
|
fclose(FP6);
|
|
FP6=NULL;
|
|
}
|
|
if(FP7)
|
|
{
|
|
fclose(FP7);
|
|
FP7=NULL;
|
|
}
|
|
if(FP8)
|
|
{
|
|
fclose(FP8);
|
|
FP8=NULL;
|
|
}
|
|
if(FP9)
|
|
{
|
|
fclose(FP9);
|
|
FP9=NULL;
|
|
}
|
|
if(FP10)
|
|
{
|
|
fclose(FP10);
|
|
FP10=NULL;
|
|
}
|
|
if(FP11)
|
|
{
|
|
fclose(FP11);
|
|
FP11=NULL;
|
|
}
|
|
if(Outfile)
|
|
{
|
|
fclose(Outfile);
|
|
Outfile=NULL;
|
|
}
|
|
if(FP1)
|
|
{
|
|
fclose(FP1);
|
|
FP1=NULL;
|
|
}
|
|
if(ResIn)
|
|
{
|
|
fclose(ResIn);
|
|
ResIn=NULL;
|
|
}
|
|
if(ResOut)
|
|
{
|
|
fclose(ResOut);
|
|
ResOut=NULL;
|
|
}
|
|
if(UserResIn)
|
|
{
|
|
fclose(UserResIn);
|
|
UserResIn=NULL;
|
|
}
|
|
if(fpErr)
|
|
{
|
|
fclose(fpErr);
|
|
fpErr=NULL;
|
|
}
|
|
if(fpHFile)
|
|
{
|
|
fclose(fpHFile);
|
|
fpHFile=NULL;
|
|
}
|
|
if(FP68)
|
|
{
|
|
fclose(FP68);
|
|
FP68=NULL;
|
|
}
|
|
if(fpdef)
|
|
{
|
|
fclose(fpdef);
|
|
fpdef=NULL;
|
|
}
|
|
if(SaveOutfileNum)
|
|
{
|
|
fclose(SaveOutfileNum);
|
|
SaveOutfileNum=NULL;
|
|
}
|
|
#else
|
|
fcloseall();
|
|
#endif
|
|
}
|
|
|
|
|
|
char * Clean (char *ZZ)
|
|
{
|
|
char *BCX_RetStr={0};
|
|
char Tmp[2048];
|
|
if(inchr(ZZ,"%"))
|
|
{
|
|
if(str_cmp(trim(ZZ),"%")==0)
|
|
{
|
|
BCX_RetStr=BCX_TmpStr(strlen(" % "));
|
|
strcpy(BCX_RetStr," % ");
|
|
return BCX_RetStr;
|
|
}
|
|
}
|
|
if(iMatchNQ(ZZ,"!="))
|
|
{
|
|
BCX_RetStr=BCX_TmpStr(strlen(ZZ));
|
|
strcpy(BCX_RetStr,ZZ);
|
|
return BCX_RetStr;
|
|
}
|
|
strcpy(Tmp,ZZ);
|
|
RemoveAll(Tmp,"%$#!@¦",1);
|
|
BCX_RetStr=BCX_TmpStr(strlen(Tmp));
|
|
strcpy(BCX_RetStr,Tmp);
|
|
return BCX_RetStr;
|
|
}
|
|
|
|
|
|
void RemoveAll (char * Arg,char * MatchChars,int qtflag)
|
|
{
|
|
PCHAR C=Arg;
|
|
PCHAR pmc;
|
|
while(*Arg)
|
|
{
|
|
if(qtflag)
|
|
{
|
|
if(*Arg==34)
|
|
{
|
|
*(C++)=*Arg;
|
|
while(*(++Arg)!=34)
|
|
{
|
|
*(C++)=*Arg;
|
|
if(*Arg==0)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
*(C++)=*(Arg++);
|
|
continue;
|
|
}
|
|
}
|
|
pmc=MatchChars;
|
|
while(*pmc)
|
|
{
|
|
if(*(pmc++)==*Arg)
|
|
{
|
|
goto SKIP;
|
|
}
|
|
}
|
|
*(C++)=*Arg;
|
|
|
|
SKIP:;
|
|
Arg++;
|
|
}
|
|
*C=0;
|
|
}
|
|
|
|
|
|
void Warning (char * ZZ,int WarnLvl)
|
|
{
|
|
static FILE *fErr;
|
|
memset(&fErr,0,sizeof(fErr));
|
|
if(WarnLvl)
|
|
{
|
|
strcpy(WarnMsg, join(7,WarnMsg," Line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," - ",ZZ));
|
|
}
|
|
else
|
|
{
|
|
strcat(WarnMsg,ZZ);
|
|
}
|
|
strcat(WarnMsg,CRLF);
|
|
if(ErrFile)
|
|
{
|
|
if((fErr=fopen(FileErr,"a"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",FileErr);
|
|
exit(1);
|
|
}
|
|
fprintf(fErr,"%s%s\n","WARNING ",ZZ);
|
|
if(fErr)
|
|
{
|
|
fclose(fErr);
|
|
fErr=NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
PCHAR GetVarTypeName (int i)
|
|
{
|
|
static char A[2048];
|
|
for(;;)
|
|
{
|
|
if(i==vt_INTEGER)
|
|
{
|
|
strcpy(A,"int");
|
|
break;
|
|
}
|
|
if(i==vt_STRVAR)
|
|
{
|
|
strcpy(A,"char *");
|
|
break;
|
|
}
|
|
if(i==vt_STRLIT)
|
|
{
|
|
strcpy(A,"STRLIT");
|
|
break;
|
|
}
|
|
if(i==vt_UNKNOWN)
|
|
{
|
|
strcpy(A,"UNKNOWN");
|
|
break;
|
|
}
|
|
if(i==vt_SINGLE)
|
|
{
|
|
strcpy(A,"float");
|
|
break;
|
|
}
|
|
if(i==vt_DOUBLE)
|
|
{
|
|
strcpy(A,"double");
|
|
break;
|
|
}
|
|
if(i==vt_LDOUBLE)
|
|
{
|
|
strcpy(A,"LDOUBLE");
|
|
break;
|
|
}
|
|
if(i==vt_DECFUNC)
|
|
{
|
|
strcpy(A,"DECFUNC");
|
|
break;
|
|
}
|
|
if(i==vt_NUMBER)
|
|
{
|
|
strcpy(A,"NUMBER");
|
|
break;
|
|
}
|
|
if(i==vt_FILEPTR)
|
|
{
|
|
strcpy(A,"FILE*");
|
|
break;
|
|
}
|
|
if(i==vt_UDT)
|
|
{
|
|
strcpy(A,"struct");
|
|
break;
|
|
}
|
|
if(i==vt_STRUCT)
|
|
{
|
|
strcpy(A,"struct");
|
|
break;
|
|
}
|
|
if(i==vt_UNION)
|
|
{
|
|
strcpy(A,"union");
|
|
break;
|
|
}
|
|
if(i==vt_BOOL)
|
|
{
|
|
strcpy(A,"bool");
|
|
break;
|
|
}
|
|
if(i==vt_CHAR)
|
|
{
|
|
strcpy(A,"char");
|
|
break;
|
|
}
|
|
if(i==vt_CHARPTR)
|
|
{
|
|
strcpy(A,"char");
|
|
break;
|
|
}
|
|
if(i==vt_PCHAR)
|
|
{
|
|
strcpy(A,"PCHAR");
|
|
break;
|
|
}
|
|
if(i==vt_VOID)
|
|
{
|
|
strcpy(A,"void");
|
|
break;
|
|
}
|
|
if(i==vt_LONG)
|
|
{
|
|
strcpy(A,"long");
|
|
break;
|
|
}
|
|
if(i==vt_DWORD)
|
|
{
|
|
strcpy(A,"DWORD");
|
|
break;
|
|
}
|
|
if(i==vt_FARPROC)
|
|
{
|
|
strcpy(A,"FARPROC");
|
|
break;
|
|
}
|
|
if(i==vt_LPBYTE)
|
|
{
|
|
strcpy(A,"LPBYTE");
|
|
break;
|
|
}
|
|
if(i==vt_LRESULT)
|
|
{
|
|
strcpy(A,"LRESULT");
|
|
break;
|
|
}
|
|
if(i==vt_BYTE)
|
|
{
|
|
strcpy(A,"BYTE");
|
|
break;
|
|
}
|
|
if(i==vt_SHORT)
|
|
{
|
|
strcpy(A,"short");
|
|
break;
|
|
}
|
|
if(i==vt_USHORT)
|
|
{
|
|
strcpy(A,"USHORT");
|
|
break;
|
|
}
|
|
if(i==vt_COLORREF)
|
|
{
|
|
strcpy(A,"COLORREF");
|
|
break;
|
|
}
|
|
if(i==vt_UINT)
|
|
{
|
|
strcpy(A,"UINT");
|
|
break;
|
|
}
|
|
if(i==vt_ULONG)
|
|
{
|
|
strcpy(A,"ULONG");
|
|
break;
|
|
}
|
|
if(i==vt_HANDLE)
|
|
{
|
|
strcpy(A,"HANDLE");
|
|
break;
|
|
}
|
|
if(i==vt_HINSTANCE)
|
|
{
|
|
strcpy(A,"HINSTANCE");
|
|
break;
|
|
}
|
|
if(i==vt_HDC)
|
|
{
|
|
strcpy(A,"HDC");
|
|
break;
|
|
}
|
|
if(i==vt_VARIANT)
|
|
{
|
|
strcpy(A,"VARIANT");
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
*A=0;
|
|
}
|
|
break;
|
|
}
|
|
return A;
|
|
}
|
|
|
|
|
|
int HashNumber (char *HT)
|
|
{
|
|
char* TT;
|
|
ULONG i=0;
|
|
TT=HT;
|
|
while(*TT)
|
|
{
|
|
i<<=1;
|
|
i ^= *TT;
|
|
TT++;
|
|
}
|
|
return imod(i,MaxGlobalVars);
|
|
}
|
|
|
|
|
|
void AddLibrary (char *LibName)
|
|
{
|
|
static int nTimes;
|
|
static int nLibNdx;
|
|
memset(&nLibNdx,0,sizeof(nLibNdx));
|
|
char TempLibName[2048];
|
|
strcpy(TempLibName,lcase(LibName));
|
|
if(!inchr(TempLibName,DQ)&&!inchr(TempLibName,"<"))
|
|
{
|
|
strcpy(TempLibName,enc(TempLibName,60,62));
|
|
}
|
|
if(nTimes==0)
|
|
{
|
|
{int i;
|
|
for(i=0; i<=MaxLib-1; i+=1)
|
|
{
|
|
*Library[i]=0;
|
|
}
|
|
}
|
|
nTimes++;
|
|
strcpy(Library[0],TempLibName);
|
|
return;
|
|
}
|
|
nLibNdx=0;
|
|
while(Library[nLibNdx][0]!=0)
|
|
{
|
|
if(str_cmp(Library[nLibNdx],TempLibName)==0)
|
|
{
|
|
return;
|
|
}
|
|
nLibNdx++;
|
|
}
|
|
if(nLibNdx<MaxLib-1)
|
|
{
|
|
strcpy(Library[nLibNdx],TempLibName);
|
|
}
|
|
}
|
|
|
|
|
|
void RemoveLibrary (char *LibName)
|
|
{
|
|
if(!instr_b(RmLibs,LibName,1,1))
|
|
{
|
|
strcpy(RmLibs, join(3,RmLibs,",",lcase(LibName)));
|
|
}
|
|
}
|
|
|
|
|
|
void EmitLibs (void)
|
|
{
|
|
static int nTimes;
|
|
static int nCount;
|
|
char ltmp[2048];
|
|
if(nTimes>0)
|
|
{
|
|
return;
|
|
}
|
|
nTimes++;
|
|
if(Library[0][0]==0)
|
|
{
|
|
return;
|
|
}
|
|
fprintf(FP7,"%s\n","");
|
|
fprintf(FP7,"%s\n","#ifndef LINUXBCX");
|
|
fprintf(FP7,"%s\n","#if !defined( __LCC__ )");
|
|
{int i;
|
|
for(i=0; i<=MaxLib-1; i+=1)
|
|
{
|
|
if(Library[i][0]==0&&nCount>0)
|
|
{
|
|
goto NEXTLIB;
|
|
}
|
|
else if(Library[i][0]==0)
|
|
{
|
|
goto NEXTLIB;
|
|
}
|
|
strcpy(ltmp,Library[i]);
|
|
RemoveAll(ltmp,join(2,"<>",DQ));
|
|
if(instr_b(RmLibs,ltmp))
|
|
{
|
|
continue;
|
|
}
|
|
if(nCount==0)
|
|
{
|
|
nCount++;
|
|
fprintf(FP7,"%s\n","// *************************************************");
|
|
fprintf(FP7,"%s\n","// Instruct Linker to Search Object/Import Libraries");
|
|
fprintf(FP7,"%s\n","// *************************************************");
|
|
}
|
|
fprintf(FP7,"%s%s%s\n","#pragma comment(lib,",enc(ltmp),")");
|
|
}
|
|
}
|
|
|
|
NEXTLIB:;
|
|
fprintf(FP7,"%s\n","#else");
|
|
strcat(RmLibs,",<libc.lib>,<kernel32.lib>,<comdlg32.lib>,<user32.lib>,<gdi32.lib>,<advapi32.lib>,<comctl32.lib>,<crtdll.lib>");
|
|
{int i;
|
|
for(i=0; i<=MaxLib-1; i+=1)
|
|
{
|
|
if(Library[i][0]==0&&nCount>0)
|
|
{
|
|
fprintf(FP7,"%s\n","// *************************************************");
|
|
fprintf(FP7,"%s\n","// End of Object/Import Libraries To Search");
|
|
fprintf(FP7,"%s\n","// *************************************************");
|
|
goto LIBEND;
|
|
}
|
|
else if(Library[i][0]==0)
|
|
{
|
|
goto LIBEND;
|
|
}
|
|
if(instr_b(RmLibs,Library[i]))
|
|
{
|
|
continue;
|
|
}
|
|
if(nCount==0)
|
|
{
|
|
nCount++;
|
|
fprintf(FP7,"%s\n","");
|
|
fprintf(FP7,"%s\n","// *************************************************");
|
|
fprintf(FP7,"%s\n","// Instruct Linker to Search Object/Import Libraries");
|
|
fprintf(FP7,"%s\n","// *************************************************");
|
|
}
|
|
fprintf(FP7,"%s%s\n","#pragma lib ",Library[i]);
|
|
}
|
|
}
|
|
|
|
LIBEND:;
|
|
fprintf(FP7,"%s\n","#endif");
|
|
fprintf(FP7,"%s\n","#endif // LINUXBCX not defined");
|
|
}
|
|
|
|
|
|
void AddGlobal (char * GlobalName,int GlobalType,int GlobalDef,char * GlobalDim,int GlobalPtr,int GlobalFS,int GlobalExtn,int iEmitted,int iConst)
|
|
{
|
|
char FirstVar[2048];
|
|
char SecondVar[2048];
|
|
char Warn[2048];
|
|
int ss;
|
|
int s;
|
|
if(RestrictedWords(GlobalName)&&TestState)
|
|
{
|
|
strcpy(Warn, join(3,"Restricted Word ",GlobalName," on Line"));
|
|
strcpy(Warn, join(4,Warn,str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])));
|
|
Warning(Warn);
|
|
}
|
|
ss=HashNumber(GlobalName);
|
|
while(GlobalVarHash[ss])
|
|
{
|
|
s=GlobalVarHash[ss];
|
|
if(str_cmp(GlobalName,GlobalVars[s].VarName)==0)
|
|
{
|
|
if(InConditional==0||(InConditional>0&&str_cmp(InIfDef,GlobalVars[s].VarCondDef)==0))
|
|
{
|
|
if(GlobalVars[s].VarType!=GlobalType||str_cmp(GlobalDim,GlobalVars[s].VarDim)!=0 || GlobalVars[s].VarDef!=GlobalDef)
|
|
{
|
|
strcpy(FirstVar, join(11,"Line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," : ",GlobalName,GlobalDim," as ",GetVarTypeName(GlobalType)," ",TypeDefs[GlobalDef].VarName));
|
|
strcpy(SecondVar, join(11,"Line",str(GlobalVars[s].VarLine)," in Module: ",GlobalVars[s].VarModule," : ",GlobalName,GlobalVars[s].VarDim," as ",GetVarTypeName(GlobalVars[s].VarType)," ",TypeDefs[GlobalVars[s].VarDef].VarName));
|
|
strcpy(Warn, join(4,"Two Variables ",FirstVar," previously defined at ",SecondVar));
|
|
Warning(Warn);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
ss=imod(ss+1,MaxGlobalVars);
|
|
}
|
|
GlobalVarCnt++;
|
|
if(GlobalVarCnt==MaxGlobalVars)
|
|
{
|
|
Abort("Maximum Global Variables reached.");
|
|
}
|
|
strcpy(GlobalVars[GlobalVarCnt].VarName,GlobalName);
|
|
GlobalVars[GlobalVarCnt].VarType=GlobalType;
|
|
GlobalVars[GlobalVarCnt].VarDef=GlobalDef;
|
|
strcpy(GlobalVars[GlobalVarCnt].VarDim,GlobalDim);
|
|
GlobalVars[GlobalVarCnt].VarLine=ModuleLineNos[ModuleNdx];
|
|
GlobalVars[GlobalVarCnt].VarPntr=GlobalPtr;
|
|
GlobalVars[GlobalVarCnt].VarSF=GlobalFS;
|
|
GlobalVars[GlobalVarCnt].VarEmitFlag=iEmitted;
|
|
strcpy(GlobalVars[GlobalVarCnt].VarModule,trim(Modules[ModuleNdx]));
|
|
GlobalVars[GlobalVarCnt].VarExtn=GlobalExtn;
|
|
GlobalVars[GlobalVarCnt].VarCondLevel=InConditional;
|
|
GlobalVars[GlobalVarCnt].VarConstant=iConst;
|
|
strcpy(GlobalVars[GlobalVarCnt].VarCondDef,InIfDef);
|
|
GlobalVarHash[ss]=GlobalVarCnt;
|
|
}
|
|
|
|
|
|
void AddLocal (char * LocalName,int LocalType,int LocalDef,char * LocalDim,int LocalPtr,int LocalFS,int iEmitted,int iConst)
|
|
{
|
|
int varid=0;
|
|
char FirstVar[2048];
|
|
char SecondVar[2048];
|
|
char Warn[2048];
|
|
int s;
|
|
if(LocalVarCnt&&TestState)
|
|
{
|
|
if(CheckGlobal(LocalName, &varid)!=vt_UNKNOWN)
|
|
{
|
|
if(LocalDef)
|
|
{
|
|
strcpy(FirstVar, join(9,"Line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," : ",LocalName,LocalDim," as ",TypeDefs[LocalDef].VarName));
|
|
}
|
|
else
|
|
{
|
|
strcpy(FirstVar, join(9,"Line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," : ",LocalName,LocalDim," as ",GetVarTypeName(LocalType)));
|
|
}
|
|
if(GlobalVars[varid].VarDef)
|
|
{
|
|
strcpy(SecondVar, join(9,"Line",str(GlobalVars[varid].VarLine)," in Module: ",GlobalVars[varid].VarModule," : ",LocalName,GlobalVars[varid].VarDim," as ",TypeDefs[GlobalVars[varid].VarDef].VarName));
|
|
}
|
|
else
|
|
{
|
|
strcpy(SecondVar, join(9,"Line",str(GlobalVars[varid].VarLine)," in Module: ",GlobalVars[varid].VarModule," : ",LocalName,GlobalVars[varid].VarDim," as ",GetVarTypeName(GlobalVars[varid].VarType)));
|
|
}
|
|
strcpy(Warn, join(5,"Local Variable ",FirstVar,CRLF,"Has Same Name as Global ",SecondVar));
|
|
Warning(Warn);
|
|
}
|
|
for(s=1; s<=LocalVarCnt; s+=1)
|
|
{
|
|
if(str_cmp(LocalName,LocalVars[s].VarName)==0)
|
|
{
|
|
if(LocalVars[s].VarType!=LocalType||str_cmp(LocalDim,LocalVars[s].VarDim)!=0 || LocalVars[s].VarDef!=LocalDef)
|
|
{
|
|
strcpy(FirstVar, join(11,"Line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," : ",LocalName,LocalDim," as ",GetVarTypeName(LocalType)," ",TypeDefs[LocalDef].VarName));
|
|
strcpy(SecondVar, join(11,"Line",str(LocalVars[s].VarLine)," in Module: ",LocalVars[s].VarModule," : ",LocalName,LocalVars[s].VarDim," as ",GetVarTypeName(LocalVars[s].VarType)," ",TypeDefs[LocalVars[s].VarDef].VarName));
|
|
strcpy(Warn, join(4,"Two Variables ",FirstVar," previously defined at ",SecondVar));
|
|
Warning(Warn);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
LocalVarCnt++;
|
|
if(LocalVarCnt==MaxLocalVars)
|
|
{
|
|
strcpy(Warn,"Maximum Local Variables reached.");
|
|
Abort(Warn);
|
|
}
|
|
strcpy(LocalVars[LocalVarCnt].VarName,LocalName);
|
|
LocalVars[LocalVarCnt].VarType=LocalType;
|
|
LocalVars[LocalVarCnt].VarDef=LocalDef;
|
|
strcpy(LocalVars[LocalVarCnt].VarDim,LocalDim);
|
|
LocalVars[LocalVarCnt].VarLine=ModuleLineNos[ModuleNdx];
|
|
LocalVars[LocalVarCnt].VarPntr=LocalPtr;
|
|
LocalVars[LocalVarCnt].VarSF=LocalFS;
|
|
LocalVars[LocalVarCnt].VarEmitFlag=iEmitted;
|
|
LocalVars[LocalVarCnt].VarConstant=iConst;
|
|
strcpy(LocalVars[LocalVarCnt].VarModule,trim(Modules[ModuleNdx]));
|
|
}
|
|
|
|
|
|
int IsNumber (char *a)
|
|
{
|
|
int i=0;
|
|
if(!*a)
|
|
{
|
|
return FALSE;
|
|
}
|
|
while(a[i])
|
|
{
|
|
if(a[i]>47&&a[i]<58)
|
|
{
|
|
i++;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int IsNumberEx (char *a)
|
|
{
|
|
int i=0;
|
|
if(!*a)
|
|
{
|
|
return FALSE;
|
|
}
|
|
while(a[i])
|
|
{
|
|
if(a[i]>44&&a[i]<58)
|
|
{
|
|
i++;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void StripTabs (void)
|
|
{
|
|
int i=0;
|
|
while(Src[i])
|
|
{
|
|
if(Src[i]==9)
|
|
{
|
|
Src[i]=32;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
|
|
void PushFileIO (void)
|
|
{
|
|
FPtr[++FPtrNdx]=SourceFile;
|
|
}
|
|
|
|
|
|
void PopFileIO (void)
|
|
{
|
|
if(FPtrNdx==0)
|
|
{
|
|
return;
|
|
}
|
|
if(SourceFile)
|
|
{
|
|
fclose(SourceFile);
|
|
SourceFile=NULL;
|
|
}
|
|
LinesRead+=(ModuleLineNos[ModuleNdx--]);
|
|
SourceFile=FPtr[FPtrNdx--];
|
|
}
|
|
|
|
|
|
int Inset (char *Mane, char *Match)
|
|
{
|
|
int i=-1;
|
|
int j=-1;
|
|
while(Match[++i])
|
|
{
|
|
while(Mane[++j])
|
|
{
|
|
if(Match[i]==Mane[j])
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
j=-1;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
void CheckParQuotes (void)
|
|
{
|
|
int CountR=0;
|
|
int CountS=0;
|
|
int i=0;
|
|
bool DoCount=TRUE;
|
|
while(Src[i])
|
|
{
|
|
if(Src[i]==34)
|
|
{
|
|
DoCount=!DoCount;
|
|
}
|
|
if(DoCount)
|
|
{
|
|
if(Src[i]==40)
|
|
{
|
|
CountR++;
|
|
}
|
|
else if(Src[i]==41)
|
|
{
|
|
CountR--;
|
|
}
|
|
else if(Src[i]==91)
|
|
{
|
|
CountS++;
|
|
}
|
|
else if(Src[i]==93)
|
|
{
|
|
CountS--;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
if(!DoCount)
|
|
{
|
|
Abort("Unmatched Quotes");
|
|
}
|
|
else if(CountS)
|
|
{
|
|
Abort("Unmatched []");
|
|
}
|
|
else if(CountR)
|
|
{
|
|
Abort("Unmatched ()");
|
|
}
|
|
}
|
|
|
|
|
|
void ClearIfThenStacks (void)
|
|
{
|
|
{int i;
|
|
for(i=0; i<=127; i+=1)
|
|
{
|
|
*SrcStk[i]=0;
|
|
}
|
|
}
|
|
SrcCnt=0;
|
|
}
|
|
|
|
|
|
int IsQuoted (char *ZZ)
|
|
{
|
|
if(!iMatchLft(ltrim(ZZ),DQ))
|
|
{
|
|
return 0;
|
|
}
|
|
if(!iMatchRgt(rtrim(ZZ),DQ))
|
|
{
|
|
return 0;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void PostProcess (void)
|
|
{
|
|
int A;
|
|
if(ReDirect==TRUE)
|
|
{
|
|
if((FP1=fopen(FileOut,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",FileOut);
|
|
exit(1);
|
|
}
|
|
while(!EoF(FP1))
|
|
{
|
|
Z[0]=0;
|
|
AR_fgets_retval=fgets(Z,65535,FP1);
|
|
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
|
|
printf("%s\n",Z);
|
|
}
|
|
CloseAll();
|
|
}
|
|
strcpy(OutfileClone,FileOut);
|
|
for(A=1; A<=EntryCnt; A+=1)
|
|
{
|
|
strcpy(OutfileClone,extract(OutfileClone,"."));
|
|
strcpy(Cmd,RemoveStr(Entry[A],DQ));
|
|
strcpy(Cmd,replace(Cmd,"\\\\","\\"));
|
|
strcpy(Cmd,iReplace(Cmd,"$file$",extract(OutfileClone,".")));
|
|
printf("%s%s\n","Shelling Out To: ",Cmd);
|
|
Shell(Cmd);
|
|
}
|
|
if(Compiler[0]>0)
|
|
{
|
|
strcpy(Compiler,trim(RemoveStr(Compiler,DQ)));
|
|
if(inchr(Compiler," "))
|
|
{
|
|
strcpy(Compiler, join(3,enc(extract(Compiler," "))," ",remain(Compiler," ")));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Compiler,enc(Compiler));
|
|
}
|
|
strcpy(FileOut, join(2,extract(FileOut,"."),".cc"));
|
|
strcpy(Compiler, join(3,Compiler," ",FileOut));
|
|
strcpy(Compiler,iReplace(Compiler,"$FILE$",extract(OutfileClone,".")));
|
|
strcpy(Compiler,replace(Compiler,"\\\\","\\"));
|
|
strcpy(Compiler,replace(Compiler,DDQ,DQ));
|
|
printf("%s%s\n","Shelling Out To: ",Compiler);
|
|
Shell(Compiler);
|
|
}
|
|
if(Linker[0]>0)
|
|
{
|
|
strcpy(Linker,trim(RemoveStr(Linker,DQ)));
|
|
if(inchr(Linker," "))
|
|
{
|
|
strcpy(Linker, join(5,DQ,extract(Linker," "),DQ," ",remain(Linker," ")));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Linker,enc(Linker));
|
|
}
|
|
strcpy(FileOut, join(2,extract(FileOut,"."),".obj"));
|
|
strcpy(Linker, join(3,Linker," ",FileOut));
|
|
strcpy(Linker,iReplace(Linker,"$FILE$",extract(OutfileClone,".")));
|
|
strcpy(Linker,replace(Linker,"\\\\","\\"));
|
|
strcpy(Linker,replace(Linker,DDQ,DQ));
|
|
printf("%s%s\n","Shelling Out To:",Linker);
|
|
Shell(Linker);
|
|
}
|
|
for(A=1; A<=XitCount; A+=1)
|
|
{
|
|
strcpy(FileOut,extract(FileOut,"."));
|
|
strcpy(Cmd,RemoveStr(Xit[A],DQ));
|
|
strcpy(Cmd,iReplace(Cmd,"$FILE$",extract(OutfileClone,".")));
|
|
strcpy(Cmd,replace(Cmd,"\\\\","\\"));
|
|
strcpy(Cmd,replace(Cmd,DDQ,DQ));
|
|
printf("%s%s\n","Shelling Out To: ",Cmd);
|
|
Shell(Cmd);
|
|
}
|
|
}
|
|
|
|
|
|
void XParse (char *Arg)
|
|
{
|
|
char lszTmp[2048];
|
|
int j;
|
|
int i=0;
|
|
int Gapflag=0;
|
|
int InIF=0;
|
|
if(str_cmp(trim(Arg),"")==0)
|
|
{
|
|
Ndx=0;
|
|
return;
|
|
}
|
|
i=iMatchNQ(Arg,"&&");
|
|
while(i)
|
|
{
|
|
strcpy(Arg,del(Arg,i,2));
|
|
strcpy(Arg,ins(Arg,i," and "));
|
|
i=iMatchNQ(Arg,"&&");
|
|
}
|
|
FastLexer(Arg,SPC,"=&()[]{}',+-*/<>?;.|:^");
|
|
while(++i<17)
|
|
{
|
|
*Stk[i+Ndx]=0;
|
|
}
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Keyword1,lcase(Stk[i]));
|
|
if(Keyword1[1]!=0)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword1,"and")==0)
|
|
{
|
|
strcpy(Stk[i],"&&");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword1,"or")==0)
|
|
{
|
|
strcpy(Stk[i],"||");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword1,"not")==0)
|
|
{
|
|
strcpy(Stk[i],"!");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword1,"is")==0)
|
|
{
|
|
strcpy(Stk[i],"=");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword1,"xor")==0)
|
|
{
|
|
strcpy(Stk[i],"xor");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword1,"if")==0 || str_cmp(Keyword1,"iif")==0 || str_cmp(Keyword1,"iif$")==0 || str_cmp(Keyword1,"case")==0 || str_cmp(Keyword1,"elseif")==0 || str_cmp(Keyword1,"while")==0)
|
|
{
|
|
InIF=1;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword1,"then")==0)
|
|
{
|
|
InIF=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword1,"byval")==0)
|
|
{
|
|
*Stk[i]=0;
|
|
Gapflag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword1,"byref")==0)
|
|
{
|
|
if(!iMatchWrd(Stk[1],"declare")&&!iMatchWrd(Stk[1],"c_declare"))
|
|
{
|
|
strcpy(ByrefVars[++ByrefCnt],Stk[i+1]);
|
|
}
|
|
for(j=i; j<=Ndx; j+=1)
|
|
{
|
|
if(str_cmp(Stk[j+1],",")==0 || str_cmp(Stk[j+1],")")==0)
|
|
{
|
|
strcpy(Stk[j],"PTR");
|
|
break;
|
|
}
|
|
strcpy(Stk[j],Stk[j+1]);
|
|
}
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
if(PassOne)
|
|
{
|
|
if(str_cmp(Keyword1,enc(chr(92)))==0)
|
|
{
|
|
strcpy(Stk[i],"chr$");
|
|
InsertTokens(i,3,"(","92",")");
|
|
i+=(3);
|
|
}
|
|
else if(TranslateSlash)
|
|
{
|
|
strcpy(Stk[i],replace(Stk[i],"\\","\\\\"));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(!InIF)
|
|
{
|
|
if(str_cmp(Stk[i],"&&")==0)
|
|
{
|
|
strcpy(Stk[i],"BAND");
|
|
}
|
|
else if(str_cmp(Stk[i],"||")==0)
|
|
{
|
|
strcpy(Stk[i],"BOR");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(;;)
|
|
{
|
|
if((UCHAR)*(Keyword1)==38)
|
|
{
|
|
if(i<3||inchr("+&,(=",Stk[i-1]))
|
|
{
|
|
strcpy(Stk[i+1], join(2," &",Stk[i+1]));
|
|
*Stk[i]=0;
|
|
Gapflag=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
if((UCHAR)*(Keyword1)==63)
|
|
{
|
|
strcpy(Stk[i],"print");
|
|
break;
|
|
}
|
|
if((UCHAR)*(Keyword1)==45)
|
|
{
|
|
if((UCHAR)*(Stk[i+1])==62)
|
|
{
|
|
strcpy(Stk[i], join(2,"->",Stk[i+2]));
|
|
*Stk[++i]=0;
|
|
*Stk[++i]=0;
|
|
Gapflag=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
if((UCHAR)*(Keyword1)==46)
|
|
{
|
|
if(IsNumber(Stk[i-1]))
|
|
{
|
|
strcpy(Stk[i], join(2,Stk[i-1],"."));
|
|
*Stk[i-1]=0;
|
|
Gapflag=TRUE;
|
|
}
|
|
if(!inchr(",)=<>*/+-^",Stk[i+1]))
|
|
{
|
|
strcpy(Stk[i], join(2,Stk[i],Stk[i+1]));
|
|
*Stk[++i]=0;
|
|
Gapflag=TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(Gapflag)
|
|
{
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(!*Stk[i])
|
|
{
|
|
j=i+1;
|
|
while(!*Stk[j]&&(j<Ndx))
|
|
{
|
|
j++;
|
|
}
|
|
if(!*Stk[j])
|
|
{
|
|
break;
|
|
}
|
|
strcpy(Stk[i],Stk[j]);
|
|
*Stk[j]=0;
|
|
}
|
|
}
|
|
Ndx=i-1;
|
|
}
|
|
if(PassOne==1)
|
|
{
|
|
if(InFunc)
|
|
{
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
for(j=1; j<=ByrefCnt; j+=1)
|
|
{
|
|
if(iMatchLft(Stk[i]," &"))
|
|
{
|
|
strcpy(lszTmp,Stk[i]+2);
|
|
}
|
|
else
|
|
{
|
|
strcpy(lszTmp,Stk[i]);
|
|
}
|
|
if(str_cmp(Clean(lszTmp),Clean(ByrefVars[j]))==0)
|
|
{
|
|
if(i>2)
|
|
{
|
|
if(inchr("+-^%*/|&<=>,",Stk[i-2])&&str_cmp(Stk[i-1],"*")==0)
|
|
{
|
|
*Stk[i-1]=0;
|
|
}
|
|
if(iMatchLft(Stk[i]," &"))
|
|
{
|
|
strcpy(Stk[i],Stk[i]+2);
|
|
break;
|
|
}
|
|
}
|
|
else if(i==2)
|
|
{
|
|
if(str_cmp(Stk[i-1],"*")==0)
|
|
{
|
|
*Stk[i-1]=0;
|
|
}
|
|
}
|
|
strcpy(Stk[i], join(2,"*",Stk[i]));
|
|
if(str_cmp(Stk[i-1],"(")!=0 || str_cmp(Stk[i+1],")")!=0)
|
|
{
|
|
strcpy(Stk[i],enc(Stk[i],40,41));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(iMatchWrd(Stk[1],"dim"))
|
|
{
|
|
if(iMatchWrd(Stk[Ndx-1],"static"))
|
|
{
|
|
strcpy(Stk[1],"static");
|
|
strcpy(Stk[Ndx-1],Stk[Ndx]);
|
|
Ndx--;
|
|
}
|
|
}
|
|
strcpy(Keyword1,lcase(Stk[1]));
|
|
if(InTypeDef)
|
|
{
|
|
if(str_cmp(Keyword1,"end")!=0 && str_cmp(Keyword1,"dim")!=0 && str_cmp(Keyword1,"declare")!=0 && str_cmp(Keyword1,"type")!=0 && str_cmp(Keyword1,"union")!=0)
|
|
{
|
|
InsertTokens(0,1,"dim");
|
|
}
|
|
}
|
|
if(!InTypeDef)
|
|
{
|
|
char lsz[2048];
|
|
int Res=1;
|
|
strcpy(lsz, join(3,SPC,Keyword1,SPC));
|
|
if(iMatchNQ(" dim , local , global , raw , static , shared , dynamic , auto , register , extern ",lsz))
|
|
{
|
|
Res=1;
|
|
}
|
|
strcpy(lsz, join(3,SPC,lcase(Stk[2]),SPC));
|
|
if(iMatchNQ(" dim , local , global , raw , static , shared , dynamic , auto , register , extern ",lsz))
|
|
{
|
|
Res=2;
|
|
}
|
|
if(Res>0)
|
|
{
|
|
i=Ndx;
|
|
while(i>1&&str_cmp(Stk[i],")")!=0)
|
|
{
|
|
if(iMatchWrd(Stk[i],"as"))
|
|
{
|
|
if(iMatchWrd(Stk[i+1],"function"))
|
|
{
|
|
if(i+1==Ndx)
|
|
{
|
|
*Stk[i]=0;
|
|
}
|
|
*Stk[i+1]=0;
|
|
InsertTokens(Res,1,"function");
|
|
}
|
|
else if(iMatchWrd(Stk[i+1],"sub"))
|
|
{
|
|
if(i+1==Ndx)
|
|
{
|
|
*Stk[i]=0;
|
|
}
|
|
*Stk[i+1]=0;
|
|
InsertTokens(Res,1,"sub");
|
|
}
|
|
RemEmptyTokens();
|
|
break;
|
|
}
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
if(InTypeDef||iMatchWrd(Stk[1],"declare")||iMatchWrd(Stk[1],"c_declare"))
|
|
{
|
|
if(iMatchWrd(Stk[2],"sub")||iMatchWrd(Stk[2],"function"))
|
|
{
|
|
{int i;
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchLft(Stk[i],"as")&&iMatchWrd(Stk[i+1],"string"))
|
|
{
|
|
if(*Stk[i+2]!=42)
|
|
{
|
|
strcpy(Stk[i+1],"char *");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void TokenSubstitutions (void)
|
|
{
|
|
int A;
|
|
int CompPtr;
|
|
int CompToken;
|
|
char Keyword[2048];
|
|
int a;
|
|
int i;
|
|
int j;
|
|
int Tmp;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"as"))
|
|
{
|
|
if(iMatchWrd(Stk[i+1],"string"))
|
|
{
|
|
if(str_cmp(Stk[i+2],"*")==0)
|
|
{
|
|
strcpy(Stk[i],"[");
|
|
strcpy(Stk[i+1],Stk[i+3]);
|
|
strcpy(Stk[i+2],"]");
|
|
strcpy(Stk[i+3],"as");
|
|
Ndx++;
|
|
strcpy(Stk[Ndx],"char");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(!InFunc)
|
|
{
|
|
if(iMatchWrd(Stk[i],"global"))
|
|
{
|
|
strcpy(Stk[i],"dim");
|
|
}
|
|
}
|
|
}
|
|
A=FALSE;
|
|
for(Tmp=1; Tmp<=Ndx; Tmp+=1)
|
|
{
|
|
if(*Stk[Tmp]==48&&Stk[Tmp][1]!=120&&Stk[Tmp][1]!=108)
|
|
{
|
|
strcpy(Stk[Tmp],ltrim(Stk[Tmp],48));
|
|
if(Stk[Tmp][0]==0)
|
|
{
|
|
strcpy(Stk[Tmp],"0");
|
|
}
|
|
}
|
|
if(iMatchWrd(Stk[Tmp],"xor"))
|
|
{
|
|
strcpy(Stk[Tmp],"^");
|
|
}
|
|
else if(str_cmp(Stk[Tmp],"=")==0 && str_cmp(Stk[Tmp+1],">")==0)
|
|
{
|
|
strcpy(Stk[Tmp],">");
|
|
strcpy(Stk[Tmp+1],"=");
|
|
}
|
|
else if(str_cmp(Stk[Tmp],"=")==0 && str_cmp(Stk[Tmp+1],"<")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"<");
|
|
strcpy(Stk[Tmp+1],"=");
|
|
}
|
|
else if(str_cmp(Stk[Tmp],"<")==0 && str_cmp(Stk[Tmp+1],">")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"!=");
|
|
*Stk[Tmp+1]=0;
|
|
A=TRUE;
|
|
}
|
|
else if(str_cmp(Stk[Tmp],">")==0 && str_cmp(Stk[Tmp+1],"<")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"!=");
|
|
*Stk[Tmp+1]=0;
|
|
A=TRUE;
|
|
}
|
|
else if(str_cmp(Stk[Tmp],"!")==0 && str_cmp(Stk[Tmp+1],"=")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"!=");
|
|
*Stk[Tmp+1]=0;
|
|
A=TRUE;
|
|
}
|
|
}
|
|
if(A==TRUE)
|
|
{
|
|
RemEmptyTokens();
|
|
}
|
|
CompToken=0;
|
|
for(Tmp=1; Tmp<=Ndx; Tmp+=1)
|
|
{
|
|
A=CheckLocal(Stk[Tmp], &i);
|
|
if(A==vt_UNKNOWN)
|
|
{
|
|
A=CheckGlobal(Stk[Tmp], &i);
|
|
}
|
|
if(A==vt_STRUCT||A==vt_UDT||A==vt_UNION)
|
|
{
|
|
CompToken=1;
|
|
}
|
|
if(iMatchWrd(Stk[Tmp],"int")&&str_cmp(Stk[Tmp+1],"(")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"fint");
|
|
}
|
|
else if(iMatchWrd(Stk[Tmp],"integer"))
|
|
{
|
|
strcpy(Stk[Tmp],"int");
|
|
}
|
|
else if(iMatchWrd(Stk[Tmp],"fint")&&str_cmp(Stk[Tmp+1],")")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"int");
|
|
}
|
|
}
|
|
CompPtr=0;
|
|
for(Tmp=1; Tmp<=Ndx; Tmp+=1)
|
|
{
|
|
strcpy(Keyword,lcase(Stk[Tmp]));
|
|
a=inchr("abcdefghijklmnopqrstuvwxyz",Keyword);
|
|
for(;;)
|
|
{
|
|
if(a==1)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"abs")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"abs");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"acos")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"acos");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"acosl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"acosl");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"acosh")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"acosh");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"appexename$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"AppExeName$()");
|
|
Use_AppExeName=Use_BcxSplitPath=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"appexepath$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"AppExePath$()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
Use_AppExePath=Use_BcxSplitPath=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ansitowide")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"AnsiToWide");
|
|
Use_AnsiToWide=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"argc")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"argc");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"argv")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"argv");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"argv$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"argv$");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"asc")==0)
|
|
{
|
|
i=0;
|
|
j=GetNumArgs(Tmp+2, &i);
|
|
if(*Stk[Tmp+2]==*DQ)
|
|
{
|
|
if(j>0||*Stk[Tmp+3]!=41)
|
|
{
|
|
strcpy(Stk[Tmp],"asc");
|
|
Use_Asc=TRUE;
|
|
}
|
|
else
|
|
{
|
|
if(str_cmp(Stk[Tmp+2],DDQ)==0)
|
|
{
|
|
strcpy(Stk[Tmp],"0");
|
|
}
|
|
else
|
|
{
|
|
strcpy(Stk[Tmp],ltrim(str((UCHAR)*(Stk[Tmp+2]+1))));
|
|
}
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
*Stk[Tmp+3]=0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(j>0)
|
|
{
|
|
strcpy(Stk[i],"+");
|
|
}
|
|
strcpy(Stk[Tmp],"(UCHAR)*");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"asin")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"asin");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"asinl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"asinl");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"asinh")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"asinh");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"atanh")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"atanh");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"atn")==0 || str_cmp(Keyword,"atan")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"atan");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"atnl")==0 || str_cmp(Keyword,"atanl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"atanl");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"auto")==0)
|
|
{
|
|
if(iMatchWrd(Stk[Tmp+1],"local"))
|
|
{
|
|
strcpy(Stk[Tmp],"dim");
|
|
strcpy(Stk[Tmp+1],"raw");
|
|
}
|
|
else
|
|
{
|
|
strcpy(Stk[Tmp],"auto");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==2)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"bcopy")==0)
|
|
{
|
|
*Stk[1]=0;
|
|
for(i=Tmp+1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"to"))
|
|
{
|
|
break;
|
|
}
|
|
strcat(Stk[1],Stk[i]);
|
|
}
|
|
*Stk[2]=0;
|
|
for(i=i+1; i<=Ndx; i+=1)
|
|
{
|
|
strcat(Stk[2],Stk[i]);
|
|
}
|
|
strcpy(Src, join(7,"memmove(&",Stk[2],",&",Stk[1],",sizeof(",Stk[2],"))"));
|
|
strcpy(Src,RemoveStr(Src,"&*"));
|
|
Ndx=0;
|
|
XParse(Src);
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bel$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"BEL$");
|
|
Use_BEL=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bs$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"BS$");
|
|
Use_BS=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bool")==0 || str_cmp(Keyword,"boolean")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"bool");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"band")==0)
|
|
{
|
|
strcpy(Stk[Tmp]," BAND ");
|
|
Use_Band=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bnot")==0)
|
|
{
|
|
strcpy(Stk[Tmp]," BNOT ");
|
|
Use_Bnot=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bcx_font")==0)
|
|
{
|
|
strcpy(Stk[Tmp],ucase(Stk[Tmp]));
|
|
char tmp[2048];
|
|
strcpy(tmp,Clean(ucase(Stk[Tmp+1])));
|
|
for(;;)
|
|
{
|
|
if(str_cmp(tmp,".NAME")==0)
|
|
{
|
|
strcpy(Stk[Tmp+1],".lf.lfFaceName$");
|
|
break;
|
|
}
|
|
if(str_cmp(tmp,".BOLD")==0)
|
|
{
|
|
strcpy(Stk[Tmp+1],".lf.lfWeight");
|
|
break;
|
|
}
|
|
if(str_cmp(tmp,".UNDERLINE")==0)
|
|
{
|
|
strcpy(Stk[Tmp+1],".lf.lfUnderline");
|
|
break;
|
|
}
|
|
if(str_cmp(tmp,".STRIKEOUT")==0)
|
|
{
|
|
strcpy(Stk[Tmp+1],".lf.lfStrikeOut");
|
|
break;
|
|
}
|
|
if(str_cmp(tmp,".ITALIC")==0)
|
|
{
|
|
strcpy(Stk[Tmp+1],".lf.lfItalic");
|
|
break;
|
|
}
|
|
if(str_cmp(tmp,".CHARSET")==0)
|
|
{
|
|
strcpy(Stk[Tmp+1],".lf.lfCharSet");
|
|
break;
|
|
}
|
|
if(str_cmp(tmp,".SIZE")==0 || str_cmp(tmp,".RGB")==0)
|
|
{
|
|
strcpy(Stk[Tmp+1],tmp);
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
strcpy(Stk[Tmp+1],Clean(Stk[Tmp+1]));
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bcxsplitpath$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$BcxSplitPath$");
|
|
Use_BcxSplitPath=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bcxpath$")==0)
|
|
{
|
|
UseFlag=TRUE;
|
|
strcpy(Stk[Tmp],"BcxPath$()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bcxfont")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"BcxFont");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bcxsocket")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"BcxSocket");
|
|
Use_Socket=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bcxsocketsend")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"BcxSocketSend");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bcxsocketread")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"BcxSocketRead");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bcxsocketclose")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"BcxSocketClose");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bcx_thread")==0 || str_cmp(Keyword,"bcx_threadwait")==0 || str_cmp(Keyword,"bcx_threadsuspend")==0 || str_cmp(Keyword,"bcx_threadresume")==0 || str_cmp(Keyword,"bcx_threadkill")==0 || str_cmp(Keyword,"bcx_threadend")==0)
|
|
{
|
|
strcpy(Stk[Tmp],ucase(Stk[Tmp]));
|
|
Use_Threads=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bin$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$Bin$");
|
|
Use_Bin=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bool$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$BoolStr$");
|
|
Use_Boolstr=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bin2dec")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Bin2Dec");
|
|
Use_Bin2dec=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"boolean")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"BOOLEAN");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"bor")==0)
|
|
{
|
|
strcpy(Stk[Tmp]," BOR ");
|
|
Use_Bor=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"byte")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"BYTE");
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==3)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"containedin")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"containedin");
|
|
Use_ContainedIn=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"copyfile")==0)
|
|
{
|
|
Use_CopyFile=TRUE;
|
|
Use_Exist=Use_Lof=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cr$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CR$");
|
|
Use_CR=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"close#")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"close");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"close")==0)
|
|
{
|
|
if(str_cmp(left(Stk[Tmp+1],1),"#")==0)
|
|
{
|
|
strcpy(Stk[Tmp+1],mid(Stk[Tmp+1],2));
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cvd")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CVD");
|
|
Use_Cvd=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cvi")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CVI");
|
|
Use_Cvi=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cvl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CVL");
|
|
Use_Cvl=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cvld")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CVLD");
|
|
Use_Cvld=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cvs")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CVS");
|
|
Use_Cvs=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"concat")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"strcat");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"chr$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$chr$");
|
|
Use_Chr=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"char")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"char");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"crlf$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CRLF$");
|
|
Use_Crlf=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cbctl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"LOWORD(wParam)");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cbctlmsg")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"HIWORD(wParam)");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cblparam")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"lParam");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cbmsg")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Msg");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cbwparam")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"wParam");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cdbl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CDBL");
|
|
Use_Cdbl=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"chdrive")==0 || str_cmp(Keyword,"chdir")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"chdir");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cint")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Cint");
|
|
Use_Cint=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cldbl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CLDBL");
|
|
Use_Cldbl=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"clng")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CLNG");
|
|
Use_Clng=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cls")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"cls");
|
|
Use_Cls=Use_ESC=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"color")==0 || str_cmp(Keyword,"color_fg")==0 || str_cmp(Keyword,"color_bg")==0)
|
|
{
|
|
strcpy(Stk[Tmp],lcase(Stk[Tmp]));
|
|
Use_Color=Use_Console=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"command$")==0)
|
|
{
|
|
Use_Command=Use_SPC=UseFlag=TRUE;
|
|
strcpy(Stk[Tmp],"command$(-1)");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"command$");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"colorref")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"COLORREF");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cos")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"cos");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cosl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"cosl");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cosh")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"cosh");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"cbool")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CBOOL");
|
|
static struct _functionParse fp;
|
|
memset(&fp,0,sizeof(fp));
|
|
static int i;
|
|
memset(&i,0,sizeof(i));
|
|
static int t;
|
|
memset(&t,0,sizeof(t));
|
|
static int expos=0;
|
|
memset(&expos,0,sizeof(expos));
|
|
if(SepFuncArgs(Tmp+1, &fp,TRUE)==0)
|
|
{
|
|
Abort("No argument specified in CBOOL");
|
|
}
|
|
for(i=fp.CommaPos[0]; i<=fp.CommaPos[1]; i+=1)
|
|
{
|
|
t=inchr("!<>=",Stk[i]);
|
|
if(t)
|
|
{
|
|
if(t<4)
|
|
{
|
|
if(str_cmp(Stk[i+1],"=")==0)
|
|
{
|
|
strcpy(Stk[i], join(2,Stk[i],Stk[i+1]));
|
|
*Stk[i+1]=0;
|
|
}
|
|
else if(t==1&&str_cmp(Stk[i],"!=")!=0)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(str_cmp(Stk[i+1],"=")!=0)
|
|
{
|
|
strcpy(Stk[i],"==");
|
|
}
|
|
}
|
|
expos=i;
|
|
break;
|
|
}
|
|
}
|
|
t=DataType(Stk[expos-1]);
|
|
if(t==vt_STRLIT||t==vt_STRVAR)
|
|
{
|
|
if(expos)
|
|
{
|
|
strcpy(Stk[Tmp+1], join(2,Stk[Tmp+1],"strcmp("));
|
|
strcpy(Stk[fp.CommaPos[1]], join(3,")",Stk[expos],"0)"));
|
|
strcpy(Stk[expos],",");
|
|
*Src=0;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Src, join(3,Src,Stk[i],SPC));
|
|
}
|
|
FastLexer(Src," ","(),");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"csng")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CSNG");
|
|
Use_Csng=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"curdir$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"curdir$()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
Use_Curdir=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"currency")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"CURRENCY");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"c_declare")==0)
|
|
{
|
|
strcpy(CallType,"__attribute__((cdecl)) ");
|
|
strcpy(Stk[Tmp],"declare");
|
|
if(iMatchWrd(Stk[4],"lib"))
|
|
{
|
|
NoTypeDeclare=FALSE;
|
|
}
|
|
else
|
|
{
|
|
NoTypeDeclare=TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==4)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"declare")==0)
|
|
{
|
|
strcpy(CallType,"__attribute__((stdcall)) ");
|
|
strcpy(Stk[Tmp],"declare");
|
|
if(!iMatchWrd(Stk[4],"lib"))
|
|
{
|
|
NoTypeDeclare=TRUE;
|
|
}
|
|
else
|
|
{
|
|
NoTypeDeclare=FALSE;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"dq$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"DQ$");
|
|
Use_DQ=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ddq$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"DDQ$");
|
|
Use_DDQ=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"data$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"DATA$");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"date$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$timef$(12)");
|
|
Use_Time=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"delete")==0)
|
|
{
|
|
if(UseCpp==FALSE)
|
|
{
|
|
Abort("'DELETE' can only be used with C++");
|
|
}
|
|
strcpy(Stk[Tmp],"delete ");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"del$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"del$");
|
|
Use_Del=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"double")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"double");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"download")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Download");
|
|
Use_Download=Use_Dynacall=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"dsplit")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"DSplit");
|
|
Use_DSplit=TRUE;
|
|
Use_Remove=TRUE;
|
|
Use_StrStr=TRUE;
|
|
Use_Mid=TRUE;
|
|
Use_Left=TRUE;
|
|
Use_Instr=TRUE;
|
|
Use_Stristr=TRUE;
|
|
UseLCaseTbl=TRUE;
|
|
UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"dword")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"DWORD");
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==5)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"extern")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"extern");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"enc$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$enc$");
|
|
Use_Enclose=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"extract$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$extract$");
|
|
Use_Extract=Use_StrStr=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"eof$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"EF$");
|
|
Use_EOF=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"eof")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"EoF");
|
|
Use_Eof=UseFlag=TRUE;
|
|
if(DataType(Stk[Tmp+2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"esc$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"ESC$");
|
|
Use_ESC=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"enum")==0)
|
|
{
|
|
if(Ndx==1||iMatchWrd(Stk[3],"enum"))
|
|
{
|
|
Use_EnumFile=TRUE;
|
|
int EnumFlag=FALSE;
|
|
fprintf(FP11,"%s\n","");
|
|
if(Ndx==1)
|
|
{
|
|
fprintf(FP11,"%s\n","enum");
|
|
}
|
|
else
|
|
{
|
|
fprintf(FP11,"%s%s\n","enum ",Stk[1]);
|
|
}
|
|
fprintf(FP11,"%s\n"," {");
|
|
*Src=0;
|
|
while(!iMatchLft(Src,"end "))
|
|
{
|
|
if(EoF(SourceFile))
|
|
{
|
|
Abort("Unbalanced ENUM");
|
|
}
|
|
Src[0]=0;
|
|
AR_fgets_retval=fgets(Src,65535,SourceFile);
|
|
if(Src[strlen(Src)-1]==10)Src[strlen(Src)-1]=0;
|
|
ModuleLineNos[ModuleNdx]++;
|
|
StripCode(Src);
|
|
if(iMatchLft(Src,"$comme"))
|
|
{
|
|
Directives();
|
|
continue;
|
|
}
|
|
strcpy(Src,trim(Src));
|
|
if(Src[0]==0)
|
|
{
|
|
continue;
|
|
}
|
|
if(str_cmp(lcase(left(join(2,Src," "),4)),"end ")==0)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if(EnumFlag==FALSE)
|
|
{
|
|
EnumFlag=TRUE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(FP11,"%s\n",",");
|
|
}
|
|
}
|
|
fprintf(FP11,"%s%s"," ",rtrim(Src));
|
|
}
|
|
*Src=0;
|
|
Ndx=0;
|
|
fprintf(FP11,"%s\n","");
|
|
fprintf(FP11,"%s\n"," };\n");
|
|
return;
|
|
}
|
|
strcpy(Stk[1],"enum {");
|
|
for(j=2; j<=Ndx; j+=1)
|
|
{
|
|
strcat(Stk[1],Stk[j]);
|
|
}
|
|
strcat(Stk[1],"}");
|
|
Ndx=1;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"environ$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Environ$");
|
|
Use_Environ=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"exist")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Exist");
|
|
Use_Exist=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"exp")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Exp");
|
|
Use_Exp=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==6)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"freeglobals")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FreeGlobals");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ff$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FF$");
|
|
Use_FF=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"function")==0)
|
|
{
|
|
if(str_cmp(Stk[Tmp+1],"=")==0)
|
|
{
|
|
if(str_cmp(Stk[Tmp+2],DDQ)==0)
|
|
{
|
|
strcpy(Stk[Tmp+2],"NUL$");
|
|
}
|
|
strcpy(Stk[Tmp],"functionreturn");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"false")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FALSE");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"file")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FILE");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"findintype")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FindInType");
|
|
Use_FindInType=TRUE;
|
|
char StMem[2048];
|
|
char StName[2048];
|
|
char VarName[2048];
|
|
static struct _functionParse fp;
|
|
memset(&fp,0,sizeof(fp));
|
|
SepFuncArgs(Tmp, &fp,TRUE);
|
|
strcpy(StMem,remain(Clean(GetArg(2, &fp)),"."));
|
|
strcpy(VarName,extract(Clean(GetArg(2, &fp)),"."));
|
|
for(j=fp.CommaPos[1]+1; j<=fp.CommaPos[2]-1; j+=1)
|
|
{
|
|
*Stk[j]=0;
|
|
}
|
|
if(CheckLocal(VarName, &i)!=vt_UNKNOWN)
|
|
{
|
|
strcpy(StName,TypeDefs[LocalVars[i].VarDef].VarName);
|
|
}
|
|
else if(CheckGlobal(VarName, &i)!=vt_UNKNOWN)
|
|
{
|
|
strcpy(StName,TypeDefs[GlobalVars[i].VarDef].VarName);
|
|
}
|
|
j=fp.CommaPos[1]+1;
|
|
strcpy(Stk[j], join(9,"(char*)",VarName," + offsetof(",StName,",",StMem,"), sizeof(",StName,")"));
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"farproc")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FARPROC");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"fillarray")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"fillarray");
|
|
Use_FillArray=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"findfirst$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"findfirst$");
|
|
j=GetNumArgs(Tmp+2);
|
|
if(j==0)
|
|
{
|
|
strcpy(Stk[Ndx],", &FindData)");
|
|
}
|
|
Use_Findfirst=Use_Like=TRUE;
|
|
Use_BcxSplitPath=TRUE;
|
|
Use_Join=TRUE;
|
|
UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"findnext$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"findnext$");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
strcpy(Stk[Tmp+1],"(&FindData");
|
|
}
|
|
else if(Tmp==Ndx)
|
|
{
|
|
Ndx++;
|
|
strcpy(Stk[Ndx],"(&FindData)");
|
|
}
|
|
Use_Findnext=Use_Like=UseFlag=TRUE;
|
|
Use_Join=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"fint")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FINT");
|
|
Use_Fint=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"fix")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FIX");
|
|
Use_Fix=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"filelocked")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FileLocked");
|
|
Use_FileLocked=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"flush")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"fflush");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"frac")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FRAC");
|
|
Use_Frac=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"fracl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FRACL");
|
|
Use_Fracl=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"freefile")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"FreeFile()");
|
|
Use_Freefile=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==7)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"getprocaddress")==0)
|
|
{
|
|
static char GlobalName[2048];
|
|
memset(&GlobalName,0,sizeof(GlobalName));
|
|
static int s;
|
|
memset(&s,0,sizeof(s));
|
|
static int ss;
|
|
memset(&ss,0,sizeof(ss));
|
|
static char tempA[2048];
|
|
memset(&tempA,0,sizeof(tempA));
|
|
strcpy(GlobalName,Stk[Tmp-2]);
|
|
ss=HashNumber(GlobalName);
|
|
while(GlobalVarHash[ss])
|
|
{
|
|
s=GlobalVarHash[ss];
|
|
if(str_cmp(GlobalName,GlobalVars[s].VarName)==0)
|
|
{
|
|
strcpy(tempA,TypeDefs[GlobalVars[s].VarDef].VarName);
|
|
if(GlobalVars[s].VarPntr)
|
|
{
|
|
strcat(tempA," *");
|
|
}
|
|
}
|
|
ss=imod(ss+1,MaxGlobalVars);
|
|
}
|
|
if(tempA[0]==0)
|
|
{
|
|
static char LocalName[2048];
|
|
memset(&LocalName,0,sizeof(LocalName));
|
|
strcpy(LocalName,Stk[Tmp-2]);
|
|
if(LocalVarCnt)
|
|
{
|
|
{int i;
|
|
for(i=1; i<=LocalVarCnt; i+=1)
|
|
{
|
|
if(str_cmp(LocalName,LocalVars[i].VarName)==0)
|
|
{
|
|
strcpy(tempA,TypeDefs[LocalVars[i].VarDef].VarName);
|
|
if(LocalVars[i].VarPntr)
|
|
{
|
|
strcat(tempA," *");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(tempA[0]!=0)
|
|
{
|
|
strcpy(Stk[Tmp], join(3,"(",tempA,")dlsym"));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Stk[Tmp],"dlsym");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"getattr")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"GETATTR");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"getbvalue")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"GetBValue");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"getc")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"getc");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"getgvalue")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"GetGValue");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"getrvalue")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"GetRValue");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"getresource")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"GetResource");
|
|
Use_Embed=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==8)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"hiword")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"HIWORD");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"hex$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"hex$");
|
|
Use_Hex=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"hex2dec")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Hex2Dec");
|
|
Use_Hex2Dec=UseLCaseTbl=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"hibyte")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"HIBYTE");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"hide")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Hide");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"hypot")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"hypot");
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==9)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"inherits")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"inherits");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"instr")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"instr_b");
|
|
Use_Instr=Use_StrStr=TRUE;
|
|
Use_Stristr=UseLCaseTbl=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"inchr")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"inchr");
|
|
Use_Inchr=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"imod")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"imod");
|
|
Use_Imod=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"iif")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"iif");
|
|
Use_Iif=TRUE;
|
|
for(i=Tmp+1; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"=")==0)
|
|
{
|
|
if(str_cmp(Stk[i-1],"<")!=0 && str_cmp(Stk[i-1],">")!=0)
|
|
{
|
|
strcpy(Stk[i],"==");
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"iif$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"sziif$");
|
|
Use_sziif=TRUE;
|
|
for(i=Tmp+1; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"=")==0)
|
|
{
|
|
if(str_cmp(Stk[i-1],"<")!=0 && str_cmp(Stk[i-1],">")!=0)
|
|
{
|
|
strcpy(Stk[i],"==");
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"inkey")==0)
|
|
{
|
|
Use_InkeyD=TRUE;
|
|
Use_GetCh=TRUE;
|
|
UseFlag=TRUE;
|
|
strcpy(Stk[Tmp],"inkeyd()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"inkey$")==0)
|
|
{
|
|
Use_Inkey=TRUE;
|
|
Use_GetCh=TRUE;
|
|
UseFlag=TRUE;
|
|
strcpy(Stk[Tmp],"inkey$()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ins$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"ins$");
|
|
Use_Ins=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"instat")==0)
|
|
{
|
|
Use_Instat=TRUE;
|
|
strcpy(Stk[Tmp],"kbhit()");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"instrrev")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"InstrRev");
|
|
Use_Instrrev=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"isptr")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"IsPtr");
|
|
Use_Isptr=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ireplace$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"iReplace$");
|
|
Use_iReplace=Use_Stristr=UseFlag=TRUE;
|
|
UseLCaseTbl=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"iremove$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"IRemoveStr$");
|
|
Use_IRemove=UseFlag=TRUE;
|
|
Use_Stristr=UseLCaseTbl=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"iterate")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"continue");
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==10)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"join$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$join$");
|
|
Use_Join=UseFlag=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==11)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"keypress")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"keypress()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
Use_Keypress=TRUE;
|
|
Use_GetCh=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==12)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"loadfile$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$LoadFile$");
|
|
Use_LoadFile=Use_Get=UseFlag=TRUE;
|
|
Use_Exist=Use_Lof=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"lf$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"LF$");
|
|
Use_LF=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"line")==0)
|
|
{
|
|
if(iMatchWrd(Stk[Tmp+1],"input"))
|
|
{
|
|
Use_Lineinput=TRUE;
|
|
strcpy(Stk[Tmp],"lineinput");
|
|
j=Tmp+4;
|
|
*Stk[Tmp+1]=0;
|
|
for(i=Tmp+2; i<=Ndx; i+=1)
|
|
{
|
|
if(*Stk[i]==44)
|
|
{
|
|
j=i+1;
|
|
break;
|
|
}
|
|
strcpy(Stk[Tmp+1], join(2,Stk[Tmp+1],Stk[i]));
|
|
*Stk[i]=0;
|
|
}
|
|
for(i=j; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[Tmp+2], join(2,Stk[Tmp+2],Stk[i]));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"lcase$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$lcase$");
|
|
Use_Lcase=TRUE;
|
|
Use_StrUpLow=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ldouble")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"LDOUBLE");
|
|
Use_Ldouble=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"left$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$left$");
|
|
Use_Left=TRUE;
|
|
UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"long")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"long");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"longlong")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"LONGLONG");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"lpbyte")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"LPBYTE");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"len")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"strlen");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"lprint")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"lprint");
|
|
if(Tmp==Ndx)
|
|
{
|
|
Ndx++;
|
|
strcpy(Stk[Ndx],enc(""));
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"lpad$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$lpad$");
|
|
Use_Lpad=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ltrim$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$ltrim$");
|
|
Use_Ltrim=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"lof")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"lof");
|
|
if(DataType(Stk[Tmp+2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
|
|
}
|
|
Use_Lof=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"loadlibrary")==0 || str_cmp(Keyword,"load_dll")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"LoadLibrary");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"like")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"like");
|
|
Use_Like=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"lobyte")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"LOBYTE");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"loc")==0)
|
|
{
|
|
if(DataType(Stk[Tmp+2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
|
|
}
|
|
strcpy(Stk[Tmp], join(5,"loc(",Stk[Tmp+2],",",Stk[Tmp+2],"len)"));
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
*Stk[Tmp+3]=0;
|
|
Use_Loc=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"locate")==0)
|
|
{
|
|
Use_Locate=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"log")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"log");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"logl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"logl");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"log10")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"log10");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"log10l")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"log10l");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"loword")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"LOWORD");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"lpstr")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"PCHAR");
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==13)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"mkd$")==0)
|
|
{
|
|
if(Tmp>2)
|
|
{
|
|
if(inchr(Stk[Tmp-2],"$")&&*Stk[Tmp-1]==61)
|
|
{
|
|
strcpy(Stk[1], join(2,"memcpy(",Stk[1]));
|
|
strcpy(Stk[Tmp-1],",");
|
|
strcpy(Stk[++Ndx],",9)");
|
|
}
|
|
}
|
|
strcpy(Stk[Tmp],"MKD");
|
|
Use_Mkd=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"mki$")==0)
|
|
{
|
|
if(Tmp>2)
|
|
{
|
|
if(inchr(Stk[Tmp-2],"$")&&*Stk[Tmp-1]==61)
|
|
{
|
|
strcpy(Stk[1], join(2,"memcpy(",Stk[1]));
|
|
strcpy(Stk[Tmp-1],",");
|
|
strcpy(Stk[++Ndx],",3)");
|
|
}
|
|
}
|
|
strcpy(Stk[Tmp],"MKI");
|
|
Use_Mki=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"mkl$")==0)
|
|
{
|
|
if(Tmp>2)
|
|
{
|
|
if(inchr(Stk[Tmp-2],"$")&&*Stk[Tmp-1]==61)
|
|
{
|
|
strcpy(Stk[1], join(2,"memcpy(",Stk[1]));
|
|
strcpy(Stk[Tmp-1],",");
|
|
strcpy(Stk[++Ndx],",5)");
|
|
}
|
|
}
|
|
strcpy(Stk[Tmp],"MKL");
|
|
Use_Mkl=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"mkld$")==0)
|
|
{
|
|
if(Tmp>2)
|
|
{
|
|
if(inchr(Stk[Tmp-2],"$")&&*Stk[Tmp-1]==61)
|
|
{
|
|
strcpy(Stk[1], join(2,"memcpy(",Stk[1]));
|
|
strcpy(Stk[Tmp-1],",");
|
|
strcpy(Stk[++Ndx],",11)");
|
|
}
|
|
}
|
|
strcpy(Stk[Tmp],"MKLD");
|
|
Use_Mkld=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"mks$")==0)
|
|
{
|
|
if(Tmp>2)
|
|
{
|
|
if(inchr(Stk[Tmp-2],"$")&&*Stk[Tmp-1]==61)
|
|
{
|
|
strcpy(Stk[1], join(2,"memcpy(",Stk[1]));
|
|
strcpy(Stk[Tmp-1],",");
|
|
strcpy(Stk[++Ndx],",5)");
|
|
}
|
|
}
|
|
strcpy(Stk[Tmp],"MKS");
|
|
Use_Mks=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"mid$")==0)
|
|
{
|
|
if(Tmp>1)
|
|
{
|
|
strcpy(Stk[Tmp],"$$mid$");
|
|
Use_Mid=UseFlag=TRUE;
|
|
}
|
|
else
|
|
{
|
|
strcpy(Stk[Tmp],"midstr");
|
|
Use_Midstr=UseFlag=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"min")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"_MIN_");
|
|
Use_Min=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"main")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"main");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"makeintresource")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"MAKEINTRESOURCE");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"makelong")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"MAKELONG");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"makeword")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"MAKEWORD");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"max")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"_MAX_");
|
|
Use_Max=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"mcase$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$mcase$");
|
|
Use_Mcase=UseFlag=TRUE;
|
|
Use_StrUpLow=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"mkdir")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"mkdir");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"mod")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"fmod");
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==14)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"new")==0)
|
|
{
|
|
if(iMatchWrd(Stk[Tmp-1],"binary"))
|
|
{
|
|
break;
|
|
}
|
|
if(UseCpp==FALSE)
|
|
{
|
|
Abort("'NEW' can only be used with C++");
|
|
}
|
|
strcpy(Stk[Tmp],"new ");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"nul$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"NUL$");
|
|
Use_NUL=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"null")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"NULL");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"now$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"now$()");
|
|
Use_Now=UseFlag=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==15)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"open")==0)
|
|
{
|
|
for(A=Tmp+1; A<=Ndx; A+=1)
|
|
{
|
|
if(str_cmp(left(Stk[A],1),"#")==0)
|
|
{
|
|
strcpy(Stk[A],mid(Stk[A],2));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"oct$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"oct$");
|
|
Use_Oct=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"osversion")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"OSVersion()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
Use_OSVersion=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==16)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"pause")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Pause()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
Use_Pause=Use_Keypress=TRUE;
|
|
Use_GetCh=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"preserve")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"PRESERVE");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"print#")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"fprint");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"print")==0)
|
|
{
|
|
if(str_cmp(left(Stk[Tmp+1],1),"#")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"fprint");
|
|
strcpy(Stk[Tmp+1],mid(Stk[Tmp+1],2));
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ptr")==0)
|
|
{
|
|
CompPtr=1;
|
|
strcpy(Stk[Tmp-1], join(2,Stk[Tmp-1],"*"));
|
|
*Stk[Tmp]=0;
|
|
if(Tmp==Ndx)
|
|
{
|
|
Ndx--;
|
|
while(tally(Stk[Ndx],"*")==strlen(Stk[Ndx]))
|
|
{
|
|
strcpy(Stk[Ndx-1], join(2,Stk[Ndx-1],Stk[Ndx]));
|
|
*Stk[Ndx]=0;
|
|
Ndx--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
i=Tmp-1;
|
|
while(tally(Stk[i],"*")==strlen(Stk[i]))
|
|
{
|
|
strcpy(Stk[i-1], join(2,Stk[i-1],Stk[i]));
|
|
*Stk[i]=0;
|
|
i--;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"peek$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$peekstr$");
|
|
Use_PeekStr=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"poke")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"memmove");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"pow")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"pow");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"powl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"powl");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"private")==0)
|
|
{
|
|
if(UseCpp)
|
|
{
|
|
strcpy(Stk[Tmp],"private");
|
|
}
|
|
if(iMatchWrd(Stk[Tmp+1],"const"))
|
|
{
|
|
strcpy(Stk[Tmp],"enum ");
|
|
strcpy(Stk[Tmp+1], join(2,Stk[Tmp+2],"{"));
|
|
Ndx++;
|
|
strcpy(Stk[Ndx],"}");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"public")==0)
|
|
{
|
|
if(UseCpp)
|
|
{
|
|
strcpy(Stk[Tmp],"public");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==17)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"qbcolor")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"qbcolor");
|
|
Use_QBColor=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==18)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"regmatch")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"regmatch");
|
|
Use_PeekStr=Use_RegEx=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"rewind")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"rewind");
|
|
if(DataType(Stk[Tmp+2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"remove$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$RemoveStr$");
|
|
Use_Remove=Use_StrStr=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"replace$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$replace$");
|
|
Use_Replace=Use_StrStr=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"right$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$right$");
|
|
Use_Right=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"rename")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"rename");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"register")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"register");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"randomize")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"randomize");
|
|
Use_Randomize=TRUE;
|
|
Use_Rnd=TRUE;
|
|
if(Ndx==1)
|
|
{
|
|
Use_Timer=TRUE;
|
|
strcpy(Stk[1],"randomize(timer())");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"rec")==0)
|
|
{
|
|
if(DataType(Stk[Tmp+2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
|
|
}
|
|
strcpy(Stk[Tmp], join(5,"rec(",Stk[Tmp+2],",",Stk[Tmp+2],"len)"));
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
*Stk[Tmp+3]=0;
|
|
Use_Rec=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"reccount")==0)
|
|
{
|
|
char length[2048];
|
|
if(DataType(Stk[Tmp+2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[Tmp+2], join(2,"FP",Stk[Tmp+2]));
|
|
}
|
|
strcpy(Stk[Tmp],"reccount");
|
|
strcpy(length, join(2,Stk[Tmp+2],"len)"));
|
|
for(i=Tmp+1; i<=Ndx; i+=1)
|
|
{
|
|
if(*Stk[i]==41)
|
|
{
|
|
*Stk[i]=0;
|
|
break;
|
|
}
|
|
strcpy(Stk[Tmp], join(2,Stk[Tmp],Stk[i]));
|
|
*Stk[i]=0;
|
|
}
|
|
strcpy(Stk[Tmp], join(3,Stk[Tmp],",",length));
|
|
Use_RecCount=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"reclen")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"reclen");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"record")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"record");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"remain$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$remain$");
|
|
Use_Remain=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"retain$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$Retain$");
|
|
Use_Retain=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"repeat$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$repeat$");
|
|
Use_Repeat=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"reverse$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$reverse$");
|
|
Use_Reverse=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"rgb")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"RGB");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"rmdir")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"rmdir");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"rnd")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"rnd()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
Use_Rnd=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"round")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Round");
|
|
Use_Round=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"rpad$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$rpad$");
|
|
Use_Rpad=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"rtrim$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$rtrim$");
|
|
Use_Rtrim=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"run")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Run");
|
|
Use_Run=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==19)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"scanerror")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"ScanError");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sprint")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"sprint");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"spc$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"SPC$");
|
|
Use_SPC=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"str$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$str$");
|
|
Use_Str=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"strl$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$strl$");
|
|
Use_Strl=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"searchpath$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$SEARCHPATH$");
|
|
Use_SearchPath=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sizeof")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"sizeof");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"setattr")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"SETATTR");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"setwindowrtftext")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"SetWindowRTFText");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sgn")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"sgn");
|
|
Use_Sgn=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"short")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"short");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"shell")==0)
|
|
{
|
|
Use_Shell=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"show")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Show");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sin")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"sin");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sinl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"sinl");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"single")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"float");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sinh")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"sinh");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sleep")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"sleep");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"space$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$space$");
|
|
Use_Space=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"split")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Split");
|
|
Use_Split=UseFlag=TRUE;
|
|
Use_Remove=TRUE;
|
|
Use_StrStr=TRUE;
|
|
Use_Mid=TRUE;
|
|
Use_Left=TRUE;
|
|
Use_Instr=TRUE;
|
|
Use_Stristr=TRUE;
|
|
UseLCaseTbl=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"splitbarfg")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"SplitBarFG");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"splitbarbg")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"SplitBarBG");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sqr")==0 || str_cmp(Keyword,"sqrt")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"sqrt");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sqrl")==0 || str_cmp(Keyword,"sqrtl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"sqrtl");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"strarray")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"PCHAR*");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"strim$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$strim$");
|
|
Use_Strim=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"string")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"string");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"string$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$stringx$");
|
|
Use_String=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"strptr")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"STRPTR");
|
|
Use_Strptr=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"strtoken$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"StrToken$");
|
|
Use_Strtoken=Use_Mid=Use_Left=Use_Extract=TRUE;
|
|
Use_Instr=Use_Instrrev=Use_Stristr=Use_Tally=Use_Remove=TRUE;
|
|
Use_StrStr=UseLCaseTbl=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"swap")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"swap");
|
|
Use_Swap=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sysdir$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$sysdir$()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
Use_Sysdir=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sysstr")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"SysStr");
|
|
Use_SysStr=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==20)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"tab$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"TAB$");
|
|
Use_TAB=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"true")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"TRUE");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"trim$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$trim$");
|
|
Use_Trim=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"tally")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"tally");
|
|
Use_Tally=UseLCaseTbl=Use_Stristr=Use_StrStr=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"tan")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"tan");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"tanh")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"tanh");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"tanl")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"tanl");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"tempdir$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$tempdir$()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
Use_Tempdir=UseFlag=Use_Exist=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"tempfilename$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$TempFileName$");
|
|
Use_TempFileName=UseFlag=TRUE;
|
|
Use_Exist=Use_Rnd=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"this")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"this");
|
|
if(*Stk[Tmp+1]==46)
|
|
{
|
|
strcpy(Stk[Tmp+1], join(2,"->",mid(Stk[Tmp+1],2)));
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"time$")==0)
|
|
{
|
|
if(str_cmp(Stk[Tmp+1],"(")!=0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$timef$()");
|
|
}
|
|
else
|
|
{
|
|
strcpy(Stk[Tmp],"$$timef$");
|
|
}
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
Use_Time=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"timer")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"timer()");
|
|
if(str_cmp(Stk[Tmp+1],"(")==0 && str_cmp(Stk[Tmp+2],")")==0)
|
|
{
|
|
*Stk[Tmp+1]=0;
|
|
*Stk[Tmp+2]=0;
|
|
}
|
|
Use_Timer=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==21)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"uint")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"UINT");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ushort")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"USHORT");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ulong")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"ULONG");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ulonglong")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"ULONGLONG");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ucase$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$ucase$");
|
|
Use_Ucase=UseFlag=TRUE;
|
|
Use_StrUpLow=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"ubound")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"ubound");
|
|
Use_Ubound=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"using$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$Using$");
|
|
Use_Using=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"using")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"using");
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==22)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"val")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"VAL");
|
|
Use_Val=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"vall")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"VALL");
|
|
Use_Vall=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"variant")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"VARIANT");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"varptr")==0)
|
|
{
|
|
*Stk[Tmp]=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"vchr$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$vchr$");
|
|
Use_VChr=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"virtual")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"virtual");
|
|
Use_Virtual=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"vt$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"VT$");
|
|
Use_VT=UseFlag=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"verify")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"Verify");
|
|
Use_Verify=Use_Mid=UseFlag=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(a==23)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"widetoansi$")==0)
|
|
{
|
|
strcpy(Stk[Tmp],"$$WideToAnsi$");
|
|
Use_WideToAnsi=UseFlag=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if(CompPtr==1)
|
|
{
|
|
RemEmptyTokens();
|
|
}
|
|
if(WithCnt)
|
|
{
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(left(Stk[i],2),"->")==0 || ( str_cmp(left(Stk[i],1),".")==0 && !IsNumber(mid(Stk[i],2,1))))
|
|
{
|
|
if(str_cmp(WithVar[WithCnt],"this")==0)
|
|
{
|
|
strcpy(Stk[i], join(2,"->",mid(Stk[i],2)));
|
|
}
|
|
if(i==1)
|
|
{
|
|
strcpy(Stk[i], join(2,WithVar[WithCnt],Stk[i]));
|
|
}
|
|
else
|
|
{
|
|
if(!IsReservedWord(Stk[i-1]))
|
|
{
|
|
if(!(isalpha(Stk[i-1][strlen(Stk[i-1]-1)])||IsNumber(right(Stk[i-1],strlen(Stk[i-1]-1)))))
|
|
{
|
|
strcpy(Stk[i], join(2,WithVar[WithCnt],Stk[i]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
strcpy(Stk[i], join(2,WithVar[WithCnt],Stk[i]));
|
|
}
|
|
}
|
|
while((isalpha(*Stk[i+1])||*Stk[i+1]==46)&&(i<Ndx))
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(CompToken==1)
|
|
{
|
|
strcpy(Keyword,lcase(Stk[1]));
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"dim")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"local")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"global")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"static")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"shared")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"raw")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"dynamic")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"free")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"redim")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"sub")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"function")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"overloaded")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"public")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"declare")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"c_declare")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"auto")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"register")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"extern")==0)
|
|
{
|
|
CompToken=0;
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
AsmUnknownStructs(1);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void JoinStrings (int i, int inif)
|
|
{
|
|
int DoJoin=0;
|
|
int InBrace=0;
|
|
int OnlyPara=0;
|
|
int j=0;
|
|
int l=0;
|
|
int sj=i;
|
|
char t[2048];
|
|
int vt;
|
|
while(i<=Ndx)
|
|
{
|
|
strcpy(t,lcase(Stk[i]));
|
|
if(!j&&!OnlyPara&&!InBrace)
|
|
{
|
|
vt=DataType(t);
|
|
if(vt==vt_STRVAR||vt==vt_STRLIT)
|
|
{
|
|
sj=i;
|
|
i++;
|
|
continue;
|
|
}
|
|
}
|
|
for(;;)
|
|
{
|
|
if(str_cmp(t,"&")==0)
|
|
{
|
|
if(OnlyPara)
|
|
{
|
|
break;
|
|
}
|
|
vt=DataType(Stk[i+1]);
|
|
if(vt!=vt_STRVAR&&vt!=vt_STRLIT)
|
|
{
|
|
vt=DataType(Stk[i-1]);
|
|
}
|
|
if(vt==vt_STRVAR||vt==vt_STRLIT)
|
|
{
|
|
j++;
|
|
strcpy(Stk[i],",");
|
|
*t=0;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(t,"[")==0)
|
|
{
|
|
InBrace++;
|
|
break;
|
|
}
|
|
if(str_cmp(t,"]")==0)
|
|
{
|
|
InBrace--;
|
|
break;
|
|
}
|
|
if(str_cmp(t,"(")==0)
|
|
{
|
|
if(str_cmp(Stk[i+1],"*")!=0)
|
|
{
|
|
JoinStrings(i+1,inif);
|
|
l=i-1;
|
|
while(str_cmp(Stk[i],")")!=0)
|
|
{
|
|
strcpy(Stk[l], join(3,Stk[l],Stk[i]," "));
|
|
*Stk[i]=0;
|
|
i++;
|
|
}
|
|
strcat(Stk[l],Stk[i]);
|
|
*Stk[i]=0;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(t,")")==0)
|
|
{
|
|
if(j)
|
|
{
|
|
strcpy(Stk[sj], join(4,"join$(",str(j+1),",",Stk[sj]));
|
|
j=sj+1;
|
|
while(j<i)
|
|
{
|
|
strcat(Stk[sj],Stk[j]);
|
|
*Stk[j]=0;
|
|
j++;
|
|
}
|
|
strcat(Stk[sj],")");
|
|
}
|
|
return;
|
|
}
|
|
if(str_cmp(t,"||")==0)
|
|
{
|
|
strcpy(Stk[i]," or ");
|
|
DoJoin=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(t,"&&")==0)
|
|
{
|
|
strcpy(Stk[i]," and ");
|
|
DoJoin=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(t,"then")==0 || str_cmp(t,"for")==0)
|
|
{
|
|
DoJoin=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(t,"=")==0)
|
|
{
|
|
if(!inif)
|
|
{
|
|
OnlyPara=TRUE;
|
|
}
|
|
else
|
|
{
|
|
DoJoin=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(t,"if")==0 || str_cmp(t,"elseif")==0 || str_cmp(t,"while")==0)
|
|
{
|
|
inif=TRUE;
|
|
sj=i+1;
|
|
break;
|
|
}
|
|
if(str_cmp(t,"sprint")==0 || str_cmp(t,"lprint")==0 || str_cmp(t,"fprint")==0 || str_cmp(t,"fprintf")==0 || str_cmp(t,"print")==0 || str_cmp(t,"print#")==0)
|
|
{
|
|
OnlyPara=TRUE;
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
if(str_cmp(left(Stk[i],2),"].")==0 || str_cmp(left(Stk[i],3),"]->")==0)
|
|
{
|
|
InBrace--;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if((DoJoin||inchr(",+-*/^;:<>~|&",t))&&!OnlyPara&&!InBrace)
|
|
{
|
|
DoJoin=0;
|
|
if(j)
|
|
{
|
|
strcpy(Stk[sj], join(4,"join$(",str(j+1),",",Stk[sj]));
|
|
j=sj;
|
|
j++;
|
|
while(j<i)
|
|
{
|
|
strcat(Stk[sj],Stk[j]);
|
|
*Stk[j]=0;
|
|
j++;
|
|
}
|
|
strcat(Stk[sj],")");
|
|
}
|
|
j=0;
|
|
sj=i+1;
|
|
}
|
|
i++;
|
|
}
|
|
if(j)
|
|
{
|
|
strcpy(Stk[sj], join(4,"join$(",str(j+1),",",Stk[sj]));
|
|
j=sj;
|
|
j++;
|
|
while(j<=i)
|
|
{
|
|
strcat(Stk[sj],Stk[j]);
|
|
*Stk[j]=0;
|
|
j++;
|
|
}
|
|
strcat(Stk[sj],")");
|
|
}
|
|
}
|
|
|
|
|
|
void Transforms (void)
|
|
{
|
|
int nBrace;
|
|
int CntMarker;
|
|
int IFCond;
|
|
int a;
|
|
int i;
|
|
int j;
|
|
char Keyword[2048];
|
|
char lszTmp[2048];
|
|
*Keyword=0;
|
|
*lszTmp=0;
|
|
if(Ndx==3&&!WithCnt)
|
|
{
|
|
if(str_cmp(Stk[2],"+")==0 && str_cmp(Stk[3],"+")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stk[1]),"++;");
|
|
Ndx=0;
|
|
Statements++;
|
|
return;
|
|
}
|
|
if(str_cmp(Stk[2],"-")==0 && str_cmp(Stk[3],"-")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Clean(Stk[1]),"--;");
|
|
Ndx=0;
|
|
Statements++;
|
|
return;
|
|
}
|
|
if(str_cmp(Stk[1],"+")==0 && str_cmp(Stk[2],"+")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"++",Clean(Stk[3]),";");
|
|
Ndx=0;
|
|
Statements++;
|
|
return;
|
|
}
|
|
if(str_cmp(Stk[1],"-")==0 && str_cmp(Stk[2],"-")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"--",Clean(Stk[3]),";");
|
|
Ndx=0;
|
|
Statements++;
|
|
return;
|
|
}
|
|
}
|
|
strcpy(Keyword,lcase(Stk[1]));
|
|
a=inchr("abcdefghijklmnopqrstuvwxyz$",Keyword);
|
|
for(;;)
|
|
{
|
|
if(a==3)
|
|
{
|
|
if(str_cmp(Keyword,"case")==0)
|
|
{
|
|
nBrace=0;
|
|
CntMarker=2;
|
|
j=0;
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(inchr("([",Stk[i]))
|
|
{
|
|
nBrace++;
|
|
}
|
|
if(inchr(")]",Stk[i]))
|
|
{
|
|
nBrace--;
|
|
}
|
|
if(str_cmp(Stk[i],",")==0)
|
|
{
|
|
if(nBrace==0)
|
|
{
|
|
CntMarker=i+1;
|
|
}
|
|
}
|
|
if(iMatchWrd(Stk[i],"to"))
|
|
{
|
|
j=1;
|
|
strcpy(Stk[i]," and <=");
|
|
strcpy(Stk[CntMarker], join(2,">=",Stk[CntMarker]));
|
|
}
|
|
}
|
|
if(j==1)
|
|
{
|
|
*Src=0;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Src, join(3,Src,Stk[i]," "));
|
|
}
|
|
XParse(Src);
|
|
}
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if(a==4)
|
|
{
|
|
if(str_cmp(Keyword,"declare")==0 && iMatchWrd(Stk[4],"lib"))
|
|
{
|
|
char alias[2048];
|
|
int i;
|
|
int idx=-1;
|
|
char AR_DllName[2048];
|
|
strcpy(Stk[5],RemoveStr(Stk[5],DQ));
|
|
for(i=0; i<=LoadLibsCnt-1; i+=1)
|
|
{
|
|
if(str_cmp(Stk[5],Loadlibs[i])==0)
|
|
{
|
|
idx=i;
|
|
break;
|
|
}
|
|
}
|
|
if(idx<0)
|
|
{
|
|
strcpy(Loadlibs[LoadLibsCnt],Stk[5]);
|
|
LoadLibsCnt++;
|
|
}
|
|
if(iMatchWrd(Stk[6],"alias"))
|
|
{
|
|
strcpy(alias,Stk[7]);
|
|
*Stk[6]=0;
|
|
*Stk[7]=0;
|
|
}
|
|
else
|
|
{
|
|
strcpy(alias,enc(Stk[3]));
|
|
}
|
|
DllCnt++;
|
|
if(DllCnt>799)
|
|
{
|
|
Abort("Maximum number of declarations exceded.");
|
|
}
|
|
if(inchr(Stk[5],"-"))
|
|
{
|
|
strcpy(AR_DllName,extract(Stk[5],"-"));
|
|
}
|
|
else if(inchr(Stk[5],"."))
|
|
{
|
|
strcpy(AR_DllName,extract(Stk[5],"."));
|
|
}
|
|
strcpy(DllDecl[DllCnt], join(11,"static BCXFPROT",ltrim(str(DllCnt)),SPC,Clean(Stk[3]),"=(BCXFPROT",ltrim(str(DllCnt)),")dlsym(H_",ucase(AR_DllName),", ",alias,");"));
|
|
*Stk[4]=0;
|
|
*Stk[5]=0;
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if(a==7)
|
|
{
|
|
if(str_cmp(Keyword,"get$")==0)
|
|
{
|
|
strcpy(Stk[1],"~get");
|
|
return;
|
|
}
|
|
if(str_cmp(Keyword,"global")==0 && iMatchWrd(Stk[2],"dynamic"))
|
|
{
|
|
strcpy(Stk[1],"global");
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if(a==9)
|
|
{
|
|
if(str_cmp(Keyword,"iremove")==0)
|
|
{
|
|
char Mat[2048];
|
|
char Fat[2048];
|
|
*Mat=0;
|
|
*Fat=0;
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"from"))
|
|
{
|
|
*Stk[i]=0;
|
|
break;
|
|
}
|
|
}
|
|
for(j=2; j<=i; j+=1)
|
|
{
|
|
strcat(Mat,Stk[j]);
|
|
}
|
|
for(j=i; j<=Ndx; j+=1)
|
|
{
|
|
strcat(Fat,Stk[j]);
|
|
}
|
|
strcpy(lszTmp, join(5,"=iremove$(",Fat,",",Mat,")"));
|
|
FastLexer(Fat," ()","");
|
|
strcpy(lszTmp, join(2,Stk[Ndx],lszTmp));
|
|
XParse(lszTmp);
|
|
TokenSubstitutions();
|
|
Emit();
|
|
Ndx=0;
|
|
return;
|
|
}
|
|
if(str_cmp(Keyword,"ireplace")==0)
|
|
{
|
|
if(Ndx<6)
|
|
{
|
|
Abort("Problem with IREPLACE statement");
|
|
}
|
|
int W;
|
|
int I;
|
|
char VV[2048];
|
|
char RR[2048];
|
|
char WW[2048];
|
|
*VV=0;
|
|
*RR=0;
|
|
*WW=0;
|
|
for(W=2; W<=Ndx; W+=1)
|
|
{
|
|
if(iMatchWrd(Stk[W],"with"))
|
|
{
|
|
*Stk[W]=0;
|
|
break;
|
|
}
|
|
}
|
|
for(I=2; I<=Ndx; I+=1)
|
|
{
|
|
if(iMatchWrd(Stk[I],"in"))
|
|
{
|
|
*Stk[I]=0;
|
|
break;
|
|
}
|
|
}
|
|
i=I+1;
|
|
for(j=i; j<=Ndx; j+=1)
|
|
{
|
|
strcat(VV,Stk[j]);
|
|
}
|
|
for(j=2; j<=W; j+=1)
|
|
{
|
|
strcat(RR,Stk[j]);
|
|
}
|
|
i=W+1;
|
|
for(j=i; j<=I; j+=1)
|
|
{
|
|
strcat(WW,Stk[j]);
|
|
}
|
|
strcpy(lszTmp, join(7,"=ireplace$(",VV,",",RR,",",WW,")"));
|
|
FastLexer(VV," ()","");
|
|
strcpy(lszTmp, join(2,Stk[Ndx],lszTmp));
|
|
XParse(lszTmp);
|
|
TokenSubstitutions();
|
|
Emit();
|
|
Ndx=0;
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if(a==12)
|
|
{
|
|
if(str_cmp(Keyword,"local")==0 && iMatchWrd(Stk[2],"dynamic"))
|
|
{
|
|
strcpy(Stk[1],"dim");
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if(a==16)
|
|
{
|
|
if(str_cmp(Keyword,"put$")==0)
|
|
{
|
|
strcpy(Stk[1],"~put");
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if(a==18)
|
|
{
|
|
if(str_cmp(Keyword,"remove")==0)
|
|
{
|
|
char Mat[2048];
|
|
char Fat[2048];
|
|
*Mat=0;
|
|
*Fat=0;
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"from"))
|
|
{
|
|
*Stk[i]=0;
|
|
break;
|
|
}
|
|
}
|
|
for(j=2; j<=i; j+=1)
|
|
{
|
|
strcat(Mat,Stk[j]);
|
|
}
|
|
for(j=i; j<=Ndx; j+=1)
|
|
{
|
|
strcat(Fat,Stk[j]);
|
|
}
|
|
strcpy(lszTmp, join(5,"=remove$(",Fat,",",Mat,")"));
|
|
FastLexer(Fat," ()","");
|
|
strcpy(lszTmp, join(2,Stk[Ndx],lszTmp));
|
|
XParse(lszTmp);
|
|
TokenSubstitutions();
|
|
Emit();
|
|
Ndx=0;
|
|
return;
|
|
}
|
|
if(str_cmp(Keyword,"replace")==0)
|
|
{
|
|
if(Ndx<6)
|
|
{
|
|
Abort("Problem with REPLACE statement");
|
|
}
|
|
int W;
|
|
int I;
|
|
char VV[2048];
|
|
char RR[2048];
|
|
char WW[2048];
|
|
*VV=0;
|
|
*RR=0;
|
|
*WW=0;
|
|
for(W=2; W<=Ndx; W+=1)
|
|
{
|
|
if(iMatchWrd(Stk[W],"with"))
|
|
{
|
|
*Stk[W]=0;
|
|
break;
|
|
}
|
|
}
|
|
for(I=2; I<=Ndx; I+=1)
|
|
{
|
|
if(iMatchWrd(Stk[I],"in"))
|
|
{
|
|
*Stk[I]=0;
|
|
break;
|
|
}
|
|
}
|
|
i=I+1;
|
|
for(j=i; j<=Ndx; j+=1)
|
|
{
|
|
strcat(VV,Stk[j]);
|
|
}
|
|
for(j=2; j<=W; j+=1)
|
|
{
|
|
strcat(RR,Stk[j]);
|
|
}
|
|
i=W+1;
|
|
for(j=i; j<=I; j+=1)
|
|
{
|
|
strcat(WW,Stk[j]);
|
|
}
|
|
strcpy(lszTmp, join(7,"=replace$(",VV,",",RR,",",WW,")"));
|
|
FastLexer(VV," ()","");
|
|
strcpy(lszTmp, join(2,Stk[Ndx],lszTmp));
|
|
XParse(lszTmp);
|
|
TokenSubstitutions();
|
|
Emit();
|
|
Ndx=0;
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if(a==27)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"$ifndef")==0)
|
|
{
|
|
strcpy(Stk[1],"~ifndef");
|
|
InConditional++;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"$if")==0 || str_cmp(Keyword,"$ifdef")==0)
|
|
{
|
|
strcpy(Stk[1],"~if");
|
|
InConditional++;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"$else")==0)
|
|
{
|
|
strcpy(Stk[1],"~else");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"$elseif")==0)
|
|
{
|
|
strcpy(Stk[1],"~elseif");
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"$endif")==0)
|
|
{
|
|
strcpy(Stk[1],"~endif");
|
|
InConditional--;
|
|
if(InConditional<0)
|
|
{
|
|
Abort("To many $ENDIFs");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"$cpp")==0)
|
|
{
|
|
Ndx=0;
|
|
UseCpp=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"$CPP")==0)
|
|
{
|
|
Ndx=0;
|
|
UseCpp=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
IFCond=0;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"if"))
|
|
{
|
|
IFCond=i+1;
|
|
}
|
|
if(iMatchWrd(Stk[i],"then")&&iMatchWrd(Stk[i+1],"if"))
|
|
{
|
|
for(j=i+2; j<=Ndx; j+=1)
|
|
{
|
|
if(iMatchWrd(Stk[j],"else"))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if(j>Ndx)
|
|
{
|
|
for(j=i; j>=IFCond+1; j+=-1)
|
|
{
|
|
strcpy(Stk[j],Stk[j-1]);
|
|
}
|
|
strcpy(Stk[IFCond],"(");
|
|
i++;
|
|
strcpy(Stk[i],")");
|
|
i++;
|
|
for(j=Ndx; j>=i; j+=-1)
|
|
{
|
|
strcpy(Stk[j+2],Stk[j]);
|
|
}
|
|
Ndx++;
|
|
Ndx++;
|
|
strcpy(Stk[i],"&&");
|
|
i++;
|
|
strcpy(Stk[i],"(");
|
|
i++;
|
|
for(i=i; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"then"))
|
|
{
|
|
Ndx++;
|
|
for(j=Ndx; j>=i; j+=-1)
|
|
{
|
|
strcpy(Stk[j],Stk[j-1]);
|
|
}
|
|
strcpy(Stk[i],")");
|
|
break;
|
|
}
|
|
}
|
|
i--;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Parse (char *Arg)
|
|
{
|
|
int A;
|
|
int B;
|
|
int CommaCnt;
|
|
int Tmp;
|
|
int i;
|
|
int j;
|
|
int k;
|
|
char lszTmp[2048];
|
|
char L_Stk_1[2048];
|
|
char L_Stk_2[2048];
|
|
char Var1[2048];
|
|
int Plus2Amp=0;
|
|
int vt;
|
|
*L_Stk_1=0;
|
|
*L_Stk_2=0;
|
|
*lszTmp=0;
|
|
*Var1=0;
|
|
XParse(Arg);
|
|
PassOne=0;
|
|
if(!iMatchWrd(Stk[1],"function"))
|
|
{
|
|
Plus2Amp=iMatchNQ(Arg,"&");
|
|
for(Tmp=2; Tmp<=Ndx-1; Tmp+=1)
|
|
{
|
|
if(str_cmp(Stk[Tmp],"+")==0)
|
|
{
|
|
vt=DataType(Stk[Tmp+1]);
|
|
if(vt==vt_STRVAR||vt==vt_STRLIT)
|
|
{
|
|
strcpy(Stk[Tmp],"&");
|
|
Plus2Amp=TRUE;
|
|
}
|
|
else
|
|
{
|
|
vt=DataType(Stk[Tmp-1]);
|
|
if(vt==vt_STRVAR||vt==vt_STRLIT)
|
|
{
|
|
strcpy(Stk[Tmp],"&");
|
|
Plus2Amp=TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(Plus2Amp>0)
|
|
{
|
|
Use_Join=UseFlag=TRUE;
|
|
j=0;
|
|
k=0;
|
|
for(Tmp=1; Tmp<=Ndx-1; Tmp+=1)
|
|
{
|
|
A=CheckLocal(Stk[Tmp], &i);
|
|
if(A==vt_UNKNOWN)
|
|
{
|
|
A=CheckGlobal(Stk[Tmp], &i);
|
|
}
|
|
if(A==vt_STRUCT||A==vt_UDT||A==vt_UNION)
|
|
{
|
|
j=1;
|
|
}
|
|
if(str_cmp(Stk[Tmp],"&")==0)
|
|
{
|
|
A=DataType(Stk[Tmp+1]);
|
|
if(A==vt_STRVAR||A==vt_STRLIT)
|
|
{
|
|
k=1;
|
|
}
|
|
else
|
|
{
|
|
A=DataType(Stk[Tmp-1]);
|
|
if(A==vt_STRVAR||A==vt_STRLIT)
|
|
{
|
|
k=1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(k)
|
|
{
|
|
if(j)
|
|
{
|
|
AsmUnknownStructs(0);
|
|
}
|
|
JoinStrings(1,0);
|
|
*Src=0;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(Stk[i][0])
|
|
{
|
|
strcpy(Src, join(3,Src,Stk[i]," "));
|
|
}
|
|
}
|
|
XParse(Src);
|
|
}
|
|
}
|
|
}
|
|
if(UseCpp)
|
|
{
|
|
if(iMatchNQ(Src,"->lpVtbl"))
|
|
{
|
|
{int i;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchRgt(Stk[i],"->lpVtbl"))
|
|
{
|
|
strcpy(Stk[i],extract(Stk[i],"->lpVtbl"));
|
|
if((str_cmp(Stk[i+3],Stk[i-1])==0 || str_cmp(Stk[i+3],Stk[i])==0) && str_cmp(Stk[i+3],")")!=0)
|
|
{
|
|
*Stk[i+3]=0;
|
|
if(str_cmp(Stk[i+4],",")==0)
|
|
{
|
|
*Stk[i+4]=0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
RemEmptyTokens();
|
|
}
|
|
}
|
|
TokenSubstitutions();
|
|
if(Ndx==0)
|
|
{
|
|
return;
|
|
}
|
|
Transforms();
|
|
if(Ndx==0)
|
|
{
|
|
return;
|
|
}
|
|
if(iMatchWrd(Stk[1],"function"))
|
|
{
|
|
if(iMatchWrd(Stk[Ndx-2],"as")&&str_cmp(Stk[Ndx],")")!=0)
|
|
{
|
|
if(!iMatchWrd(Stk[Ndx],"export")&&!iMatchWrd(Stk[Ndx],"stdcall"))
|
|
{
|
|
strcpy(Stk[Ndx-1], join(3,Stk[Ndx-1]," ",Stk[Ndx]));
|
|
Ndx--;
|
|
}
|
|
}
|
|
}
|
|
if(iMatchWrd(Stk[1],"function")||iMatchWrd(Stk[1],"sub"))
|
|
{
|
|
int offset;
|
|
int LastBrk=Ndx-2;
|
|
for(i=Ndx; i>=3; i+=-1)
|
|
{
|
|
if(str_cmp(Stk[i],")")==0)
|
|
{
|
|
LastBrk=i;
|
|
break;
|
|
}
|
|
}
|
|
for(i=3; i<=LastBrk; i+=1)
|
|
{
|
|
offset=2;
|
|
if(iMatchWrd(Stk[i],"as")&&(i<LastBrk)&&str_cmp(Stk[i+offset],"=")!=0)
|
|
{
|
|
if(iMatchWrd(Stk[i+1],"function"))
|
|
{
|
|
offset=3;
|
|
}
|
|
if(!inchr(Stk[i+offset],")")&&!inchr(Stk[i+offset],","))
|
|
{
|
|
if(strlen(Stk[i+offset])!=0&&!iMatchWrd(Stk[i+3],"as"))
|
|
{
|
|
strcpy(Stk[i+offset-1], join(3,Stk[i+offset-1]," ",Stk[i+offset]));
|
|
*Stk[i+offset]=0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(!iMatchWrd(Stk[1],"declare"))
|
|
{
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"lib"))
|
|
{
|
|
if(str_cmp(Stk[i-1],"(")==0 && (DataType(Stk[i+1])==vt_STRLIT||DataType(Stk[i+1])==vt_STRVAR))
|
|
{
|
|
j=GetNumArgs(i+2);
|
|
strcpy(lszTmp,"BCX_DynaCall");
|
|
if(!iMatchWrd(Stk[1],"print"))
|
|
{
|
|
if(DataType(Stk[i-2])==vt_STRVAR||DataType(Stk[1])==vt_STRVAR)
|
|
{
|
|
strcpy(lszTmp, join(2,"(char*)",lszTmp));
|
|
}
|
|
}
|
|
strcpy(Var1,right(Stk[i-2],1));
|
|
if(inchr("!$#¦%",Var1))
|
|
{
|
|
strcat(lszTmp,Var1);
|
|
strcpy(Stk[i],enc(left(Stk[i-2],strlen(Stk[i-2])-1)));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Stk[i],enc(Stk[i-2]));
|
|
}
|
|
strcpy(Stk[i-2],lszTmp);
|
|
for(B=Ndx+3; B>=i+3; B+=-1)
|
|
{
|
|
strcpy(Stk[B],Stk[B-3]);
|
|
}
|
|
strcpy(Stk[i+2],Stk[i+1]);
|
|
strcpy(Stk[i+1],",");
|
|
strcpy(Stk[i+3],",");
|
|
strcpy(Stk[i+4],ltrim(str(j)));
|
|
strcpy(Stk[i+5],sziif(j,",",")"));
|
|
Ndx+=(3);
|
|
Use_Dynacall=TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(inchr(Arg,"^"))
|
|
{
|
|
int lp=0;
|
|
int rp=0;
|
|
Test=FALSE;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"^")==0)
|
|
{
|
|
Test=TRUE;
|
|
if(str_cmp(Stk[i+1],"-")==0)
|
|
{
|
|
Ndx++;
|
|
for(A=Ndx; A>=i+2; A+=-1)
|
|
{
|
|
strcpy(Stk[A],Stk[A-1]);
|
|
}
|
|
strcpy(Stk[i+1],"(");
|
|
B=i+3;
|
|
if(str_cmp(Stk[B],"(")==0)
|
|
{
|
|
lp=0;
|
|
rp=0;
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Stk[B],"(")==0)
|
|
{
|
|
lp++;
|
|
}
|
|
if(str_cmp(Stk[B],")")==0)
|
|
{
|
|
rp++;
|
|
}
|
|
B++;
|
|
if(lp==rp)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
Ndx++;
|
|
j=B+1;
|
|
for(A=Ndx; A>=j; A+=-1)
|
|
{
|
|
strcpy(Stk[A],Stk[A-1]);
|
|
}
|
|
strcpy(Stk[B],")");
|
|
}
|
|
else
|
|
{
|
|
B=i+4;
|
|
if(inchr("[",Stk[B]))
|
|
{
|
|
for(;;)
|
|
{
|
|
B++;
|
|
if(inchr("]",Stk[B]))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
Ndx++;
|
|
j=B+2;
|
|
for(A=Ndx; A>=j; A+=-1)
|
|
{
|
|
strcpy(Stk[A],Stk[A-1]);
|
|
}
|
|
strcpy(Stk[B+1],")");
|
|
}
|
|
else
|
|
{
|
|
if(inchr("(",Stk[B]))
|
|
{
|
|
for(;;)
|
|
{
|
|
B++;
|
|
if(inchr(")",Stk[B]))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
Ndx++;
|
|
j=B+2;
|
|
for(A=Ndx; A>=j; A+=-1)
|
|
{
|
|
strcpy(Stk[A],Stk[A-1]);
|
|
}
|
|
strcpy(Stk[B+1],")");
|
|
}
|
|
else
|
|
{
|
|
Ndx++;
|
|
j=B+1;
|
|
for(A=Ndx; A>=j; A+=-1)
|
|
{
|
|
strcpy(Stk[A],Stk[A-1]);
|
|
}
|
|
strcpy(Stk[B],")");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(Test)
|
|
{
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"^")==0)
|
|
{
|
|
A=i-1;
|
|
B=0;
|
|
while(str_cmp(Stk[A],"=")!=0)
|
|
{
|
|
if(str_cmp(Stk[A],"]")==0)
|
|
{
|
|
B++;
|
|
}
|
|
if(str_cmp(Stk[A],")")==0)
|
|
{
|
|
B++;
|
|
}
|
|
if(str_cmp(Stk[A],"[")==0)
|
|
{
|
|
B--;
|
|
}
|
|
if(str_cmp(Stk[A],"(")==0)
|
|
{
|
|
B--;
|
|
}
|
|
if(B==0)
|
|
{
|
|
break;
|
|
}
|
|
A--;
|
|
}
|
|
if(str_cmp(Stk[A],"[")==0)
|
|
{
|
|
A--;
|
|
}
|
|
if(str_cmp(Stk[A],"=")==0)
|
|
{
|
|
A++;
|
|
}
|
|
if(str_cmp(Stk[A],"(")==0)
|
|
{
|
|
B=DataType(Stk[A-1]);
|
|
if(!iMatchWrd(Stk[A-1],"print")&&(B==vt_INTEGER||B==vt_SINGLE||B==vt_DOUBLE))
|
|
{
|
|
A--;
|
|
}
|
|
}
|
|
strcpy(Arg,"pow(");
|
|
B=A-1;
|
|
while(B>0)
|
|
{
|
|
strcpy(Arg, join(4,Stk[B]," ",Arg," "));
|
|
B--;
|
|
}
|
|
for(B=A; B<=i-1; B+=1)
|
|
{
|
|
strcpy(Arg, join(3,Arg," ",Stk[B]));
|
|
}
|
|
strcat(Arg,",");
|
|
A=i+1;
|
|
B=DataType(Stk[A]);
|
|
if((str_cmp(Stk[A+1],"(")==0 || str_cmp(Stk[A+1],"[")==0) && (B==vt_INTEGER||B==vt_SINGLE||B==vt_DOUBLE))
|
|
{
|
|
A++;
|
|
}
|
|
B=0;
|
|
while(A<=Ndx)
|
|
{
|
|
if(str_cmp(Stk[A],"[")==0)
|
|
{
|
|
B++;
|
|
}
|
|
if(str_cmp(Stk[A],"(")==0)
|
|
{
|
|
B++;
|
|
}
|
|
if(str_cmp(Stk[A],"]")==0)
|
|
{
|
|
B--;
|
|
}
|
|
if(str_cmp(Stk[A],")")==0)
|
|
{
|
|
B--;
|
|
}
|
|
if(!B)
|
|
{
|
|
break;
|
|
}
|
|
A++;
|
|
}
|
|
for(B=i+1; B<=A; B+=1)
|
|
{
|
|
strcpy(Arg, join(3,Arg," ",Stk[B]));
|
|
}
|
|
strcat(Arg,")");
|
|
A++;
|
|
while(A<=Ndx)
|
|
{
|
|
strcpy(Arg, join(3,Arg," ",Stk[A]));
|
|
A++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
Parse(Arg);
|
|
}
|
|
}
|
|
strcpy(L_Stk_1,lcase(Stk[1]));
|
|
strcpy(L_Stk_2,lcase(Stk[2]));
|
|
if(str_cmp(L_Stk_1,"$dll")==0)
|
|
{
|
|
MakeDLL=NoMain=TRUE;
|
|
if(IsApple)
|
|
{
|
|
strcpy(LD_FLAGS,"-fPIC -shared $FILE$.so");
|
|
}
|
|
else
|
|
{
|
|
strcpy(LD_FLAGS,"-fPIC -shared -Wl,-soname,$FILE$.so");
|
|
}
|
|
Ndx=0;
|
|
return;
|
|
}
|
|
IsCallBack=0;
|
|
if(iMatchWrd(Stk[Ndx],"callback"))
|
|
{
|
|
IsCallBack=1;
|
|
Ndx--;
|
|
}
|
|
if(str_cmp(L_Stk_1,"open")==0)
|
|
{
|
|
for(A=1; A<=Ndx; A+=1)
|
|
{
|
|
if(iMatchWrd(Stk[A],"binary"))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if(A<Ndx)
|
|
{
|
|
A++;
|
|
strcpy(Var1,lcase(Stk[A]));
|
|
if(str_cmp(Var1,"new")==0)
|
|
{
|
|
strcpy(Stk[A-1],"binarynew");
|
|
for(i=A+1; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
if(str_cmp(Var1,"append")==0)
|
|
{
|
|
strcpy(Stk[A-1],"binaryappend");
|
|
for(i=A+1; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
if(str_cmp(Var1,"input")==0)
|
|
{
|
|
strcpy(Stk[A-1],"binaryinput");
|
|
for(i=A+1; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
if(str_cmp(Var1,"output")==0)
|
|
{
|
|
strcpy(Stk[A-1],"binaryoutput");
|
|
for(i=A+1; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
}
|
|
}
|
|
if(str_cmp(L_Stk_1,"option")==0 && str_cmp(L_Stk_2,"base")==0)
|
|
{
|
|
OptionBase=VAL(Stk[3]);
|
|
Ndx=0;
|
|
return;
|
|
}
|
|
if(str_cmp(L_Stk_1,"dim")==0)
|
|
{
|
|
if(str_cmp(L_Stk_2,"shared")==0 || str_cmp(L_Stk_2,"dynamic")==0 || str_cmp(L_Stk_2,"raw")==0 || str_cmp(L_Stk_2,"local")==0 || str_cmp(L_Stk_2,"auto")==0 || str_cmp(L_Stk_2,"register")==0 || str_cmp(L_Stk_2,"static")==0)
|
|
{
|
|
strcpy(Stk[1],L_Stk_2);
|
|
strcpy(L_Stk_1,L_Stk_2);
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
}
|
|
if(str_cmp(L_Stk_1,"public")==0)
|
|
{
|
|
if(str_cmp(L_Stk_2,"function")==0 || str_cmp(L_Stk_2,"sub")==0)
|
|
{
|
|
strcpy(Stk[1],L_Stk_2);
|
|
strcpy(L_Stk_1,L_Stk_2);
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
}
|
|
if(str_cmp(L_Stk_1,"private")==0)
|
|
{
|
|
if(str_cmp(L_Stk_2,"function")==0 || str_cmp(L_Stk_2,"sub")==0)
|
|
{
|
|
Use_Static=TRUE;
|
|
strcpy(Stk[1],L_Stk_2);
|
|
strcpy(L_Stk_1,L_Stk_2);
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
}
|
|
if(str_cmp(L_Stk_1,"onexit")==0)
|
|
{
|
|
if(str_cmp(L_Stk_2,"sub")==0)
|
|
{
|
|
Use_ExitCode=TRUE;
|
|
ExitNdx++;
|
|
strcpy(ExitSub[ExitNdx],Stk[3]);
|
|
strcpy(Stk[1],L_Stk_2);
|
|
strcpy(L_Stk_1,L_Stk_2);
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
}
|
|
if(str_cmp(L_Stk_1,"onstart")==0)
|
|
{
|
|
if(str_cmp(L_Stk_2,"sub")==0)
|
|
{
|
|
Use_StartupCode=TRUE;
|
|
StartNdx++;
|
|
strcpy(StartSub[StartNdx],Stk[3]);
|
|
strcpy(Stk[1],L_Stk_2);
|
|
strcpy(L_Stk_1,L_Stk_2);
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
}
|
|
if(str_cmp(L_Stk_1,"overloaded")==0 && str_cmp(L_Stk_2,"function")==0)
|
|
{
|
|
strcpy(Stk[1],"overloadedfunction");
|
|
strcpy(L_Stk_1,"overloadedfunction");
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
if(str_cmp(L_Stk_1,"overloadedfunction")==0 && str_cmp(Stk[2],"=")!=0)
|
|
{
|
|
OkayToSend=TRUE;
|
|
}
|
|
if(str_cmp(L_Stk_1,"overloaded")==0 && str_cmp(L_Stk_2,"sub")==0)
|
|
{
|
|
strcpy(Stk[1],"overloadedsub");
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
if(str_cmp(L_Stk_1,"function")==0 && iMatchWrd(Stk[3],"optional"))
|
|
{
|
|
strcpy(Stk[1],"optfunction");
|
|
strcpy(L_Stk_1,"optfunction");
|
|
for(i=4; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
if(str_cmp(L_Stk_1,"optfunction")==0 && str_cmp(Stk[2],"=")!=0)
|
|
{
|
|
OkayToSend=TRUE;
|
|
}
|
|
if(str_cmp(L_Stk_1,"sub")==0 && iMatchWrd(Stk[3],"optional"))
|
|
{
|
|
strcpy(L_Stk_1,"optsub");
|
|
strcpy(Stk[1],"optsub");
|
|
for(i=4; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i-1],Stk[i]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
if(str_cmp(L_Stk_1,"end")==0 && str_cmp(Stk[2],"=")!=0)
|
|
{
|
|
strcpy(Stk[1], join(2,L_Stk_1,L_Stk_2));
|
|
Ndx=1;
|
|
}
|
|
if(str_cmp(L_Stk_1,"function")==0 && str_cmp(Stk[2],"=")!=0)
|
|
{
|
|
OkayToSend=TRUE;
|
|
}
|
|
if(str_cmp(L_Stk_1,"midstr")==0)
|
|
{
|
|
CommaCnt=0;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],",")==0)
|
|
{
|
|
CommaCnt++;
|
|
}
|
|
else if(str_cmp(Stk[i],"=")==0)
|
|
{
|
|
if(CommaCnt<2)
|
|
{
|
|
strcpy(Stk[i],"-1,");
|
|
}
|
|
else
|
|
{
|
|
*Stk[i]=0;
|
|
}
|
|
strcpy(Stk[i-1],",");
|
|
Ndx++;
|
|
strcpy(Stk[Ndx],")");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(str_cmp(Stk[2],":")==0)
|
|
{
|
|
if(Ndx==2)
|
|
{
|
|
strcpy(Stk[1], join(2,ucase(Stk[1]),":"));
|
|
Ndx=1;
|
|
return;
|
|
}
|
|
}
|
|
if(str_cmp(L_Stk_1,"case")==0 && str_cmp(L_Stk_2,"else")==0)
|
|
{
|
|
Ndx=1;
|
|
strcpy(Stk[1],"caseelse");
|
|
}
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"let"))
|
|
{
|
|
for(j=i+1; j<=Ndx; j+=1)
|
|
{
|
|
strcpy(Stk[j-1],Stk[j]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
}
|
|
if(str_cmp(Stk[Ndx],"*")==0)
|
|
{
|
|
strcpy(Stk[Ndx-1], join(2,Stk[Ndx-1],"*"));
|
|
Ndx--;
|
|
}
|
|
if(TestState==TRUE)
|
|
{
|
|
if(LastCmd==0)
|
|
{
|
|
if(str_cmp(Stk[1],"*")==0)
|
|
{
|
|
strcpy(Z,Clean(Stk[2]));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Z,Clean(Stk[1]));
|
|
}
|
|
if(str_cmp(left(Z,1),"*")==0)
|
|
{
|
|
strcpy(Z,mid(Z,2));
|
|
}
|
|
i=inchr(Z,".");
|
|
if(i==0)
|
|
{
|
|
i=instr_b(Z,"->");
|
|
}
|
|
if(i>0)
|
|
{
|
|
if(WithCnt)
|
|
{
|
|
strcpy(Z,WithVar[WithCnt]);
|
|
}
|
|
else
|
|
{
|
|
strcpy(Z,left(Z,i-1));
|
|
}
|
|
}
|
|
if(inchr(Z,"["))
|
|
{
|
|
strcpy(Z,extract(Z,"["));
|
|
}
|
|
if(CheckLocal(Z, &j)==vt_UNKNOWN)
|
|
{
|
|
if(CheckGlobal(Z, &j)==vt_UNKNOWN)
|
|
{
|
|
strcpy(Z,lcase(Z));
|
|
if(str_cmp(Stk[2],"=")==0 && str_cmp(Z,"functionreturn")!=0 && str_cmp(Z,"bcx_retstr")!=0 && str_cmp(Z,"end")!=0)
|
|
{
|
|
Warning(join(6,"Assignment before Declaration in Line ",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx]),": ",Src));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void FuncSubDecs1 (char *s)
|
|
{
|
|
int i;
|
|
int j;
|
|
if(iMatchWrd(Stk[1],s))
|
|
{
|
|
if(DataType(Stk[2])==vt_STRVAR)
|
|
{
|
|
Abort(join(3,"Invalid ",s,"name"));
|
|
}
|
|
}
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"[")==0 && str_cmp(Stk[i+1],"]")==0)
|
|
{
|
|
if(iMatchWrd(Stk[i+2],"as"))
|
|
{
|
|
strcpy(Stk[i+3], join(2,Stk[i+3],"*"));
|
|
}
|
|
else if(str_cmp(Stk[i+2],"[")==0)
|
|
{
|
|
j=i-1;
|
|
while(i<=Ndx)
|
|
{
|
|
if(iMatchWrd(Stk[i],"as"))
|
|
{
|
|
break;
|
|
}
|
|
if(iMatchRgt(Stk[j],"]")&&inchr(",)=",Stk[i]))
|
|
{
|
|
break;
|
|
}
|
|
strcpy(Stk[j], join(2,Stk[j],Stk[i]));
|
|
*Stk[i++]=0;
|
|
}
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if(DataType(Stk[i-1])==vt_STRVAR)
|
|
{
|
|
strcpy(Stk[i-1], join(2,Stk[i-1],"[][65535]"));
|
|
}
|
|
strcpy(Stk[i-1], join(2,"*",Stk[i-1]));
|
|
}
|
|
*Stk[i++]=0;
|
|
*Stk[i]=0;
|
|
}
|
|
}
|
|
RemEmptyTokens();
|
|
IsExported=FALSE;
|
|
if(iMatchWrd(Stk[Ndx],"export"))
|
|
{
|
|
Ndx--;
|
|
IsExported=TRUE;
|
|
if(UseStdCall)
|
|
{
|
|
strcpy(CallType,"__attribute__((stdcall)) ");
|
|
}
|
|
else
|
|
{
|
|
strcpy(CallType,"__attribute__((cdecl)) ");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void RemEmptyTokens (void)
|
|
{
|
|
int i;
|
|
int j;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(!*Stk[i])
|
|
{
|
|
j=i;
|
|
while(!*Stk[j]&&(j<Ndx))
|
|
{
|
|
j++;
|
|
}
|
|
if(!*Stk[j])
|
|
{
|
|
break;
|
|
}
|
|
strcpy(Stk[i],Stk[j]);
|
|
*Stk[j]=0;
|
|
}
|
|
}
|
|
Ndx=i-1;
|
|
}
|
|
|
|
|
|
void FuncSubDecs2 (char *s, int method)
|
|
{
|
|
if(iMatchWrd(Stk[1],s))
|
|
{
|
|
if(iMatchWrd(Stk[Ndx-1],"as"))
|
|
{
|
|
Abort(join(2,"Attempted type assignment to ",s));
|
|
}
|
|
VarCode.IsPtrFlag=0;
|
|
CurrentFuncType=vt_VOID;
|
|
}
|
|
else
|
|
{
|
|
if(iMatchWrd(Stk[Ndx-1],"as"))
|
|
{
|
|
CurrentFuncType=CheckType(Stk[Ndx]);
|
|
strcpy(VarCode.Token,Stk[2]);
|
|
strcpy(VarCode.AsToken,Stk[Ndx]);
|
|
VarCode.IsPtrFlag=tally(Stk[Ndx],"*");
|
|
*Stk[Ndx]=0;
|
|
*Stk[Ndx-1]=0;
|
|
Ndx--;
|
|
Ndx--;
|
|
}
|
|
else
|
|
{
|
|
CurrentFuncType=DataType(Stk[2]);
|
|
strcpy(VarCode.Token,Stk[2]);
|
|
VarCode.IsPtrFlag=tally(Stk[2],"*");
|
|
*VarCode.AsToken=0;
|
|
}
|
|
}
|
|
strcpy(VarCode.Proto," (");
|
|
strcpy(VarCode.Header," (");
|
|
*VarCode.Functype=0;
|
|
VarCode.Method=method;
|
|
VarCode.VarNo=CurrentFuncType;
|
|
GetVarCode( &VarCode);
|
|
}
|
|
|
|
|
|
void FuncSubDecs3 (VARCODE* varcode)
|
|
{
|
|
if(*Stk[Ndx-1]==46)
|
|
{
|
|
strcat(varcode->Header,"...");
|
|
}
|
|
strcpy(varcode->Header,rtrim(varcode->Header));
|
|
if(iMatchRgt(varcode->Header,","))
|
|
{
|
|
midstr(varcode->Header,strlen(varcode->Header),-1,")");
|
|
}
|
|
else
|
|
{
|
|
strcat(varcode->Header,")");
|
|
}
|
|
strcpy(varcode->Header,replace(varcode->Header,"()","(void)"));
|
|
strcpy(varcode->Header, join(3,varcode->Functype,varcode->Token,varcode->Header));
|
|
if(varcode->Method==2)
|
|
{
|
|
if(*Stk[Ndx-1]==46)
|
|
{
|
|
strcat(varcode->Proto,"...");
|
|
}
|
|
strcpy(varcode->Proto,rtrim(varcode->Proto));
|
|
if(iMatchRgt(varcode->Proto,","))
|
|
{
|
|
midstr(varcode->Proto,strlen(varcode->Proto),-1,")");
|
|
}
|
|
else
|
|
{
|
|
strcat(varcode->Proto,")");
|
|
}
|
|
strcpy(varcode->Proto,replace(varcode->Proto,"()","(void)"));
|
|
strcpy(varcode->Proto, join(4,varcode->Functype,varcode->Token,varcode->Proto,";"));
|
|
}
|
|
if(IsExported)
|
|
{
|
|
strcpy(varcode->Proto, join(2,"C_EXPORT ",varcode->Proto));
|
|
strcpy(varcode->Header, join(2,"C_EXPORT ",varcode->Header));
|
|
}
|
|
}
|
|
|
|
|
|
void AddTypeDefs (char *TypeName, int TDef)
|
|
{
|
|
TypeDefsCnt++;
|
|
if(TypeDefsCnt==MaxTypes)
|
|
{
|
|
Abort("Exceeded TYPE Limits.");
|
|
}
|
|
strcpy(TypeDefs[TypeDefsCnt].VarName,TypeName);
|
|
TypeDefs[TypeDefsCnt].TypeofDef=TDef;
|
|
TypeDefs[TypeDefsCnt].EleCnt=0;
|
|
}
|
|
|
|
|
|
int DefsID (char *ZZ)
|
|
{
|
|
int i;
|
|
if(TypeDefsCnt>0)
|
|
{
|
|
for(i=1; i<=TypeDefsCnt; i+=1)
|
|
{
|
|
if(str_cmp(ZZ,TypeDefs[i].VarName)==0)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
void GetTypeInfo (char *stk, int* IsPointer, int* UdtIdx, int* vtCode)
|
|
{
|
|
char Var1[2048];
|
|
(*IsPointer)=tally(stk,"*");
|
|
strcpy(Var1,RemoveStr(stk,"*"));
|
|
if(str_cmp(right(Var1,6),"_CLASS")==0)
|
|
{
|
|
strcpy(Var1,left(Var1,strlen(Var1)-6));
|
|
}
|
|
(*vtCode)=CheckType(Var1);
|
|
if((*vtCode)==vt_UNKNOWN)
|
|
{
|
|
AddTypeDefs(Var1,vt_UDT);
|
|
(*vtCode)=vt_UDT;
|
|
}
|
|
(*UdtIdx)=0;
|
|
if((*vtCode)==vt_STRUCT||(*vtCode)==vt_UNION||(*vtCode)==vt_UDT)
|
|
{
|
|
(*UdtIdx)=DefsID(Var1);
|
|
}
|
|
}
|
|
|
|
|
|
void AddTypedefElement (int WorkingTypeDefsCnt, int ElType, char *EName, char *EType, int EPtr)
|
|
{
|
|
UserTypeDefs* TD;
|
|
TD= &(TypeDefs[WorkingTypeDefsCnt]);
|
|
if(TD->EleCnt==MaxElements)
|
|
{
|
|
Abort("Exceeded TYPE Element Limits.");
|
|
}
|
|
TD->Elements[TD->EleCnt].ElementType=ElType;
|
|
TD->Elements[TD->EleCnt].ElementDynaPtr=EPtr;
|
|
if(ElType==vt_STRUCT||ElType==vt_UNION||ElType==vt_UDT)
|
|
{
|
|
TD->Elements[TD->EleCnt].ElementID=DefsID(EType);
|
|
}
|
|
else
|
|
{
|
|
TD->Elements[TD->EleCnt].ElementID=0;
|
|
}
|
|
strcpy(TD->Elements[TD->EleCnt].ElementName,EName);
|
|
TD->EleCnt=1+TD->EleCnt;
|
|
}
|
|
|
|
|
|
char * GetElement (int StartStk, int* vt, int* dms, int id)
|
|
{
|
|
char *BCX_RetStr={0};
|
|
int BC=0;
|
|
int i;
|
|
char ZZ[2048];
|
|
for(i=StartStk+1; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"[")==0)
|
|
{
|
|
BC++;
|
|
}
|
|
else if(str_cmp(Stk[i],"]")==0)
|
|
{
|
|
BC--;
|
|
}
|
|
else if(BC==0)
|
|
{
|
|
if(iMatchLft(Stk[i],"->")||*Stk[i]==46)
|
|
{
|
|
strcpy(ZZ,Clean(Stk[i]));
|
|
RemoveAll(ZZ,".->(*)",1);
|
|
(*vt)=GetElementInfo( &id,dms,ZZ);
|
|
if((*vt)!=vt_STRUCT&&(*vt)!=vt_UNION)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if((*vt)==vt_UDT||(*vt)==vt_UNION||(*vt)==vt_STRUCT)
|
|
{
|
|
strcpy(ZZ,TypeDefs[id].VarName);
|
|
}
|
|
else
|
|
{
|
|
strcpy(ZZ,GetVarTypeName(*vt));
|
|
}
|
|
BCX_RetStr=BCX_TmpStr(strlen(ZZ));
|
|
strcpy(BCX_RetStr,ZZ);
|
|
return BCX_RetStr;
|
|
}
|
|
|
|
|
|
int GetElementInfo (int* DefID, int* EPtr, char *Elename)
|
|
{
|
|
int i;
|
|
int id;
|
|
id=(*DefID);
|
|
for(i=0; i<=TypeDefs[id].EleCnt-1; i+=1)
|
|
{
|
|
if(str_cmp(Elename,TypeDefs[id].Elements[i].ElementName)==0)
|
|
{
|
|
(*DefID)=TypeDefs[id].Elements[i].ElementID;
|
|
(*EPtr)=TypeDefs[id].Elements[i].ElementDynaPtr;
|
|
return TypeDefs[id].Elements[i].ElementType;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
void HandleNonsense (void)
|
|
{
|
|
int i;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"as"))
|
|
{
|
|
strcpy(Stk[i-1],Clean(Stk[i-1]));
|
|
}
|
|
if(OptionBase)
|
|
{
|
|
if(str_cmp(Stk[i],"[")==0)
|
|
{
|
|
strcpy(Stk[i+1], join(3,ltrim(str(OptionBase)),"+",Stk[i+1]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void ValidVar (char *v)
|
|
{
|
|
char *ZZ;
|
|
ZZ=(char*)calloc(256+65535,1);
|
|
if(!isalpha(*v)&&*v!=95)
|
|
{
|
|
if(!iMatchLft(v,"(*"))
|
|
{
|
|
Abort("Invalid String Variable Name");
|
|
}
|
|
}
|
|
if(RestrictedWords(v)&&TestState)
|
|
{
|
|
strcpy(ZZ, join(3,"Variable ",v," on line"));
|
|
strcpy(ZZ, join(5,ZZ,str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx])," is a Restricted Word"));
|
|
Warning(ZZ);
|
|
}
|
|
if(ZZ)free(ZZ);
|
|
}
|
|
|
|
|
|
void PointerFix (void)
|
|
{
|
|
strcpy(Stk[Ndx-1], join(2,Stk[Ndx-1],Stk[Ndx]));
|
|
Stk[Ndx][0]=0;
|
|
Ndx--;
|
|
while(tally(Stk[Ndx],"*")==strlen(Stk[Ndx]))
|
|
{
|
|
strcpy(Stk[Ndx-1], join(2,Stk[Ndx-1],Stk[Ndx]));
|
|
Stk[Ndx][0]=0;
|
|
Ndx--;
|
|
}
|
|
}
|
|
|
|
|
|
void DimDynaString (char *SVar, int DG, int s)
|
|
{
|
|
int A;
|
|
char DS[2048];
|
|
strcpy(DS, join(5,"if(",SVar,")free(",SVar,");"));
|
|
if(InFunc&&(IsLocal||IsDim||IsRaw||IsAuto||IsRegister)&&DG==0)
|
|
{
|
|
LocalDynaCnt++;
|
|
strcpy(DynaStr[LocalDynaCnt],DS);
|
|
if(IsAuto)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"char *",SVar,";");
|
|
}
|
|
else if(IsRegister)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"register char *",SVar,";");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"char *",SVar,";");
|
|
}
|
|
AddLocal(SVar,vt_CHAR,0,"",1,0,0);
|
|
}
|
|
else
|
|
{
|
|
if(Use_GenFree)
|
|
{
|
|
GlobalDynaCnt++;
|
|
strcpy(GlobalDynaStr[GlobalDynaCnt],DS);
|
|
}
|
|
if(DG==2)
|
|
{
|
|
AddGlobal(SVar,vt_CHAR,0,"",1,0,1,0);
|
|
}
|
|
else
|
|
{
|
|
if(s)
|
|
{
|
|
AddGlobal(SVar,vt_CHAR,0,"",1,0,2,0);
|
|
}
|
|
else
|
|
{
|
|
AddGlobal(SVar,vt_CHAR,0,"",1,0,0,0);
|
|
}
|
|
}
|
|
}
|
|
if(DG!=2)
|
|
{
|
|
fprintf(Outfile,"%s%s%s",Scoot,SVar,"=(char*)calloc(256+");
|
|
for(A=4; A<=Ndx; A+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[A]));
|
|
}
|
|
fprintf(Outfile,"%s\n",",1);");
|
|
}
|
|
}
|
|
|
|
|
|
int SubFuncTest (void)
|
|
{
|
|
if(iMatchWrd(Stk[2],"function")||iMatchWrd(Stk[2],"sub"))
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int DimSubFunc (int IsDynamic)
|
|
{
|
|
int i;
|
|
char lszTmp[2048];
|
|
int StartPoint=3;
|
|
int Funptr=0;
|
|
*lszTmp=0;
|
|
if(iMatchWrd(Stk[Ndx],"stdcall"))
|
|
{
|
|
strcpy(CallType,"__attribute__((stdcall)) ");
|
|
Ndx--;
|
|
IsStdFunc=TRUE;
|
|
}
|
|
else
|
|
{
|
|
strcpy(CallType,"__attribute__((cdecl)) ");
|
|
IsStdFunc=FALSE;
|
|
}
|
|
static struct _functionParse FP;
|
|
memset(&FP,0,sizeof(FP));
|
|
SepFuncArgs(3, &FP,TRUE);
|
|
StartPoint=_MAX_(FP.CommaPos[0],3);
|
|
if(!InTypeDef)
|
|
{
|
|
SFPOINTER=TRUE;
|
|
if(FP.NumArgs==0)
|
|
{
|
|
i=_MIN_(FP.CommaPos[1]+1,Ndx);
|
|
}
|
|
else
|
|
{
|
|
i=_MIN_(FP.CommaPos[FP.NumArgs]+1,Ndx);
|
|
}
|
|
if(str_cmp(Stk[i],"=")==0)
|
|
{
|
|
*Stk[i++]=0;
|
|
while(!iMatchWrd(Stk[i],"as")&&i<=Ndx)
|
|
{
|
|
strcat(lszTmp,Stk[i]);
|
|
*Stk[i++]=0;
|
|
}
|
|
RemoveAll(lszTmp,"{}",1);
|
|
if(lszTmp[0]!=0)
|
|
{
|
|
RemEmptyTokens();
|
|
}
|
|
}
|
|
if(!InNameSpace)
|
|
{
|
|
fprintf(FP4,"%s%s\n",MakeDecProto( &FP),";");
|
|
}
|
|
SFPOINTER=FALSE;
|
|
Ndx=StartPoint;
|
|
*Stk[2]=0;
|
|
if(lszTmp[0]!=0)
|
|
{
|
|
strcpy(Stk[Ndx++],"=");
|
|
strcpy(Stk[Ndx++],"{");
|
|
strcpy(Stk[Ndx++],Clean(lszTmp));
|
|
strcpy(Stk[Ndx++],"}");
|
|
}
|
|
strcpy(Stk[Ndx++],"as");
|
|
strcpy(Stk[Ndx], join(3,Clean(Stk[3]),"_TYPE",stringx(Funptr,42)));
|
|
RemEmptyTokens();
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if(iMatchWrd(Stk[2],"constructor")||iMatchWrd(Stk[2],"destructor"))
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",LF,Scoot,MakeDecProto( &FP),";");
|
|
}
|
|
else if(Use_Virtual)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Scoot,"virtual ",MakeDecProto( &FP),vproc,";");
|
|
Use_Virtual=FALSE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,MakeDecProto( &FP),";");
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void Emit (void)
|
|
{
|
|
int HasStorage=0;
|
|
int A;
|
|
int B;
|
|
int i;
|
|
int j;
|
|
int Tmp;
|
|
int FuncRetnFlag;
|
|
int IsPointer=0;
|
|
int VType;
|
|
int id=0;
|
|
int k=0;
|
|
int vt=0;
|
|
char Arg[2048];
|
|
char CVar[2048];
|
|
char Keyword[2048];
|
|
char lszTmp[2048];
|
|
char Var1[2048];
|
|
char *ZZ;
|
|
ZZ=(char*)calloc(256+65535,1);
|
|
int IsSubOrFuncPtr;
|
|
int dms;
|
|
static int NoBreak;
|
|
static int NoBreak2;
|
|
FuncRetnFlag=0;
|
|
*lszTmp=0;
|
|
*ZZ=0;
|
|
strcpy(Keyword,lcase(Stk[1]));
|
|
if(NoBreak2&&!iMatchLft(Keyword,"case")&&!iMatchWrd(Keyword,"endselect"))
|
|
{
|
|
NoBreak2=0;
|
|
}
|
|
|
|
EMITAGAIN:;
|
|
if(Ndx==0)
|
|
{
|
|
if(ZZ)free(ZZ);
|
|
return;
|
|
}
|
|
Statements++;
|
|
if(iMatchRgt(Stk[1],":"))
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s%s\n",ucase(Stk[1]),";");
|
|
if(ZZ)free(ZZ);
|
|
return;
|
|
}
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(Stk[i],replace(Stk[i],chr(-15),":"));
|
|
}
|
|
if((CurrentFuncType==vt_STRVAR)&&InFunc&&OkayToSend)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"char *BCX_RetStr={0};");
|
|
OkayToSend=0;
|
|
}
|
|
strcpy(Lookup,lcase(Stk[1]));
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Lookup,"fprint")==0 || str_cmp(Lookup,"sprint")==0)
|
|
{
|
|
int IsLprint=FALSE;
|
|
int IsSprint=FALSE;
|
|
if(iMatchWrd(Stk[1],"sprint"))
|
|
{
|
|
IsSprint=TRUE;
|
|
}
|
|
if(IsNumber(Stk[2]))
|
|
{
|
|
strcpy(Stk[2], join(2,"FP",Stk[2]));
|
|
}
|
|
if(IsSprint)
|
|
{
|
|
strcpy(Handl,Clean(Stk[2]));
|
|
}
|
|
else
|
|
{
|
|
if(str_cmp(lcase(Stk[2]),"stderr")==0)
|
|
{
|
|
strcpy(Handl,lcase(Stk[2]));
|
|
}
|
|
else
|
|
{
|
|
if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
|
|
{
|
|
if(CheckGlobal(Stk[2], &i)==vt_UNKNOWN)
|
|
{
|
|
AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
|
|
}
|
|
}
|
|
*Handl=0;
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(*Stk[i]==44||*Stk[i]==59)
|
|
{
|
|
*Stk[i]=0;
|
|
break;
|
|
}
|
|
strcat(Handl,Stk[i]);
|
|
*Stk[i]=0;
|
|
}
|
|
strcat(Handl,"@");
|
|
}
|
|
}
|
|
*Stk[2]=0;
|
|
*Stk[3]=0;
|
|
if(IsSprint)
|
|
{
|
|
strcpy(ZZ, join(2,"s",PrintWriteFormat(0)));
|
|
strcpy(ZZ,RemoveStr(ZZ,"\\n"));
|
|
}
|
|
else
|
|
{
|
|
strcpy(ZZ, join(2,"f",PrintWriteFormat(0)));
|
|
}
|
|
strcpy(ZZ, join(4,left(ZZ,8),RemoveStr(Handl,"@"),",",mid(ZZ,9)));
|
|
fprintf(Outfile,"%s%s\n",Scoot,ZZ);
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"end")==0)
|
|
{
|
|
if(Ndx==1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"fflush(stdout);");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"exit(0);");
|
|
break;
|
|
}
|
|
if(str_cmp(Stk[2],"=")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"fflush(stdout);");
|
|
fprintf(Outfile,"%s%s",Scoot,"exit(");
|
|
for(Tmp=3; Tmp<=Ndx; Tmp+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[Tmp]));
|
|
}
|
|
fprintf(Outfile,"%s\n",");");
|
|
break;
|
|
}
|
|
if(iMatchWrd(Stk[2],"if"))
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
BumpDown();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"endif")==0)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
BumpDown();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"if")==0)
|
|
{
|
|
EmitIfCond("if");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"elseif")==0)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
BumpDown();
|
|
EmitIfCond("else if");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"for")==0)
|
|
{
|
|
int FFlg=0;
|
|
int For1=0;
|
|
int For2=0;
|
|
int For3=0;
|
|
int For4=0;
|
|
char Reg[2048];
|
|
char xxx[2048];
|
|
char yyy[2048];
|
|
char zzz[2048];
|
|
char qqq[2048];
|
|
*Reg=0;
|
|
*xxx=0;
|
|
*yyy=0;
|
|
*zzz=0;
|
|
*qqq=0;
|
|
for(i=Ndx; i>=1; i+=-1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"step"))
|
|
{
|
|
FFlg=TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if(!FFlg)
|
|
{
|
|
Ndx++;
|
|
strcpy(Stk[Ndx],"step");
|
|
Ndx++;
|
|
strcpy(Stk[Ndx],"1");
|
|
}
|
|
Test=FALSE;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"=")==0)
|
|
{
|
|
Test=TRUE;
|
|
}
|
|
}
|
|
if(Test==FALSE)
|
|
{
|
|
Abort("Missing =");
|
|
}
|
|
Test=FALSE;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"to"))
|
|
{
|
|
Test=TRUE;
|
|
}
|
|
}
|
|
if(Test==FALSE)
|
|
{
|
|
Abort("Missing TO");
|
|
}
|
|
strcpy(Reg,lcase(Stk[2]));
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Reg,"int")==0 || str_cmp(Reg,"fint")==0)
|
|
{
|
|
strcpy(Reg,SPC);
|
|
LoopLocalVar[LoopLocalCnt++]=1;
|
|
fprintf(Outfile,"%s%s",Scoot," {int ");
|
|
break;
|
|
}
|
|
if(str_cmp(Reg,"single")==0 || str_cmp(Reg,"float")==0)
|
|
{
|
|
strcpy(Reg,SPC);
|
|
LoopLocalVar[LoopLocalCnt++]=1;
|
|
fprintf(Outfile,"%s%s",Scoot," {float ");
|
|
break;
|
|
}
|
|
if(str_cmp(Reg,"double")==0)
|
|
{
|
|
strcpy(Reg,SPC);
|
|
LoopLocalVar[LoopLocalCnt++]=1;
|
|
fprintf(Outfile,"%s%s",Scoot," {double ");
|
|
break;
|
|
}
|
|
if(str_cmp(Reg,"ldouble")==0)
|
|
{
|
|
strcpy(Reg,SPC);
|
|
LoopLocalVar[LoopLocalCnt++]=1;
|
|
fprintf(Outfile,"%s%s",Scoot," {LDOUBLE ");
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
*Reg=0;
|
|
LoopLocalVar[LoopLocalCnt++]=0;
|
|
}
|
|
break;
|
|
}
|
|
if(strlen(Reg))
|
|
{
|
|
for(j=3; j<=Ndx; j+=1)
|
|
{
|
|
strcpy(Stk[j-1],Stk[j]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"=")==0)
|
|
{
|
|
For1=i-1;
|
|
break;
|
|
}
|
|
}
|
|
for(i=For1+2; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"to"))
|
|
{
|
|
For2=i-1;
|
|
break;
|
|
}
|
|
}
|
|
for(i=For2+2; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"step"))
|
|
{
|
|
For3=i-1;
|
|
break;
|
|
}
|
|
}
|
|
For4=For3+2;
|
|
for(i=2; i<=For1; i+=1)
|
|
{
|
|
strcat(xxx,Stk[i]);
|
|
}
|
|
for(i=For1+2; i<=For2; i+=1)
|
|
{
|
|
strcat(yyy,Stk[i]);
|
|
}
|
|
for(i=For2+2; i<=For3; i+=1)
|
|
{
|
|
strcat(zzz,Stk[i]);
|
|
}
|
|
for(i=For4; i<=Ndx; i+=1)
|
|
{
|
|
strcat(qqq,Stk[i]);
|
|
}
|
|
strcpy(xxx,Clean(xxx));
|
|
strcpy(yyy,Clean(yyy));
|
|
strcpy(zzz,Clean(zzz));
|
|
strcpy(qqq,Clean(qqq));
|
|
if(str_cmp(Reg,SPC)==0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",xxx,";");
|
|
}
|
|
*Reg=0;
|
|
if(IsNumberEx(qqq))
|
|
{
|
|
if(str_cmp(left(qqq,1),"-")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",Scoot,"for(",Reg,xxx,"=",yyy,"; ",xxx,">=",zzz,"; ",xxx,"+=",qqq,")");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",Scoot,"for(",Reg,xxx,"=",yyy,"; ",xxx,"<=",zzz,"; ",xxx,"+=",qqq,")");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",Scoot,"for(",Reg,xxx,"=",yyy,"; ",qqq,">=0 ? ",xxx,"<=",zzz," : ",xxx,">=",zzz,"; ",xxx,"+=",qqq,")");
|
|
}
|
|
BumpUp();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
BumpUp();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"next")==0)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
if(LoopLocalVar[--LoopLocalCnt])
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
}
|
|
if(LoopLocalCnt<0)
|
|
{
|
|
Abort("Next without For");
|
|
}
|
|
BumpDown();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"do")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"for(;;)");
|
|
BumpUp();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
BumpUp();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"loop")==0)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
BumpDown();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"caseelse")==0)
|
|
{
|
|
CaseElseFlag[Pusher]=TRUE;
|
|
if(CaseFlag)
|
|
{
|
|
if(NoBreak2==0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"break;");
|
|
}
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"// case else");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
BumpUp();
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"endselect")==0)
|
|
{
|
|
if(CaseFlag)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
}
|
|
BumpDown();
|
|
if(CaseElseFlag[Pusher]==0||NoBreak2==0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"break;");
|
|
}
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
NoBreak2=CaseElseFlag[Pusher]=0;
|
|
Pop(CaseVar);
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"else")==0)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"else");
|
|
BumpUp();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
BumpUp();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"case")==0)
|
|
{
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"%")==0)
|
|
{
|
|
strcpy(Stk[i]," % ");
|
|
}
|
|
if(str_cmp(Stk[i],"!=")==0)
|
|
{
|
|
strcpy(Stk[i],"<>");
|
|
}
|
|
if(str_cmp(Stk[i],"!")==0 && str_cmp(Stk[i+1],"=")==0)
|
|
{
|
|
strcpy(Stk[i],"<>");
|
|
*Stk[i+1]=0;
|
|
}
|
|
if(isalpha(Stk[i][0]))
|
|
{
|
|
strcat(Stk[i]," ");
|
|
}
|
|
}
|
|
*szTmp=0;
|
|
Test=FALSE;
|
|
if(DataType(CaseVar)==vt_STRVAR)
|
|
{
|
|
Test=TRUE;
|
|
}
|
|
i=0;
|
|
for(A=2; A<=Ndx; A+=1)
|
|
{
|
|
if(inchr("([",Stk[A]))
|
|
{
|
|
i++;
|
|
}
|
|
if(inchr(")]",Stk[A]))
|
|
{
|
|
i--;
|
|
}
|
|
if(i)
|
|
{
|
|
strcat(szTmp,Stk[A]);
|
|
continue;
|
|
}
|
|
if(str_cmp(Stk[A],",")==0)
|
|
{
|
|
if(!inchr("<>=",Stk[A+1]))
|
|
{
|
|
strcpy(szTmp, join(4,szTmp," or ",CaseVar,"="));
|
|
}
|
|
else
|
|
{
|
|
strcpy(szTmp, join(3,szTmp," or ",CaseVar));
|
|
}
|
|
*Stk[A]=0;
|
|
continue;
|
|
}
|
|
if(str_cmp(Stk[A],"&&")==0)
|
|
{
|
|
strcpy(szTmp, join(3,szTmp," and ",CaseVar));
|
|
*Stk[A]=0;
|
|
}
|
|
else if(str_cmp(Stk[A],"||")==0)
|
|
{
|
|
strcpy(szTmp, join(3,szTmp," or ",CaseVar));
|
|
*Stk[A]=0;
|
|
}
|
|
else
|
|
{
|
|
strcat(szTmp,Stk[A]);
|
|
}
|
|
}
|
|
if(CaseFlag==0)
|
|
{
|
|
NoBreak=0;
|
|
}
|
|
if(CaseFlag)
|
|
{
|
|
if(NoBreak==0)
|
|
{
|
|
if(NoBreak2==0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"break;");
|
|
}
|
|
}
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
BumpDown();
|
|
}
|
|
CaseFlag=TRUE;
|
|
if(iMatchLft(CaseVar," BAND "))
|
|
{
|
|
NoBreak=1;
|
|
strcpy(Src, join(4,"IF ",szTmp,CaseVar," Then "));
|
|
}
|
|
else
|
|
{
|
|
if(inchr("<>=",szTmp)&&!IsQuoted(szTmp))
|
|
{
|
|
strcpy(Src, join(4,"IF ",CaseVar,szTmp," Then "));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Src, join(5,"IF ",CaseVar," = ",szTmp," Then "));
|
|
}
|
|
}
|
|
Parse(Src);
|
|
Emit();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"delay")==0)
|
|
{
|
|
*lszTmp=0;
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
strcat(lszTmp,Clean(Stk[i]));
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"sleep(",lszTmp,");");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"qsortidx")==0)
|
|
{
|
|
*lszTmp=0;
|
|
strcpy(Var,Clean(Stk[2]));
|
|
for(i=4; i<=Ndx-4; i+=1)
|
|
{
|
|
strcat(lszTmp,Stk[i]);
|
|
}
|
|
strcpy(lszTmp,Clean(lszTmp));
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"Key = ",Stk[Ndx],";");
|
|
if(str_cmp(Var,"0")!=0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"int iDx;");
|
|
fprintf(Outfile,"%s%s%s%s",Scoot,"for(iDx=0; iDx<",lszTmp,"; iDx+=1) ");
|
|
fprintf(Outfile,"%s%s\n",Var,"[iDx]=iDx;");
|
|
}
|
|
if(!inchr(Stk[Ndx-2],"."))
|
|
{
|
|
Use_Idxqsort=TRUE;
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"pppStr = ",Clean(Stk[Ndx-2]),";");
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"qsort(",Var,",",lszTmp,",sizeof(int),IdxCompare);");
|
|
}
|
|
else
|
|
{
|
|
char Stptr[2048];
|
|
char StMem[2048];
|
|
char StName[2048];
|
|
strcpy(StMem,remain(Clean(Stk[Ndx-2]),"."));
|
|
strcpy(Stptr,extract(Stk[Ndx-2],"."));
|
|
if(CheckLocal(Stptr, &i)!=vt_UNKNOWN)
|
|
{
|
|
strcpy(StName,TypeDefs[LocalVars[i].VarDef].VarName);
|
|
}
|
|
else if(CheckGlobal(Stptr, &i)!=vt_UNKNOWN)
|
|
{
|
|
strcpy(StName,TypeDefs[GlobalVars[i].VarDef].VarName);
|
|
}
|
|
if(str_cmp(Var,"0")!=0)
|
|
{
|
|
Use_IdxqsortSt=TRUE;
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"cmp1 =(char*)(",Stptr,") + offsetof(",StName,",",StMem,");");
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"StructSize = sizeof(",StName,");");
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"qsort(",Var,",",lszTmp,",sizeof(int),IdxCompareSt);");
|
|
}
|
|
else
|
|
{
|
|
Use_PtrqsortSt=TRUE;
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"OffSet = offsetof(",StName,",",StMem,");");
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"qsort(",Stptr,",",lszTmp,",sizeof(",StName,"),PtrCompareSt);");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"qsort")==0)
|
|
{
|
|
int QST=0;
|
|
int order=0;
|
|
if(iMatchWrd(Stk[2],"dynamic"))
|
|
{
|
|
QST=TRUE;
|
|
for(j=3; j<=Ndx; j+=1)
|
|
{
|
|
strcpy(Stk[j-1],Stk[j]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
if(str_cmp(lcase(Stk[Ndx]),"ascending")==0)
|
|
{
|
|
order=2;
|
|
Ndx--;
|
|
Ndx--;
|
|
}
|
|
if(str_cmp(lcase(Stk[Ndx]),"descending")==0)
|
|
{
|
|
order=1;
|
|
Ndx--;
|
|
Ndx--;
|
|
}
|
|
if(order==0)
|
|
{
|
|
order=2;
|
|
}
|
|
*lszTmp=0;
|
|
for(i=4; i<=Ndx; i+=1)
|
|
{
|
|
strcat(lszTmp,Stk[i]);
|
|
}
|
|
strcpy(Var,Clean(Stk[2]));
|
|
vt=DataType(Stk[2]);
|
|
if(vt!=vt_STRVAR&&vt!=vt_INTEGER&&vt!=vt_SINGLE&&vt!=vt_DOUBLE)
|
|
{
|
|
vt=CheckType(Stk[2]);
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s%s",Scoot,"qsort(",Var,",",Clean(lszTmp));
|
|
for(;;)
|
|
{
|
|
if(vt==vt_STRVAR)
|
|
{
|
|
if(!QST)
|
|
{
|
|
if(order==1)
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n",",sizeof(",Var,"[0]),StrCompareD);");
|
|
Use_Strqsortd=TRUE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n",",sizeof(",Var,"[0]),StrCompareA);");
|
|
Use_Strqsorta=TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(order==1)
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n",",sizeof(",Var,"[0]),DynStrCompareD);");
|
|
Use_DynStrqsortd=TRUE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n",",sizeof(",Var,"[0]),DynStrCompareA);");
|
|
Use_DynStrqsorta=TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(vt==vt_INTEGER)
|
|
{
|
|
if(order==1)
|
|
{
|
|
fprintf(Outfile,"%s\n",",sizeof(int),NumCompareDint);");
|
|
Use_Numqsortdint=TRUE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n",",sizeof(int),NumCompareAint);");
|
|
Use_Numqsortaint=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
if(vt==vt_SINGLE)
|
|
{
|
|
if(order==1)
|
|
{
|
|
fprintf(Outfile,"%s\n",",sizeof(float),NumCompareDfloat);");
|
|
Use_Numqsortdfloat=TRUE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n",",sizeof(float),NumCompareAfloat);");
|
|
Use_Numqsortafloat=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
if(vt==vt_DOUBLE)
|
|
{
|
|
if(order==1)
|
|
{
|
|
fprintf(Outfile,"%s\n",",sizeof(double),NumCompareDdouble);");
|
|
Use_Numqsortddouble=TRUE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n",",sizeof(double),NumCompareAdouble);");
|
|
Use_Numqsortadouble=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
if(order==1)
|
|
{
|
|
fprintf(Outfile,"%s\n",",sizeof(int),NumCompareDint);");
|
|
Use_Numqsortdint=TRUE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n",",sizeof(int),NumCompareAint);");
|
|
Use_Numqsortaint=TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"endprogram")==0)
|
|
{
|
|
fprintf(Outfile,"%s\n"," return 0; // End of main program");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
EndOfProgram=1;
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"~ifndef")==0)
|
|
{
|
|
strcpy(InIfDef,"#ifndef ");
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(InIfDef, join(3,InIfDef,Stk[i]," "));
|
|
}
|
|
strcpy(InIfDef,trim(InIfDef));
|
|
if(InFunc||InMain)
|
|
{
|
|
fprintf(Outfile,"%s\n",InIfDef);
|
|
}
|
|
else
|
|
{
|
|
fprintf(FP6,"%s\n",InIfDef);
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"~if")==0)
|
|
{
|
|
strcpy(InIfDef,"#if defined ");
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(InIfDef, join(3,InIfDef,Stk[i]," "));
|
|
}
|
|
strcpy(InIfDef,trim(InIfDef));
|
|
strcpy(ConstLastDef,InIfDef);
|
|
if(InFunc)
|
|
{
|
|
if(Outfile==FP3)
|
|
{
|
|
fprintf(Outfile,"%s\n","// FP3");
|
|
}
|
|
if(Outfile==FP2)
|
|
{
|
|
fprintf(Outfile,"%s\n","// FP2");
|
|
}
|
|
fprintf(Outfile,"%s%s\n",InIfDef,"// OUTFILE");
|
|
strcpy(InIfDef,"FP3");
|
|
}
|
|
else if(InMain)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",InIfDef,"// --FP2--");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"~else")==0)
|
|
{
|
|
strcpy(InIfDef,"#else");
|
|
strcpy(ConstLastDef,InIfDef);
|
|
if(InFunc||InMain)
|
|
{
|
|
fprintf(Outfile,"%s\n",InIfDef);
|
|
}
|
|
else
|
|
{
|
|
fprintf(FP6,"%s\n",InIfDef);
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"~elseif")==0)
|
|
{
|
|
strcpy(InIfDef,"#elif defined ");
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(InIfDef, join(3,InIfDef,Stk[i]," "));
|
|
}
|
|
strcpy(InIfDef,trim(InIfDef));
|
|
strcpy(ConstLastDef,InIfDef);
|
|
if(InFunc||InMain)
|
|
{
|
|
fprintf(Outfile,"%s\n",InIfDef);
|
|
}
|
|
else
|
|
{
|
|
fprintf(FP6,"%s\n",InIfDef);
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"~endif")==0)
|
|
{
|
|
if(str_cmp(InIfDef,"FP3")==0)
|
|
{
|
|
fprintf(FP3,"%s\n","#endif // FP3");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n","#endif // Main");
|
|
}
|
|
if(str_cmp(ConstLastDef,"FP6")==0)
|
|
{
|
|
fprintf(FP6,"%s\n","#endif // FP6");
|
|
}
|
|
strcpy(InIfDef,"#endif // other");
|
|
if(InConditional==0)
|
|
{
|
|
*InIfDef=0;
|
|
*ConstLastDef=0;
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"incr")==0)
|
|
{
|
|
j=FALSE;
|
|
fprintf(Outfile,"%s",Scoot);
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],",")==0)
|
|
{
|
|
fprintf(Outfile,"%s","+=(");
|
|
j=TRUE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[i]));
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n",sziif(j,");","++;"));
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"decr")==0)
|
|
{
|
|
j=FALSE;
|
|
fprintf(Outfile,"%s",Scoot);
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],",")==0)
|
|
{
|
|
fprintf(Outfile,"%s","-=(");
|
|
j=TRUE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[i]));
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n",sziif(j,");","--;"));
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"seek")==0)
|
|
{
|
|
if(DataType(Stk[2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[2], join(2,"FP",Stk[2]));
|
|
}
|
|
if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
|
|
{
|
|
AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
|
|
}
|
|
fprintf(Outfile,"%s%s",Scoot,"fseek(");
|
|
for(Tmp=2; Tmp<=Ndx; Tmp+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[Tmp]));
|
|
}
|
|
fprintf(Outfile,"%s\n",",0);");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"select")==0)
|
|
{
|
|
*CaseVar=0;
|
|
CaseFlag=0;
|
|
for(A=3; A<=Ndx; A+=1)
|
|
{
|
|
strcat(CaseVar,Stk[A]);
|
|
}
|
|
Push(CaseVar);
|
|
fprintf(Outfile,"%s%s\n",Scoot,"for(;;)");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
BumpUp();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"~get")==0)
|
|
{
|
|
Use_Get=TRUE;
|
|
if(DataType(Stk[2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[2], join(2,"FP",Stk[2]));
|
|
}
|
|
if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
|
|
{
|
|
if(CheckGlobal(Stk[2], &i)==vt_UNKNOWN)
|
|
{
|
|
AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s",Scoot,"GET(");
|
|
for(Tmp=2; Tmp<=Ndx; Tmp+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[Tmp]));
|
|
}
|
|
fprintf(Outfile,"%s\n",");");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"~put")==0)
|
|
{
|
|
Use_Put=TRUE;
|
|
if(DataType(Stk[2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[2], join(2,"FP",Stk[2]));
|
|
}
|
|
if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
|
|
{
|
|
if(CheckGlobal(Stk[2], &i)==vt_UNKNOWN)
|
|
{
|
|
AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s",Scoot,"PUT(");
|
|
for(Tmp=2; Tmp<=Ndx; Tmp+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[Tmp]));
|
|
}
|
|
fprintf(Outfile,"%s\n",");");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"gosub")==0)
|
|
{
|
|
Use_Gosub=TRUE;
|
|
fprintf(Outfile,"%s%s",Scoot,"if (setjmp(GosubStack[GosubNdx++])==0)");
|
|
fprintf(Outfile,"%s%s%s\n"," goto ",ucase(Stk[2]),";");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"return")==0)
|
|
{
|
|
Use_Gosub=TRUE;
|
|
fprintf(Outfile,"%s%s\n",Scoot,"longjmp (GosubStack [--GosubNdx],1 );");
|
|
fprintf(Outfile,"%s\n","");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"data")==0)
|
|
{
|
|
if(str_cmp(Stk[Ndx],",")!=0)
|
|
{
|
|
strcpy(Stk[Ndx+1],",");
|
|
Ndx++;
|
|
}
|
|
for(A=2; A<=Ndx; A+=1)
|
|
{
|
|
if(inchr(Stk[A],DQ)==0&&str_cmp(Stk[A],",")!=0)
|
|
{
|
|
strcpy(Stk[A],enc(Stk[A]));
|
|
}
|
|
fprintf(FP5,"%s",Stk[A]);
|
|
}
|
|
fprintf(FP5,"%s\n","");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"namespace")==0)
|
|
{
|
|
UseCpp=TRUE;
|
|
strcpy(szTmp,mid(Src,inchr(Src," ")+1));
|
|
fprintf(Outfile,"%s%s\n","namespace ",ltrim(szTmp));
|
|
fprintf(Outfile,"%s\n","{");
|
|
InNameSpace++;
|
|
BumpUp();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"endnamespace")==0)
|
|
{
|
|
InNameSpace--;
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"class")==0)
|
|
{
|
|
if(InTypeDef==0)
|
|
{
|
|
SaveOutfileNum=Outfile;
|
|
}
|
|
Outfile=FP4;
|
|
InTypeDef++;
|
|
strcpy(TypeName[InTypeDef],Stk[2]);
|
|
if(str_cmp(Stk[3],"inherits")==0)
|
|
{
|
|
strcpy(Stk[3], join(2,": public ",Stk[4]));
|
|
}
|
|
AddTypeDefs(TypeName[InTypeDef],vt_STRUCT);
|
|
BaseTypeDefsCnt[InTypeDef]=TypeDefsCnt;
|
|
if(InTypeDef==1)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s%s%s%s\n","class ",TypeName[InTypeDef],Stk[3]," {");
|
|
BumpUp();
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"endclass")==0)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n","};",LF);
|
|
InTypeDef--;
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"type")==0)
|
|
{
|
|
if(InTypeDef==0)
|
|
{
|
|
SaveOutfileNum=Outfile;
|
|
}
|
|
Outfile=FP4;
|
|
if(Ndx>2)
|
|
{
|
|
if(InTypeDef)
|
|
{
|
|
Abort("Single line TYPE within type/union not supported");
|
|
}
|
|
for(i=Ndx; i>=1; i+=-1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"as"))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if(!iMatchWrd(Stk[i],"as"))
|
|
{
|
|
Abort("Missing AS TYPE");
|
|
}
|
|
fprintf(Outfile,"%s","typedef ");
|
|
j=i-1;
|
|
i++;
|
|
while(i<=Ndx)
|
|
{
|
|
fprintf(Outfile,"%s%s",Stk[i]," ");
|
|
i++;
|
|
}
|
|
for(i=2; i<=j; i+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Stk[i]);
|
|
}
|
|
fprintf(Outfile,"%s\n",";");
|
|
Outfile=SaveOutfileNum;
|
|
}
|
|
else
|
|
{
|
|
InTypeDef++;
|
|
strcpy(TypeName[InTypeDef],Stk[2]);
|
|
AddTypeDefs(TypeName[InTypeDef],vt_STRUCT);
|
|
BaseTypeDefsCnt[InTypeDef]=TypeDefsCnt;
|
|
if(InTypeDef==1)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s%s\n","typedef struct _",TypeName[InTypeDef]);
|
|
fprintf(Outfile,"%s\n","{");
|
|
BumpUp();
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"struct");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
AddTypedefElement(BaseTypeDefsCnt[InTypeDef-1],vt_STRUCT,TypeName[InTypeDef],TypeName[InTypeDef],0);
|
|
BumpUp();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"endtype")==0)
|
|
{
|
|
if(InTypeDef==1)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n","}",TypeName[InTypeDef],", *","LP",ucase(TypeName[InTypeDef]),";");
|
|
fprintf(Outfile,"%s\n","");
|
|
Outfile=SaveOutfileNum;
|
|
fprintf(FP6,"%s%s%s%s%s%s\n",Scoot,"#define ",ucase(TypeName[InTypeDef]),"_CLASS struct _",ucase(TypeName[InTypeDef]),"*");
|
|
}
|
|
else
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"} ",TypeName[InTypeDef],";");
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
InTypeDef--;
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"union")==0)
|
|
{
|
|
if(InTypeDef==0)
|
|
{
|
|
SaveOutfileNum=Outfile;
|
|
}
|
|
Outfile=FP4;
|
|
InTypeDef++;
|
|
strcpy(TypeName[InTypeDef],Stk[2]);
|
|
AddTypeDefs(TypeName[InTypeDef],vt_UNION);
|
|
BaseTypeDefsCnt[InTypeDef]=TypeDefsCnt;
|
|
if(InTypeDef==1)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","typedef union ");
|
|
fprintf(Outfile,"%s\n","{");
|
|
BumpUp();
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"union");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
AddTypedefElement(BaseTypeDefsCnt[InTypeDef-1],vt_UNION,TypeName[InTypeDef],TypeName[InTypeDef],0);
|
|
BumpUp();
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"endunion")==0)
|
|
{
|
|
if(InTypeDef==1)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n","} ",TypeName[InTypeDef],", *","LP",ucase(TypeName[InTypeDef]),";");
|
|
fprintf(Outfile,"%s\n","");
|
|
Outfile=SaveOutfileNum;
|
|
}
|
|
else
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"} ",TypeName[InTypeDef],";");
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
InTypeDef--;
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"with")==0)
|
|
{
|
|
WithCnt++;
|
|
if(WithCnt==8)
|
|
{
|
|
Abort("[With] depth exceeded");
|
|
}
|
|
*WithVar[WithCnt]=0;
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
strcat(WithVar[WithCnt],Stk[i]);
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"endwith")==0)
|
|
{
|
|
WithCnt--;
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"clear")==0)
|
|
{
|
|
Use_Clear=TRUE;
|
|
fprintf(Outfile,"%s%s",Scoot,"Clear ");
|
|
if(str_cmp(Stk[2],"(")!=0)
|
|
{
|
|
fprintf(Outfile,"%s","(");
|
|
}
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[i]));
|
|
}
|
|
if(str_cmp(Stk[2],"(")!=0)
|
|
{
|
|
fprintf(Outfile,"%s",")");
|
|
}
|
|
fprintf(Outfile,"%s\n",";");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"repeat")==0)
|
|
{
|
|
*lszTmp=0;
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
strcat(lszTmp,Stk[i]);
|
|
}
|
|
strcpy(lszTmp,Clean(lszTmp));
|
|
BumpUp();
|
|
if(inchr(Stk[2],"-"))
|
|
{
|
|
if(str_cmp(left(lszTmp,1),"-")==0)
|
|
{
|
|
strcpy(lszTmp,mid(lszTmp,2));
|
|
}
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{int BCX_REPEAT;");
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"for(BCX_REPEAT=",lszTmp,";BCX_REPEAT>=1;BCX_REPEAT--)");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{int BCX_REPEAT;");
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"for(BCX_REPEAT=1;BCX_REPEAT<=",lszTmp,";BCX_REPEAT++)");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
}
|
|
BumpUp();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"endrepeat")==0)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
BumpDown();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"const")==0)
|
|
{
|
|
char Buffer[2048];
|
|
char Sep[2048];
|
|
*Buffer=0;
|
|
*Sep=0;
|
|
*Stk[1]=0;
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"=")==0)
|
|
{
|
|
i++;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
strcat(Stk[1],Stk[i]);
|
|
}
|
|
}
|
|
strcpy(Stk[1], join(3,"#define ",Clean(Stk[1]),SPC));
|
|
for(i=i; i<=Ndx; i+=1)
|
|
{
|
|
if(isalpha(Stk[i][0])||(Stk[i][0]==95&&isalpha(Stk[i+1][0]))||Stk[i+1][0]==95)
|
|
{
|
|
strcpy(Sep," ");
|
|
}
|
|
else
|
|
{
|
|
*Sep=0;
|
|
}
|
|
if(!IsQuoted(Stk[i]))
|
|
{
|
|
strcpy(Stk[i],RemoveStr(Stk[i],"$"));
|
|
}
|
|
strcpy(Buffer, join(3,Buffer,Stk[i],Sep));
|
|
}
|
|
strcpy(Buffer, join(2,Stk[1],Buffer));
|
|
if(InConditional)
|
|
{
|
|
if(InFunc)
|
|
{
|
|
fprintf(Outfile,"%s\n",Buffer);
|
|
}
|
|
else
|
|
{
|
|
if(str_cmp(ConstLastDef,"FP6")!=0)
|
|
{
|
|
fprintf(FP6,"%s%s\n",InIfDef,"// FP6");
|
|
strcpy(ConstLastDef,"FP6");
|
|
}
|
|
fprintf(FP6,"%s\n",Buffer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(FP6,"%s\n",Buffer);
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"kill")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s",Scoot,"remove (");
|
|
for(A=2; A<=Ndx; A+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(trim(Stk[A])));
|
|
}
|
|
fprintf(Outfile,"%s\n",");");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"chdir")==0 || str_cmp(Lookup,"_chdir")==0 || str_cmp(Lookup,"rmdir")==0 || str_cmp(Lookup,"_rmdir")==0 || str_cmp(Lookup,"mkdir")==0 || str_cmp(Lookup,"_mkdir")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s",Scoot,Lookup," (");
|
|
for(A=2; A<=Ndx; A+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(trim(Stk[A])));
|
|
}
|
|
fprintf(Outfile,"%s\n",");");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"free")==0)
|
|
{
|
|
VarInfo* VI;
|
|
A=2;
|
|
if(iMatchWrd(Stk[2],"dynamic"))
|
|
{
|
|
A=3;
|
|
}
|
|
if(str_cmp(Stk[A],"(")==0)
|
|
{
|
|
A++;
|
|
Ndx--;
|
|
}
|
|
strcpy(CVar,Clean(Stk[A]));
|
|
vt=CheckLocal(CVar, &id);
|
|
if(vt==vt_UNKNOWN)
|
|
{
|
|
vt=CheckGlobal(CVar, &id);
|
|
if(vt==vt_UNKNOWN)
|
|
{
|
|
Abort(join(3,"Can not REDIM ",CVar," not previously dimensioned"));
|
|
}
|
|
VI= &GlobalVars[id];
|
|
}
|
|
else
|
|
{
|
|
VI= &LocalVars[id];
|
|
Warning("Local dynamic variables are automatically freed.",1);
|
|
}
|
|
*CVar=0;
|
|
for(i=A; i<=Ndx; i+=1)
|
|
{
|
|
strcat(CVar,Stk[i]);
|
|
}
|
|
strcpy(CVar,Clean(CVar));
|
|
if(vt==vt_STRUCT||vt==vt_UNION)
|
|
{
|
|
GetElement(2, &vt, &dms,VI->VarDef);
|
|
if(vt!=vt_UNKNOWN&&dms>0)
|
|
{
|
|
Use_DynamicA=TRUE;
|
|
fprintf(Outfile,"%s%s%s",Scoot,"if (",CVar);
|
|
fprintf(Outfile,"%s%s%s%d%s",") { DestroyArr((void **)",CVar,",",(int)dms,", 1); ");
|
|
fprintf(Outfile,"%s%s\n",CVar,"=NULL; }");
|
|
break;
|
|
}
|
|
}
|
|
if(VI->VarPntr>1)
|
|
{
|
|
Use_DynamicA=TRUE;
|
|
fprintf(Outfile,"%s%s%s",Scoot,"if (",CVar);
|
|
fprintf(Outfile,"%s%s%s%s%s",") { DestroyArr((void **)",CVar,",",str(VI->VarPntr),", 1); ");
|
|
fprintf(Outfile,"%s%s\n",CVar,"=NULL; }");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"free(",CVar,"), ",CVar,"=NULL;");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"midstr")==0)
|
|
{
|
|
*Src=0;
|
|
for(A=1; A<=Ndx; A+=1)
|
|
{
|
|
strcat(Src,Clean(Stk[A]));
|
|
}
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,trim(Src),";");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"swap")==0)
|
|
{
|
|
VarInfo* VI1;
|
|
VarInfo* VI2;
|
|
int indx;
|
|
fprintf(Outfile,"%s%s",Scoot,"swap ((BYTE*)&");
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],",")==0)
|
|
{
|
|
break;
|
|
}
|
|
fprintf(Outfile,"%s",Clean(Stk[i]));
|
|
}
|
|
A=CheckLocal(Stk[2], &indx);
|
|
if(A==vt_UNKNOWN)
|
|
{
|
|
A=CheckGlobal(Stk[2], &indx);
|
|
if(A==vt_UNKNOWN)
|
|
{
|
|
Abort(join(3,"Variable '",Stk[2],"' in swap statement unknown"));
|
|
}
|
|
VI1= &GlobalVars[indx];
|
|
}
|
|
else
|
|
{
|
|
VI1= &LocalVars[indx];
|
|
}
|
|
if(str_cmp(right(Stk[i-1],1),"]")!=0)
|
|
{
|
|
if(VI1->VarType==vt_CHAR&&VI1->VarPntr==1)
|
|
{
|
|
fprintf(Outfile,"%s","[0]");
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s",",(BYTE*)&");
|
|
i++;
|
|
for(j=i; j<=Ndx; j+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[j]));
|
|
}
|
|
A=CheckLocal(Stk[i], &indx);
|
|
if(A==vt_UNKNOWN)
|
|
{
|
|
A=CheckGlobal(Stk[i], &indx);
|
|
if(A==vt_UNKNOWN)
|
|
{
|
|
Abort(join(3,"Variable '",Stk[i],"' in swap statement unknown"));
|
|
}
|
|
VI2= &GlobalVars[indx];
|
|
}
|
|
else
|
|
{
|
|
VI2= &LocalVars[indx];
|
|
}
|
|
if(str_cmp(right(Stk[j-1],1),"]")!=0)
|
|
{
|
|
if(VI2->VarType==vt_CHAR&&VI2->VarPntr==1)
|
|
{
|
|
fprintf(Outfile,"%s","[0]");
|
|
}
|
|
}
|
|
if(VI1->VarType!=VI2->VarType)
|
|
{
|
|
Warning("Possible size error in swap statement");
|
|
}
|
|
if(VI2->VarType==vt_STRVAR||VI2->VarType==vt_CHAR)
|
|
{
|
|
fprintf(Outfile,"%s",",strlen(");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s",",sizeof(");
|
|
}
|
|
for(j=i; j<=Ndx; j+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[j]));
|
|
}
|
|
fprintf(Outfile,"%s\n","));");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"rename")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s",Scoot,"rename (");
|
|
for(A=2; A<=Ndx; A+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(trim(Stk[A])));
|
|
}
|
|
fprintf(Outfile,"%s\n",");");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"copyfile")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s",Scoot,"CopyFile ");
|
|
if(str_cmp(Stk[2],"(")!=0)
|
|
{
|
|
fprintf(Outfile,"%s","(");
|
|
}
|
|
for(A=2; A<=Ndx; A+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(trim(Stk[A])));
|
|
}
|
|
if(str_cmp(Stk[Ndx],")")!=0)
|
|
{
|
|
fprintf(Outfile,"%s\n",");");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n",";");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"shell")==0)
|
|
{
|
|
if(Ndx>2)
|
|
{
|
|
for(A=3; A<=Ndx; A+=1)
|
|
{
|
|
strcpy(Stk[2], join(2,Stk[2],Stk[A]));
|
|
}
|
|
}
|
|
strcpy(ZZ,Stk[2]);
|
|
if(ZZ[0]==0)
|
|
{
|
|
strcpy(ZZ,DDQ);
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"Shell(",Clean(ZZ),");");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"lineinput")==0)
|
|
{
|
|
i=DataType(Stk[2]);
|
|
if(i==vt_STRLIT||i==vt_STRVAR)
|
|
{
|
|
if(i!=vt_STRLIT)
|
|
{
|
|
strcpy(Stk[2],Clean(Stk[2]));
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"printf(",enc("%s"),",",Stk[2],");");
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"AR_fgets_retval=fgets(",Clean(Stk[3]),",65535,stdin);");
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Scoot,Clean(Stk[3]),"[strlen(",Clean(Stk[3]),")-1]=0;");
|
|
break;
|
|
}
|
|
strcpy(Stk[2],RemoveStr(Stk[2],"#"));
|
|
if(DataType(Stk[2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[2], join(2,"FP",Stk[2]));
|
|
}
|
|
strcpy(Handl,extract(Stk[2],"["));
|
|
if(CheckLocal(Handl, &i)==vt_UNKNOWN)
|
|
{
|
|
if(CheckGlobal(Handl, &i)==vt_UNKNOWN)
|
|
{
|
|
AddGlobal(Handl,vt_FILEPTR,0,"",0,0,0,0);
|
|
}
|
|
}
|
|
strcpy(Var,Clean(Stk[3]));
|
|
*Var1=0;
|
|
strcpy(CVar,Var);
|
|
if(inchr(Var,"[")&&inchr(Var,"]"))
|
|
{
|
|
if(instr_b(Var,"[++"))
|
|
{
|
|
strcpy(CVar,replace(CVar,"++",""));
|
|
}
|
|
if(instr_b(Var,"[--"))
|
|
{
|
|
strcpy(CVar,replace(CVar,"--",""));
|
|
}
|
|
if(instr_b(Var,"++]"))
|
|
{
|
|
strcpy(CVar,replace(CVar,"++",""));
|
|
strcpy(Var1,mid(Var,inchr(Var,"[")+1));
|
|
strcpy(Var1,extract(Var1,"]"));
|
|
strcpy(Var,CVar);
|
|
}
|
|
if(instr_b(Var,"--]"))
|
|
{
|
|
strcpy(CVar,replace(CVar,"--",""));
|
|
strcpy(Var1,mid(Var,inchr(Var,"[")+1));
|
|
strcpy(Var1,extract(Var1,"]"));
|
|
strcpy(Var,CVar);
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,Var,"[0]=0;");
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"AR_fgets_retval=fgets(",Var,",65535,",Clean(Stk[2]),");");
|
|
fprintf(Outfile,"%s%s%s%s%s%s",Scoot,"if(",CVar,"[strlen(",CVar,")-1]==10)");
|
|
fprintf(Outfile,"%s%s%s%s\n",CVar,"[strlen(",CVar,")-1]=0;");
|
|
if(Var1[0]!=0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Var1,";");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"open")==0)
|
|
{
|
|
for(A=1; A<=Ndx; A+=1)
|
|
{
|
|
strcpy(Keyword,lcase(Stk[A]));
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Keyword,"open")==0)
|
|
{
|
|
*Stk[A]=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"for")==0)
|
|
{
|
|
*Stk[A]=0;
|
|
*Filnam=0;
|
|
for(j=2; j<=A-1; j+=1)
|
|
{
|
|
strcat(Filnam,Stk[j]);
|
|
}
|
|
strcpy(Filnam,Clean(Filnam));
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"as")==0)
|
|
{
|
|
*Stk[A]=0;
|
|
if(DataType(Stk[A+1])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[A+1], join(2,"FP",Stk[A+1]));
|
|
}
|
|
if(CheckLocal(Stk[A+1], &i)==vt_UNKNOWN)
|
|
{
|
|
if(CheckGlobal(Stk[A+1], &i)==vt_UNKNOWN)
|
|
{
|
|
AddGlobal(Stk[A+1],vt_FILEPTR,0,"",0,0,0,0);
|
|
}
|
|
}
|
|
*Var=0;
|
|
for(j=A+1; j<=Ndx; j+=1)
|
|
{
|
|
if(iMatchWrd(Stk[j],"reclen"))
|
|
{
|
|
break;
|
|
}
|
|
strcat(Var,Stk[j]);
|
|
*Stk[j]=0;
|
|
}
|
|
strcpy(Handl, join(2,Var,"@"));
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"network")==0)
|
|
{
|
|
Use_Socket=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"input")==0)
|
|
{
|
|
strcpy(Op,enc("r"));
|
|
*Stk[A]=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"output")==0)
|
|
{
|
|
strcpy(Op,enc("w"));
|
|
*Stk[A]=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"append")==0)
|
|
{
|
|
strcpy(Op,enc("a"));
|
|
*Stk[A]=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"binary")==0)
|
|
{
|
|
strcpy(Op,enc("rb+"));
|
|
*Stk[A]=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"binaryappend")==0)
|
|
{
|
|
strcpy(Op,enc("ab+"));
|
|
*Stk[A]=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"binarynew")==0)
|
|
{
|
|
strcpy(Op,enc("wb+"));
|
|
*Stk[A]=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"binaryinput")==0)
|
|
{
|
|
strcpy(Op,enc("rb"));
|
|
*Stk[A]=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"binaryoutput")==0)
|
|
{
|
|
strcpy(Op,enc("rb+"));
|
|
*Stk[A]=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Keyword,"reclen")==0)
|
|
{
|
|
if(str_cmp(Stk[A+1],"=")==0)
|
|
{
|
|
for(j=A+2; j<=Ndx; j+=1)
|
|
{
|
|
strcpy(Stk[j-1],Stk[j]);
|
|
}
|
|
Ndx--;
|
|
}
|
|
strcpy(Var, join(2,extract(Clean(Handl),"["),"len"));
|
|
if(CheckLocal(Var, &i)==vt_UNKNOWN)
|
|
{
|
|
AddGlobal(Var,vt_INTEGER,0,"",0,0,0,0);
|
|
}
|
|
else
|
|
{
|
|
if(CheckLocal(Var, &i)==vt_UNKNOWN)
|
|
{
|
|
AddLocal(Var,vt_INTEGER,0,"",0,0,0);
|
|
strcpy(Var, join(2,"int ",Var));
|
|
}
|
|
}
|
|
i=CheckType(Stk[A+1]);
|
|
strcpy(ZZ,lcase(Stk[A+1]));
|
|
if(i==vt_STRUCT||i==vt_UNION||str_cmp(ZZ,"int")==0 || str_cmp(ZZ,"double")==0 || str_cmp(ZZ,"float")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Scoot,Var," = sizeof(",Stk[A+1],");");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Scoot,Var," = ",Clean(Stk[A+1]),";");
|
|
}
|
|
*Stk[A]=0;
|
|
*Stk[A+1]=0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"if((",Clean(Handl),"=fopen(",Filnam,",",Op,"))==0)");
|
|
fprintf(Outfile,"%s%s\n",Scoot," {");
|
|
strcpy(lszTmp,enc("Can't open file %s\\n"));
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot," fprintf(stderr,",lszTmp,",",Filnam,");");
|
|
fprintf(Outfile,"%s%s\n",Scoot," exit(1);");
|
|
fprintf(Outfile,"%s%s\n",Scoot," }");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"record")==0)
|
|
{
|
|
static struct _functionParse ffp;
|
|
memset(&ffp,0,sizeof(ffp));
|
|
int numargs=0;
|
|
if(DataType(Stk[2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[2], join(2,"FP",Stk[2]));
|
|
}
|
|
if(Ndx>1)
|
|
{
|
|
numargs=SepFuncArgs(1, &ffp,FALSE);
|
|
}
|
|
if(numargs<1)
|
|
{
|
|
Abort("Missing required arguments to RECORD");
|
|
}
|
|
if(numargs>4)
|
|
{
|
|
Abort("Too many arguments to RECORD");
|
|
}
|
|
if(numargs==3)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s\n",Scoot,"fseek(",GetArg(1, &ffp),", (",GetArg(2, &ffp)," - 1) * ",Stk[2],"len + ",GetArg(3, &ffp),", SEEK_SET);");
|
|
}
|
|
else if(numargs==2)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"fseek(",GetArg(1, &ffp),", (",GetArg(2, &ffp)," - 1) * ",Stk[2],"len, SEEK_SET);");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"fseek(",GetArg(1, &ffp),", 0, SEEK_SET);");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"fwrite")==0)
|
|
{
|
|
if(DataType(Stk[2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[2], join(2,"FP",Stk[Ndx]));
|
|
}
|
|
if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
|
|
{
|
|
AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
|
|
}
|
|
*Handl=0;
|
|
for(j=2; j<=Ndx; j+=1)
|
|
{
|
|
if(iMatchWrd(Stk[j],",")||iMatchWrd(Stk[j],";"))
|
|
{
|
|
*Stk[j]=0;
|
|
break;
|
|
}
|
|
strcat(Handl,Stk[j]);
|
|
*Stk[j]=0;
|
|
}
|
|
strcat(Handl,"@");
|
|
strcpy(ZZ, join(2,"f",PrintWriteFormat(1)));
|
|
strcpy(ZZ, join(4,left(ZZ,8),Clean(Handl),",",mid(ZZ,9)));
|
|
fprintf(Outfile,"%s%s\n",Scoot,ZZ);
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"close")==0)
|
|
{
|
|
if(Ndx==1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"fcloseall();");
|
|
break;
|
|
}
|
|
if(DataType(Stk[2])==vt_NUMBER)
|
|
{
|
|
strcpy(Stk[2], join(2,"FP",Stk[Ndx]));
|
|
}
|
|
if(CheckLocal(Stk[2], &i)==vt_UNKNOWN)
|
|
{
|
|
if(CheckGlobal(Stk[2], &i)==vt_UNKNOWN)
|
|
{
|
|
AddGlobal(Stk[2],vt_FILEPTR,0,"",0,0,0,0);
|
|
}
|
|
}
|
|
*Handl=0;
|
|
for(j=2; j<=Ndx; j+=1)
|
|
{
|
|
strcat(Handl,Stk[j]);
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"if(",Handl,")");
|
|
fprintf(Outfile,"%s%s\n",Scoot," {");
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot," fclose(",Handl,");");
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot," ",Handl,"=NULL;");
|
|
fprintf(Outfile,"%s%s\n",Scoot," }");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"call")==0)
|
|
{
|
|
*lszTmp=0;
|
|
for(Tmp=2; Tmp<=Ndx; Tmp+=1)
|
|
{
|
|
strcat(lszTmp,Clean(Stk[Tmp]));
|
|
}
|
|
if(!iMatchRgt(lszTmp,")"))
|
|
{
|
|
strcat(lszTmp,"()");
|
|
}
|
|
strcat(lszTmp,";");
|
|
fprintf(Outfile,"%s%s\n",Scoot,lszTmp);
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"declare")==0)
|
|
{
|
|
static struct _functionParse FP;
|
|
memset(&FP,0,sizeof(FP));
|
|
char TempProto[2048];
|
|
FuncSubDecs1("sub");
|
|
SepFuncArgs(3, &FP,TRUE);
|
|
strcpy(TempProto,MakeDecProto( &FP));
|
|
if(!NoTypeDeclare)
|
|
{
|
|
fprintf(FP4,"%s%s\n",TempProto,";");
|
|
}
|
|
else
|
|
{
|
|
ProtoCnt++;
|
|
strcpy(ProtoType[ProtoCnt].Prototype, join(2,TempProto,";"));
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"function")==0 || str_cmp(Lookup,"sub")==0 || str_cmp(Lookup,"constructor")==0 || str_cmp(Lookup,"destructor")==0)
|
|
{
|
|
static char CTOR_USE[2048];
|
|
memset(&CTOR_USE,0,sizeof(CTOR_USE));
|
|
static char CTOR_SRC[2048];
|
|
memset(&CTOR_SRC,0,sizeof(CTOR_SRC));
|
|
static int New_Ndx;
|
|
memset(&New_Ndx,0,sizeof(New_Ndx));
|
|
if(str_cmp(Stk[2],"main")==0)
|
|
{
|
|
strcpy(Stk[1],"function");
|
|
strcpy(Stk[2],"main%");
|
|
ForceMainToFunc=TRUE;
|
|
}
|
|
if(iMatchWrd(Stk[1],"constructor")||iMatchWrd(Stk[1],"destructor"))
|
|
{
|
|
strcpy(Stk[1],"sub");
|
|
{int ct;
|
|
for(ct=1; ct<=Ndx; ct+=1)
|
|
{
|
|
if(str_cmp(Stk[ct],"using")==0)
|
|
{
|
|
New_Ndx=ct-1;
|
|
{int ut;
|
|
for(ut=ct; ut<=Ndx; ut+=1)
|
|
{
|
|
strcat(CTOR_USE,Stk[ut]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(strlen(CTOR_USE))
|
|
{
|
|
strcpy(CTOR_USE,iReplace(CTOR_USE,"using",":"));
|
|
Ndx=New_Ndx;
|
|
}
|
|
Use_Ctor=TRUE;
|
|
}
|
|
FuncSubDecs1("sub");
|
|
IsStdFunc=FALSE;
|
|
if(iMatchWrd(Stk[Ndx],"stdcall"))
|
|
{
|
|
strcpy(CallType,"__attribute__((stdcall)) ");
|
|
Ndx--;
|
|
IsStdFunc=TRUE;
|
|
}
|
|
InFunc=TRUE;
|
|
InMain=FALSE;
|
|
LocalVarCnt=0;
|
|
if(InNameSpace)
|
|
{
|
|
Outfile=FP2;
|
|
}
|
|
else
|
|
{
|
|
Outfile=FP3;
|
|
}
|
|
FuncSubDecs2("sub",mt_FuncSubDecC_Dec);
|
|
strcpy(VarCode.Functype,ltrim(VarCode.Functype));
|
|
strcpy(Funcname,Clean(Stk[2]));
|
|
if(IsExported||IsStdFunc)
|
|
{
|
|
strcpy(Funcname, join(2,CallType,Funcname));
|
|
}
|
|
VarCode.Method=mt_FuncSubDecC_Dec2;
|
|
A=3;
|
|
while(A<=Ndx)
|
|
{
|
|
if(str_cmp(Stk[A+1],"(")==0)
|
|
{
|
|
for(k=A+2; k<=Ndx; k+=1)
|
|
{
|
|
if(str_cmp(Stk[k],")")==0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if(iMatchWrd(Stk[k+2],"sub"))
|
|
{
|
|
j=vt_VOID;
|
|
strcpy(VarCode.AsToken,"void");
|
|
}
|
|
else if(iMatchWrd(Stk[k+2],"function"))
|
|
{
|
|
GetTypeInfo(Stk[k+3], &IsPointer, &i, &j);
|
|
strcpy(VarCode.AsToken,Stk[k+3]);
|
|
}
|
|
strcpy(VarCode.Token,Stk[A]);
|
|
VarCode.VarNo=j;
|
|
VarCode.IsPtrFlag=1;
|
|
VarCode.Method=mt_FuncSubx1;
|
|
GetVarCode( &VarCode);
|
|
strcpy(Var,Clean(Stk[A]));
|
|
*lszTmp=0;
|
|
A+=2;
|
|
while(A<=k)
|
|
{
|
|
if(iMatchWrd(Stk[A+1],"as")&&A<k)
|
|
{
|
|
Tmp=A+2;
|
|
while(str_cmp(Stk[Tmp],",")!=0 && str_cmp(Stk[Tmp],")")!=0)
|
|
{
|
|
GetTypeInfo(Stk[Tmp], &IsPointer, &i, &j);
|
|
AddLocal(Stk[A],j,i,"",IsPointer,0,0);
|
|
strcpy(VarCode.Token,Stk[A]);
|
|
strcpy(VarCode.AsToken,Stk[Tmp]);
|
|
VarCode.VarNo=j;
|
|
VarCode.IsPtrFlag=1;
|
|
VarCode.Method=mt_FuncSubx2;
|
|
GetVarCode( &VarCode);
|
|
Tmp++;
|
|
if(str_cmp(Stk[Tmp],",")==0)
|
|
{
|
|
strcat(VarCode.Proto,",");
|
|
strcat(VarCode.Header,",");
|
|
}
|
|
}
|
|
A=Tmp;
|
|
}
|
|
else
|
|
{
|
|
if(str_cmp(Stk[A],",")!=0 && str_cmp(Stk[A],")")!=0)
|
|
{
|
|
IsPointer=tally((Stk[A]),"*");
|
|
strcpy(Var,RemoveStr(Stk[A],"*"));
|
|
j=DataType(Var);
|
|
if(j!=vt_UNKNOWN&&InFunc==TRUE&&Var[0])
|
|
{
|
|
AddLocal(Clean(Var),j,0,"",IsPointer,0,0);
|
|
}
|
|
strcpy(VarCode.Token,Stk[A]);
|
|
*VarCode.AsToken=0;
|
|
VarCode.VarNo=j;
|
|
VarCode.IsPtrFlag=IsPointer;
|
|
VarCode.Method=mt_FuncSubDecC_Dec2;
|
|
GetVarCode( &VarCode);
|
|
}
|
|
}
|
|
A++;
|
|
}
|
|
A=k+3;
|
|
if(VarCode.Method==mt_FuncSubDecC_Dec2)
|
|
{
|
|
midstr(VarCode.Proto,strlen(VarCode.Proto)-1,1,")");
|
|
midstr(VarCode.Header,strlen(VarCode.Header)-1,1,")");
|
|
}
|
|
else
|
|
{
|
|
strcat(VarCode.Proto,")");
|
|
strcat(VarCode.Header,")");
|
|
}
|
|
VarCode.Method=mt_FuncSubDecC_Dec2;
|
|
}
|
|
else
|
|
{
|
|
if(iMatchWrd(Stk[A+1],"as"))
|
|
{
|
|
GetTypeInfo(Stk[A+2], &IsPointer, &i, &j);
|
|
strcpy(Var,Clean(Stk[A]));
|
|
AddLocal(Var,j,i,"",IsPointer,0,0);
|
|
strcpy(VarCode.Token,Stk[A]);
|
|
strcpy(VarCode.AsToken,Stk[A+2]);
|
|
VarCode.VarNo=j;
|
|
VarCode.IsPtrFlag=IsPointer;
|
|
GetVarCode( &VarCode);
|
|
*Stk[A+1]=0;
|
|
*Stk[A+2]=0;
|
|
A+=2;
|
|
}
|
|
else
|
|
{
|
|
if(inchr("=",Stk[A])&&str_cmp(Stk[A],"")!=0)
|
|
{
|
|
Abort("Illegal optional parameter found");
|
|
}
|
|
if(!inchr(",().",Stk[A])&&str_cmp(Stk[A],"")!=0)
|
|
{
|
|
IsPointer=tally((Stk[A]),"*");
|
|
strcpy(Var,RemoveStr(Stk[A],"*"));
|
|
j=DataType(Var);
|
|
if(j!=vt_UNKNOWN&&Var[0])
|
|
{
|
|
AddLocal(Clean(Var),j,0,"",IsPointer,0,0);
|
|
}
|
|
strcpy(VarCode.Token,Stk[A]);
|
|
*VarCode.AsToken=0;
|
|
VarCode.VarNo=j;
|
|
VarCode.IsPtrFlag=IsPointer;
|
|
GetVarCode( &VarCode);
|
|
}
|
|
}
|
|
}
|
|
A++;
|
|
}
|
|
VarCode.Method=2;
|
|
strcpy(VarCode.Token,Funcname);
|
|
FuncSubDecs3( &VarCode);
|
|
if(iMatchLft(VarCode.Header,"main("))
|
|
{
|
|
strcpy(VarCode.Header,"int main(int argc, char *argv[])");
|
|
strcpy(VarCode.Proto,"int main(int argc, char *argv[]);");
|
|
CurrentFuncType=vt_INTEGER;
|
|
}
|
|
if(Use_Static)
|
|
{
|
|
strcpy(VarCode.Header, join(2,"static ",VarCode.Header));
|
|
strcpy(VarCode.Proto, join(2,"static ",VarCode.Proto));
|
|
}
|
|
if(!InNameSpace)
|
|
{
|
|
ProtoCnt++;
|
|
strcpy(ProtoType[ProtoCnt].Prototype,VarCode.Proto);
|
|
}
|
|
if(str_cmp(InIfDef,"FP3")==0)
|
|
{
|
|
if(ProtoCnt>1)
|
|
{
|
|
strcpy(ProtoType[ProtoCnt].Condition,ProtoType[ProtoCnt-1].Condition);
|
|
}
|
|
else
|
|
{
|
|
*ProtoType[ProtoCnt].Condition=0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
strcpy(ProtoType[ProtoCnt].Condition,InIfDef);
|
|
}
|
|
ProtoType[ProtoCnt].CondLevel=InConditional;
|
|
if(*InIfDef)
|
|
{
|
|
if(str_cmp(InIfDef,"FP3")!=0)
|
|
{
|
|
fprintf(Outfile,"%s\n",InIfDef);
|
|
printf("%s\n",InIfDef);
|
|
}
|
|
}
|
|
if(Use_Ctor)
|
|
{
|
|
strcpy(VarCode.Header,replace(VarCode.Header,"void ",""));
|
|
strcpy(VarCode.Header,replace(VarCode.Header,"void",""));
|
|
if(strlen(CTOR_USE))
|
|
{
|
|
fprintf(Outfile,"%s\n",VarCode.Header);
|
|
fprintf(Outfile,"%s%s\n",Scoot,CTOR_USE);
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n",VarCode.Header);
|
|
}
|
|
Use_Ctor=FALSE;
|
|
}
|
|
else if(InNameSpace)
|
|
{
|
|
char szCPP_SF1[2048];
|
|
*szCPP_SF1=0;
|
|
if(iMatchLft(Lookup,"public"))
|
|
{
|
|
strcpy(szCPP_SF1,"public: virtual ");
|
|
}
|
|
fprintf(Outfile,"%s%s%s\n",Scoot,szCPP_SF1,VarCode.Header);
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n",VarCode.Header);
|
|
}
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
BumpUp();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"optfunction")==0 || str_cmp(Lookup,"optsub")==0)
|
|
{
|
|
FuncSubDecs1("optsub");
|
|
InFunc=TRUE;
|
|
LocalVarCnt=0;
|
|
Outfile=FP3;
|
|
if(InNameSpace)
|
|
{
|
|
Outfile=FP2;
|
|
}
|
|
else
|
|
{
|
|
Outfile=FP3;
|
|
}
|
|
FuncSubDecs2("optsub",mt_Opts);
|
|
strcpy(Funcname,Clean(Stk[2]));
|
|
VarCode.Method=mt_Opts2;
|
|
A=4;
|
|
while(A<Ndx)
|
|
{
|
|
if(Stk[A][0]==0)
|
|
{
|
|
A++;
|
|
continue;
|
|
}
|
|
if(str_cmp(Stk[A],",")==0)
|
|
{
|
|
VarCode.Method=mt_Opts3;
|
|
strcpy(VarCode.Token,Stk[A]);
|
|
GetVarCode( &VarCode);
|
|
VarCode.Method=mt_Opts2;
|
|
}
|
|
else if(str_cmp(Stk[A],"=")==0)
|
|
{
|
|
VarCode.Method=mt_Opts3;
|
|
if(str_cmp(Stk[A+1],"-")==0)
|
|
{
|
|
strcpy(VarCode.Token, join(3,Stk[A],Stk[A+1],Stk[A+2]));
|
|
*Stk[A+1]=0;
|
|
*Stk[A+2]=0;
|
|
A++;
|
|
}
|
|
else
|
|
{
|
|
strcpy(VarCode.Token, join(2,Stk[A],Stk[A+1]));
|
|
*Stk[A+1]=0;
|
|
}
|
|
if(iMatchWrd(Stk[A+2],"as"))
|
|
{
|
|
*Stk[A+2]=0;
|
|
*Stk[A+3]=0;
|
|
}
|
|
VarCode.VarNo=j;
|
|
VarCode.IsPtrFlag=IsPointer;
|
|
GetVarCode( &VarCode);
|
|
VarCode.Method=mt_Opts2;
|
|
}
|
|
else if(iMatchWrd(Stk[A+1],"as"))
|
|
{
|
|
GetTypeInfo(Stk[A+2], &IsPointer, &i, &j);
|
|
if(InFunc)
|
|
{
|
|
strcpy(Var,Clean(Stk[A]));
|
|
AddLocal(Var,j,i,"",IsPointer,0,0);
|
|
}
|
|
VarCode.VarNo=j;
|
|
strcpy(VarCode.Token,Stk[A]);
|
|
strcpy(VarCode.AsToken,Stk[A+2]);
|
|
VarCode.IsPtrFlag=IsPointer;
|
|
GetVarCode( &VarCode);
|
|
*Stk[A+1]=0;
|
|
*Stk[A+2]=0;
|
|
}
|
|
else
|
|
{
|
|
IsPointer=tally((Stk[A]),"*");
|
|
strcpy(Var,RemoveStr(Stk[A],"*"));
|
|
j=DataType(Var);
|
|
if(j!=vt_UNKNOWN)
|
|
{
|
|
AddLocal(Clean(Var),j,0,"",IsPointer,0,0);
|
|
}
|
|
VarCode.VarNo=j;
|
|
strcpy(VarCode.Token,Stk[A]);
|
|
*VarCode.AsToken=0;
|
|
VarCode.IsPtrFlag=IsPointer;
|
|
GetVarCode( &VarCode);
|
|
}
|
|
A++;
|
|
}
|
|
VarCode.Method=2;
|
|
strcpy(VarCode.Token,Funcname);
|
|
FuncSubDecs3( &VarCode);
|
|
if(Use_Static)
|
|
{
|
|
strcpy(VarCode.Header, join(2,"static ",VarCode.Header));
|
|
strcpy(VarCode.Proto, join(2,"static ",VarCode.Proto));
|
|
}
|
|
ProtoCnt++;
|
|
strcpy(ProtoType[ProtoCnt].Prototype,VarCode.Proto);
|
|
if(str_cmp(InIfDef,"FP3")==0)
|
|
{
|
|
*ProtoType[ProtoCnt].Condition=0;
|
|
}
|
|
else
|
|
{
|
|
strcpy(ProtoType[ProtoCnt].Condition,InIfDef);
|
|
}
|
|
ProtoType[ProtoCnt].CondLevel=InConditional;
|
|
fprintf(Outfile,"%s\n",VarCode.Header);
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
BumpUp();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"overloadedfunction")==0 || str_cmp(Lookup,"overloadedsub")==0)
|
|
{
|
|
Use_Overloaded=TRUE;
|
|
FuncSubDecs1("overloadedsub");
|
|
InFunc=TRUE;
|
|
InMain=FALSE;
|
|
LocalVarCnt=0;
|
|
Outfile=FP8;
|
|
FuncSubDecs2("overloadedsub",mt_OverLoad);
|
|
strcpy(Funcname,Clean(Stk[2]));
|
|
strcpy(lszTmp, join(2," overloaded ",Funcname));
|
|
strcpy(Funcname,lszTmp);
|
|
VarCode.Method=mt_OverLoad2;
|
|
for(A=3; A<=Ndx; A+=1)
|
|
{
|
|
if(iMatchWrd(Stk[A+1],"as"))
|
|
{
|
|
GetTypeInfo(Stk[A+2], &IsPointer, &i, &j);
|
|
strcpy(Var,Clean(Stk[A]));
|
|
AddLocal(Var,j,i,"",IsPointer,0,0);
|
|
strcpy(VarCode.AsToken,Stk[A+2]);
|
|
*Stk[A+1]=0;
|
|
*Stk[A+2]=0;
|
|
}
|
|
else
|
|
{
|
|
strcpy(Var,RemoveStr(Stk[A],"*"));
|
|
j=DataType(Var);
|
|
if(!inchr(",().",Stk[A])&&str_cmp(Stk[A],"")!=0)
|
|
{
|
|
IsPointer=tally((Stk[A]),"*");
|
|
if(j!=vt_UNKNOWN&&InFunc==TRUE&&Var[0])
|
|
{
|
|
AddLocal(Clean(Var),j,0,"",IsPointer,0,0);
|
|
}
|
|
}
|
|
*VarCode.AsToken=0;
|
|
}
|
|
VarCode.VarNo=j;
|
|
strcpy(VarCode.Token,Stk[A]);
|
|
GetVarCode( &VarCode);
|
|
}
|
|
VarCode.Method=1;
|
|
strcpy(VarCode.Token,Funcname);
|
|
FuncSubDecs3( &VarCode);
|
|
if(Use_Static)
|
|
{
|
|
strcpy(VarCode.Header, join(2,"static ",VarCode.Header));
|
|
}
|
|
fprintf(Outfile,"%s\n",VarCode.Header);
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
BumpUp();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"functionreturn")==0)
|
|
{
|
|
if(CaseFlag)
|
|
{
|
|
NoBreak2=TRUE;
|
|
}
|
|
*lszTmp=0;
|
|
for(A=3; A<=Ndx; A+=1)
|
|
{
|
|
strcpy(lszTmp, join(3,lszTmp,Stk[A]," "));
|
|
}
|
|
if(CurrentFuncType==vt_STRVAR)
|
|
{
|
|
strcpy(lszTmp, join(2,"BCX_RetStr$ = ",lszTmp));
|
|
FuncRetnFlag=1;
|
|
UseFlag=TRUE;
|
|
}
|
|
else
|
|
{
|
|
FuncRetnFlag=2;
|
|
}
|
|
if(FuncRetnFlag==2)
|
|
{
|
|
if(LocalDynaCnt!=0)
|
|
{
|
|
for(j=1; j<=LocalDynaCnt; j+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,DynaStr[j]);
|
|
}
|
|
}
|
|
if(LocalDynArrCount!=0)
|
|
{
|
|
for(i=1; i<=LocalDynArrCount; i+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,LocalDynArrName[i]);
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s",Scoot,"return ");
|
|
LastCmd=2;
|
|
}
|
|
Parse(lszTmp);
|
|
LastCmd=0;
|
|
goto EMITAGAIN;
|
|
}
|
|
if(str_cmp(Lookup,"endfunction")==0 || str_cmp(Lookup,"endsub")==0 || str_cmp(Lookup,"endconstructor")==0 || str_cmp(Lookup,"enddestructor")==0)
|
|
{
|
|
if(iMatchWrd(Stk[1],"endfunction"))
|
|
{
|
|
LocalDynaCnt=0;
|
|
LocalDynArrCount=0;
|
|
}
|
|
if(iMatchWrd(Stk[1],"endsub")||iMatchWrd(Stk[1],"endconstructor")||iMatchWrd(Stk[1],"enddestructor"))
|
|
{
|
|
if(LocalDynaCnt!=0)
|
|
{
|
|
for(j=1; j<=LocalDynaCnt; j+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,DynaStr[j]);
|
|
}
|
|
LocalDynaCnt=0;
|
|
}
|
|
if(LocalDynArrCount!=0)
|
|
{
|
|
for(i=1; i<=LocalDynArrCount; i+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,LocalDynArrName[i]);
|
|
}
|
|
LocalDynArrCount=0;
|
|
}
|
|
}
|
|
if(ForceMainToFunc==TRUE)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"return 0;");
|
|
ForceMainToFunc=FALSE;
|
|
}
|
|
BumpDown();
|
|
if(InNameSpace)
|
|
{
|
|
fprintf(FP2,"%s%s\n",Scoot,"}\n");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}\n\n");
|
|
BumpDown();
|
|
}
|
|
InFunc=FALSE;
|
|
Use_Static=FALSE;
|
|
if(Outfile==FP3)
|
|
{
|
|
strcpy(InIfDef,"FP3");
|
|
}
|
|
Outfile=FP2;
|
|
ByrefCnt=0;
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"input")==0)
|
|
{
|
|
EmitInputCode();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"finput")==0)
|
|
{
|
|
EmitFileInputCode();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"dynamic")==0)
|
|
{
|
|
int w=0;
|
|
char SOF[2048];
|
|
HandleNonsense();
|
|
strcpy(CVar,Clean(Stk[2]));
|
|
ValidVar(CVar);
|
|
if(str_cmp(Stk[Ndx],"*")==0)
|
|
{
|
|
PointerFix();
|
|
}
|
|
if(str_cmp(Stk[Ndx],"&")==0)
|
|
{
|
|
*Stk[Ndx--]=0;
|
|
strcat(Stk[Ndx],"&");
|
|
}
|
|
*ZZ=0;
|
|
if(iMatchWrd(Stk[Ndx-1],"as"))
|
|
{
|
|
strcpy(SOF,Stk[Ndx]);
|
|
GetTypeInfo(SOF, &w, &id, &vt);
|
|
if(vt==vt_STRLIT||vt==vt_DECFUNC||vt==vt_NUMBER||(vt==vt_VOID&&inchr(Stk[Ndx],"*")==0))
|
|
{
|
|
Abort(join(2,SOF," is not a valid type"));
|
|
}
|
|
if(vt==vt_FILEPTR&&inchr(SOF,"*")==0)
|
|
{
|
|
strcat(SOF,"*");
|
|
}
|
|
Ndx-=2;
|
|
}
|
|
else
|
|
{
|
|
vt=DataType(Stk[2]);
|
|
id=0;
|
|
strcpy(SOF,GetVarTypeName(vt));
|
|
}
|
|
Use_DynamicA=TRUE;
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcat(ZZ,Stk[i]);
|
|
}
|
|
dms=tally(ZZ,"][")+1;
|
|
if(dms>1)
|
|
{
|
|
strcpy(ZZ,replace(ZZ,"][",","));
|
|
}
|
|
strcpy(ZZ,Clean(ZZ));
|
|
RemoveAll(ZZ,"[]");
|
|
if(vt==vt_STRVAR)
|
|
{
|
|
vt=vt_CHAR;
|
|
strcpy(SOF,"char");
|
|
if(InTypeDef)
|
|
{
|
|
if(str_cmp(Stk[3],"[")!=0)
|
|
{
|
|
dms--;
|
|
}
|
|
else
|
|
{
|
|
vt=vt_CHARPTR;
|
|
}
|
|
}
|
|
dms++;
|
|
strcat(ZZ,",65535");
|
|
}
|
|
if(InTypeDef)
|
|
{
|
|
if(vt==vt_STRUCT)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,"struct _",SOF," ",stringx(dms,42),CVar,";");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,SOF," ",stringx(dms,42),CVar,";");
|
|
}
|
|
AddTypedefElement(BaseTypeDefsCnt[InTypeDef],vt,CVar,SOF,dms);
|
|
}
|
|
else if(InFunc)
|
|
{
|
|
LocalDynArrCount++;
|
|
strcpy(LocalDynArrName[LocalDynArrCount], join(9,"if (",CVar,") { DestroyArr((void **)",CVar,",",str(dms),", 1); ",CVar,"=NULL; }"));
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,SOF," ",stringx(dms,42),CVar,"=0;");
|
|
AddLocal(CVar,vt,id,"",dms,0,0);
|
|
}
|
|
else
|
|
{
|
|
if(Use_GenFree)
|
|
{
|
|
GlobalDynaCnt++;
|
|
strcpy(GlobalDynaStr[GlobalDynaCnt], join(9,"if (",CVar,") { DestroyArr((void **)",CVar,",",str(dms),", 1); ",CVar,"=NULL; }"));
|
|
}
|
|
AddGlobal(CVar,vt,id,"",dms,0,0,0);
|
|
}
|
|
if(!InTypeDef)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",Scoot,CVar,"= (",SOF,stringx(dms,42),")CreateArr (",CVar,",sizeof(",SOF,"),0,",trim(str(dms)),",",ZZ,");");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"redim")==0)
|
|
{
|
|
int IsPreserve;
|
|
char SOF[2048];
|
|
VarInfo* VI;
|
|
int vt1=0;
|
|
int IsSplat=0;
|
|
int BC=0;
|
|
int StartPoint;
|
|
int AsPos=Ndx;
|
|
HandleNonsense();
|
|
IsPreserve=iMatchWrd(Stk[2],"preserve");
|
|
StartPoint=2+IsPreserve;
|
|
vt1=DataType(Stk[StartPoint]);
|
|
strcpy(CVar,Clean(Stk[StartPoint]));
|
|
IsSplat=iMatchWrd(Stk[StartPoint+1],"*");
|
|
ValidVar(CVar);
|
|
for(i=Ndx; i>=1; i+=-1)
|
|
{
|
|
if(iMatchWrd(Stk[AsPos],"as"))
|
|
{
|
|
AsPos=i-1;
|
|
break;
|
|
}
|
|
}
|
|
int L=AsPos;
|
|
int SP=0;
|
|
while(L>StartPoint)
|
|
{
|
|
if(str_cmp(Stk[L],"[")==0)
|
|
{
|
|
BC--;
|
|
}
|
|
else if(str_cmp(Stk[L],"]")==0)
|
|
{
|
|
BC++;
|
|
if(BC==1)
|
|
{
|
|
L--;
|
|
continue;
|
|
}
|
|
}
|
|
if(BC==0)
|
|
{
|
|
SP++;
|
|
if(str_cmp(Stk[L-1],"]")!=0)
|
|
{
|
|
break;
|
|
}
|
|
strcpy(ZZ, join(2,",",ZZ));
|
|
}
|
|
else
|
|
{
|
|
strcpy(ZZ, join(2,Stk[L],ZZ));
|
|
}
|
|
L--;
|
|
}
|
|
vt=CheckLocal(CVar, &id);
|
|
if(vt==vt_UNKNOWN)
|
|
{
|
|
vt=CheckGlobal(CVar, &id);
|
|
if(vt==vt_UNKNOWN)
|
|
{
|
|
Abort(join(3,"Can not REDIM ",CVar," not previously dimensioned"));
|
|
}
|
|
VI= &GlobalVars[id];
|
|
}
|
|
else
|
|
{
|
|
VI= &LocalVars[id];
|
|
}
|
|
dms=VI->VarPntr;
|
|
if(vt==vt_STRUCT||vt==vt_UDT||vt==vt_UNION)
|
|
{
|
|
strcpy(SOF,GetElement(StartPoint, &vt, &dms,VI->VarDef));
|
|
i=Ndx;
|
|
Ndx=L-1;
|
|
AsmUnknownStructs(1);
|
|
Ndx=i;
|
|
RemEmptyTokens();
|
|
strcpy(CVar,Clean(Stk[StartPoint]));
|
|
IsSplat=iMatchWrd(Stk[StartPoint+1],"*");
|
|
}
|
|
else
|
|
{
|
|
strcpy(SOF,GetVarTypeName(vt));
|
|
}
|
|
if(iMatchWrd(Stk[Ndx-1],"as"))
|
|
{
|
|
if(str_cmp(SOF,Stk[Ndx])!=0 && !iMatchWrd(Stk[Ndx],"string"))
|
|
{
|
|
Abort(join(6,"Can not change types for variable ",CVar," previously defined as ",SOF," on line",str(VI->VarLine)));
|
|
}
|
|
if(iMatchWrd(Stk[Ndx],"string"))
|
|
{
|
|
Ndx--;
|
|
strcpy(Stk[Ndx],"[");
|
|
strcpy(Stk[++Ndx],"65535");
|
|
strcpy(Stk[++Ndx],"]");
|
|
}
|
|
else
|
|
{
|
|
Ndx-=2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if((vt==vt_CHAR&&vt1==vt_STRVAR&&IsSplat==0)||vt==vt_CHARPTR)
|
|
{
|
|
Ndx++;
|
|
strcpy(Stk[Ndx],"[");
|
|
strcpy(Stk[++Ndx],"65535");
|
|
strcpy(Stk[++Ndx],"]");
|
|
}
|
|
}
|
|
if(str_cmp(Stk[3+IsPreserve],"[")==0)
|
|
{
|
|
if(IsPreserve)
|
|
{
|
|
StartPoint=4;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s\n",Scoot,"if (",CVar,") { DestroyArr((void **)",CVar,",",str(dms),", 1); ",CVar,"=NULL; }");
|
|
StartPoint=3;
|
|
}
|
|
Use_DynamicA=TRUE;
|
|
A=0;
|
|
*ZZ=0;
|
|
for(i=StartPoint; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"[")==0)
|
|
{
|
|
A++;
|
|
i++;
|
|
BC=1;
|
|
while(BC>0)
|
|
{
|
|
if(str_cmp(Stk[i],"[")==0)
|
|
{
|
|
BC++;
|
|
strcat(ZZ,Stk[i]);
|
|
}
|
|
else
|
|
{
|
|
if(str_cmp(Stk[i],"]")==0)
|
|
{
|
|
BC--;
|
|
if(BC==0&&i<Ndx)
|
|
{
|
|
strcat(ZZ,",");
|
|
}
|
|
if(BC)
|
|
{
|
|
strcat(ZZ,Stk[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
strcat(ZZ,Stk[i]);
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
i--;
|
|
}
|
|
}
|
|
strcpy(ZZ,Clean(ZZ));
|
|
if(vt==vt_STRLIT||vt==vt_DECFUNC||vt==vt_NUMBER||(vt==vt_VOID&&inchr(Stk[Ndx],"*")==0))
|
|
{
|
|
Abort(join(2,Stk[Ndx]," is not a valid type"));
|
|
}
|
|
if(vt==vt_STRVAR)
|
|
{
|
|
strcpy(SOF,"char");
|
|
A++;
|
|
strcat(ZZ,",65535");
|
|
}
|
|
if(A!=dms)
|
|
{
|
|
Abort(join(6,"Mismatch in dimensions for ",CVar,", orignally ",str(dms)," found ",str(A)));
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%d%s%s%s\n",Scoot,CVar,"= (",SOF,stringx(dms,42),")CreateArr (",CVar,",sizeof(",SOF,"),",trim(str(IsPreserve)),",",(int)dms,",",ZZ,");");
|
|
break;
|
|
}
|
|
if(str_cmp(Stk[3],"*")==0 || (IsPreserve&&str_cmp(Stk[4],"*")==0))
|
|
{
|
|
if(IsPreserve)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s",Scoot,CVar,"=(char*)realloc(",CVar,",256+");
|
|
i=5;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"free(",CVar,");");
|
|
fprintf(Outfile,"%s%s%s",Scoot,CVar,"=(char*)calloc(256+");
|
|
i=4;
|
|
}
|
|
for(A=i; A<=Ndx; A+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[A]));
|
|
}
|
|
if(IsPreserve)
|
|
{
|
|
fprintf(Outfile,"%s\n",");");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n",",1);");
|
|
}
|
|
break;
|
|
}
|
|
Abort("Invalid REDIM statement");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"dim")==0 || str_cmp(Lookup,"local")==0 || str_cmp(Lookup,"raw")==0 || str_cmp(Lookup,"static")==0 || str_cmp(Lookup,"auto")==0 || str_cmp(Lookup,"register")==0)
|
|
{
|
|
int w=0;
|
|
char UseStatic[2048];
|
|
int IsVolatile=0;
|
|
char IV[2048];
|
|
IsVolatile=iMatchWrd(Stk[2],"volatile");
|
|
if(IsVolatile)
|
|
{
|
|
strcpy(IV,"volatile ");
|
|
}
|
|
else
|
|
{
|
|
*IV=0;
|
|
}
|
|
IsSubOrFuncPtr=SubFuncTest();
|
|
HandleNonsense();
|
|
if(str_cmp(Stk[Ndx],"*")==0)
|
|
{
|
|
PointerFix();
|
|
}
|
|
if(str_cmp(Stk[Ndx],"&")==0)
|
|
{
|
|
*Stk[Ndx--]=0;
|
|
strcat(Stk[Ndx],"&");
|
|
}
|
|
IsRegister=IsAuto=IsDim=IsLocal=IsStatic=IsRaw=FALSE;
|
|
strcpy(Cmd,lcase(Stk[1]));
|
|
for(;;)
|
|
{
|
|
if(str_cmp(Cmd,"dim")==0)
|
|
{
|
|
IsDim=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Cmd,"local")==0)
|
|
{
|
|
IsLocal=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Cmd,"static")==0)
|
|
{
|
|
IsStatic=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Cmd,"raw")==0)
|
|
{
|
|
IsRaw=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Cmd,"auto")==0)
|
|
{
|
|
IsAuto=TRUE;
|
|
break;
|
|
}
|
|
if(str_cmp(Cmd,"register")==0)
|
|
{
|
|
IsRegister=TRUE;
|
|
}
|
|
break;
|
|
}
|
|
if(InTypeDef)
|
|
{
|
|
if(iMatchWrd(Stk[2],"public")||iMatchWrd(Stk[2],"private")||iMatchWrd(Stk[2],"protected"))
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n",LF,lcase(Stk[2]),":");
|
|
break;
|
|
}
|
|
else if(iMatchWrd(Stk[2],"constructor")||iMatchWrd(Stk[2],"destructor"))
|
|
{
|
|
DimSubFunc(0);
|
|
break;
|
|
}
|
|
else if(iMatchWrd(Stk[2],"virtual"))
|
|
{
|
|
*vproc=0;
|
|
if(iMatchWrd(Stk[Ndx-1],"=")&&iMatchWrd(Stk[Ndx],"0"))
|
|
{
|
|
strcpy(vproc, join(2,Stk[Ndx-1],Stk[Ndx]));
|
|
Ndx-=2;
|
|
}
|
|
{int act;
|
|
for(act=3; act<=Ndx; act+=1)
|
|
{
|
|
strcpy(Stk[act-1],Stk[act]);
|
|
}
|
|
}
|
|
Ndx--;
|
|
DimSubFunc(0);
|
|
break;
|
|
}
|
|
}
|
|
if(IsSubOrFuncPtr)
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
Abort("volatile SUB/FUNCTION pointers not supported");
|
|
}
|
|
if(DimSubFunc(0))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
strcpy(CVar,Clean(Stk[2+IsVolatile]));
|
|
ValidVar(CVar);
|
|
VType=DataType(Stk[2+IsVolatile]);
|
|
if(str_cmp(Stk[3+IsVolatile],"*")==0)
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
Abort("volatile dynamic strings not supported");
|
|
}
|
|
DimDynaString(CVar,0,0);
|
|
break;
|
|
}
|
|
int iASoffset=0;
|
|
char sConst[2048];
|
|
int iIsConst;
|
|
if(iMatchWrd(Stk[Ndx-1],"as"))
|
|
{
|
|
iASoffset=Ndx-1;
|
|
}
|
|
if(iMatchWrd(Stk[Ndx-2],"as"))
|
|
{
|
|
iASoffset=Ndx-2;
|
|
}
|
|
if(iASoffset)
|
|
{
|
|
iIsConst=0;
|
|
*sConst=0;
|
|
if(iASoffset==Ndx-2)
|
|
{
|
|
if(iMatchWrd(Stk[Ndx-1],"const"))
|
|
{
|
|
strcpy(sConst,"const");
|
|
iIsConst=1;
|
|
}
|
|
}
|
|
strcpy(Var1,CVar);
|
|
IsPointer=tally(Stk[Ndx],"*");
|
|
*DimType=0;
|
|
*lszTmp=0;
|
|
for(i=2+IsVolatile; i<=iASoffset-1; i+=1)
|
|
{
|
|
strcat(lszTmp,Stk[i]);
|
|
if(i>2+IsVolatile)
|
|
{
|
|
strcat(DimType,Stk[i]);
|
|
}
|
|
}
|
|
strcpy(Var,RemoveStr(Stk[Ndx],"*"));
|
|
GetTypeInfo(Var, &w, &id, &vt);
|
|
if(vt==vt_STRVAR)
|
|
{
|
|
strcpy(Stk[Ndx],"char");
|
|
strcpy(Var,Stk[Ndx]);
|
|
strcat(DimType,"[65535]");
|
|
strcat(lszTmp,"[65535]");
|
|
}
|
|
if(InFunc||InTypeDef)
|
|
{
|
|
if(IsRegister||IsAuto)
|
|
{
|
|
if(IsRegister)
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
Abort("Register volatile not supported");
|
|
}
|
|
if(vt==vt_FILEPTR)
|
|
{
|
|
fprintf(Outfile,"%s%s",Scoot,"register FILE* ");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s",Scoot,"register ",sConst," ",Stk[Ndx]," ");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(vt==vt_FILEPTR)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s",Scoot,"auto ",IV," FILE* ");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s",Scoot,"auto ",IV," ",sConst," ",Stk[Ndx]," ");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(IsRaw==TRUE)
|
|
{
|
|
if(vt==vt_FILEPTR)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s",Scoot,"static ",IV," FILE* ");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s",Scoot,IV,sConst," ",Stk[Ndx]," ");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(InTypeDef)
|
|
{
|
|
*UseStatic=0;
|
|
}
|
|
else
|
|
{
|
|
strcpy(UseStatic,"static ");
|
|
}
|
|
if(vt==vt_STRUCT)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s",Scoot,UseStatic,IV,sConst," ","struct _",Stk[Ndx]," ");
|
|
}
|
|
else
|
|
{
|
|
if(vt==vt_FILEPTR)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s",Scoot,UseStatic,IV,"FILE *");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s",Scoot,UseStatic,IV,sConst," ",Stk[Ndx]," ");
|
|
}
|
|
}
|
|
if(InTypeDef)
|
|
{
|
|
AddTypedefElement(BaseTypeDefsCnt[InTypeDef],vt,CVar,Var,0);
|
|
}
|
|
}
|
|
}
|
|
if(InFunc&&!InTypeDef)
|
|
{
|
|
AddLocal(Var1,vt,id,DimType,IsPointer,0,0,iIsConst);
|
|
}
|
|
fprintf(Outfile,"%s%s\n",Clean(lszTmp),";");
|
|
if(!InTypeDef&&!IsStatic&&!IsRaw&&!IsRegister&&!IsVolatile)
|
|
{
|
|
strcpy(T,Clean(extract(lszTmp,"[")));
|
|
if(IsPointer)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",Clean(Var)," *","));");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",T,"));");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
AddGlobal(Var1,vt,id,DimType,IsPointer,0,3,0,iIsConst);
|
|
}
|
|
else
|
|
{
|
|
AddGlobal(Var1,vt,id,DimType,IsPointer,0,0,0,iIsConst);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(InFunc||InTypeDef)
|
|
{
|
|
*lszTmp=0;
|
|
if(iMatchWrd(Stk[3+IsVolatile],"as"))
|
|
{
|
|
VType=CheckType(Stk[4+IsVolatile]);
|
|
if(VType==vt_CHAR)
|
|
{
|
|
if(str_cmp(Stk[5],"*")==0)
|
|
{
|
|
strcpy(lszTmp, join(3,"[",Stk[6+IsVolatile],"]"));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(i=3+IsVolatile; i<=Ndx; i+=1)
|
|
{
|
|
strcat(lszTmp,Stk[i]);
|
|
}
|
|
strcpy(lszTmp,ltrim(Clean(lszTmp)));
|
|
if(VType==vt_STRVAR)
|
|
{
|
|
if(str_cmp(lszTmp,"[65535]")!=0)
|
|
{
|
|
strcat(lszTmp,"[2048]");
|
|
}
|
|
}
|
|
}
|
|
j=(!InTypeDef BAND !IsStatic BAND !IsRaw BAND !IsRegister);
|
|
if(j)
|
|
{
|
|
strcpy(T,Clean(extract(CVar,"[")));
|
|
}
|
|
for(;;)
|
|
{
|
|
if(VType==vt_STRVAR)
|
|
{
|
|
if(IsRaw)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,IV,"char ",CVar,lszTmp,";");
|
|
}
|
|
else if(IsAuto)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,"auto ",IV,"char ",CVar,lszTmp,";");
|
|
}
|
|
else if(IsRegister)
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
Abort("register volatile not supported");
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Scoot,"register char ",CVar,lszTmp,";");
|
|
}
|
|
else
|
|
{
|
|
if(InTypeDef)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,IV,"char ",CVar,lszTmp,";");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,"static ",IV,"char ",CVar,lszTmp,";");
|
|
}
|
|
}
|
|
if(j&&!IsVolatile)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",T,"));");
|
|
}
|
|
break;
|
|
}
|
|
if(VType>=vt_VarMin&&VType<=vt_VarMax)
|
|
{
|
|
strcpy(ZZ,GetVarTypeName(VType));
|
|
strcpy(ZZ,rpad(ZZ,7));
|
|
if(IsRaw)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,IV,ZZ," ",CVar,lszTmp,";");
|
|
}
|
|
else if(IsAuto)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"auto ",IV,ZZ," ",CVar,lszTmp,";");
|
|
}
|
|
else if(IsRegister)
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
Abort("Regester volatile not supported");
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,"register ",ZZ," ",CVar,lszTmp,";");
|
|
}
|
|
else
|
|
{
|
|
if(InTypeDef)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Scoot,IV,ZZ," ",CVar,lszTmp,";");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"static ",IV,ZZ," ",CVar,lszTmp,";");
|
|
}
|
|
}
|
|
if(j&&!IsVolatile)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"memset(&",T,",0,sizeof(",T,"));");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(InFunc&&!InTypeDef)
|
|
{
|
|
AddLocal(CVar,VType,0,lszTmp,0,0,0);
|
|
}
|
|
if(InTypeDef)
|
|
{
|
|
AddTypedefElement(BaseTypeDefsCnt[InTypeDef],VType,CVar,Var,0);
|
|
}
|
|
break;
|
|
}
|
|
*lszTmp=0;
|
|
for(i=3+IsVolatile; i<=Ndx; i+=1)
|
|
{
|
|
strcat(lszTmp,Stk[i]);
|
|
}
|
|
if(VType==vt_STRVAR&&str_cmp(lszTmp,"")!=0)
|
|
{
|
|
strcat(lszTmp,"[65535]");
|
|
}
|
|
if(IsVolatile)
|
|
{
|
|
AddGlobal(CVar,VType,0,lszTmp,0,0,3,0);
|
|
}
|
|
else
|
|
{
|
|
AddGlobal(CVar,VType,0,lszTmp,0,0,0,0);
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"extern")==0)
|
|
{
|
|
int IsVolatile;
|
|
IsSubOrFuncPtr=SubFuncTest();
|
|
HandleNonsense();
|
|
IsVolatile=iMatchWrd(Stk[2],"volatile");
|
|
strcpy(CVar,Clean(Stk[2+IsVolatile]));
|
|
ValidVar(CVar);
|
|
if(str_cmp(Stk[Ndx],"*")==0)
|
|
{
|
|
PointerFix();
|
|
}
|
|
if(str_cmp(Stk[Ndx],"&")==0)
|
|
{
|
|
*Stk[Ndx--]=0;
|
|
strcat(Stk[Ndx],"&");
|
|
}
|
|
if(str_cmp(Stk[3+IsVolatile],"*")==0)
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
Abort("volatile dynamic strings not supported");
|
|
}
|
|
DimDynaString(CVar,2,0);
|
|
break;
|
|
}
|
|
if(IsSubOrFuncPtr)
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
Abort("volatile SUB/FUNCTION pointers not supported");
|
|
}
|
|
if(DimSubFunc(0))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
strcpy(Var,Clean(Stk[2+IsVolatile]));
|
|
ValidVar(Var);
|
|
IsPointer=0;
|
|
*DimType=0;
|
|
if(iMatchWrd(Stk[Ndx-1],"as"))
|
|
{
|
|
GetTypeInfo(Stk[Ndx], &IsPointer, &id, &vt);
|
|
strcpy(Stk[Ndx],RemoveStr(Stk[Ndx],"*"));
|
|
for(i=3+IsVolatile; i<=Ndx-2; i+=1)
|
|
{
|
|
strcat(DimType,Stk[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
i=3+IsVolatile;
|
|
while(i<=Ndx)
|
|
{
|
|
strcat(DimType,Stk[i]);
|
|
i++;
|
|
}
|
|
vt=DataType(Stk[2+IsVolatile]);
|
|
id=0;
|
|
}
|
|
if(vt==vt_STRVAR)
|
|
{
|
|
strcat(DimType,"[65535]");
|
|
}
|
|
if(IsVolatile)
|
|
{
|
|
AddGlobal(Var,vt,id,DimType,IsPointer,0,4,0);
|
|
}
|
|
else
|
|
{
|
|
AddGlobal(Var,vt,id,DimType,IsPointer,0,1,0);
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"shared")==0 || str_cmp(Lookup,"global")==0)
|
|
{
|
|
int w=0;
|
|
char SOF[2048];
|
|
int IsShared;
|
|
int IsVolatile;
|
|
IsSubOrFuncPtr=SubFuncTest();
|
|
HandleNonsense();
|
|
IsVolatile=iMatchWrd(Stk[2],"volatile");
|
|
strcpy(CVar,Clean(Stk[2+IsVolatile]));
|
|
ValidVar(CVar);
|
|
IsShared=iMatchWrd(Stk[1],"shared");
|
|
if(str_cmp(Stk[Ndx],"*")==0)
|
|
{
|
|
PointerFix();
|
|
}
|
|
if(str_cmp(Stk[Ndx],"&")==0)
|
|
{
|
|
*Stk[Ndx--]=0;
|
|
strcat(Stk[Ndx],"&");
|
|
}
|
|
if(str_cmp(Stk[3+IsVolatile],"*")==0)
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
Abort("volatile dynamic strings not supported");
|
|
}
|
|
DimDynaString(CVar,1,IsShared);
|
|
break;
|
|
}
|
|
if(IsSubOrFuncPtr)
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
Abort("volatile SUB/FUNCTION pointers not supported");
|
|
}
|
|
DimSubFunc(0);
|
|
break;
|
|
}
|
|
if(iMatchWrd(Stk[2],"dynamic"))
|
|
{
|
|
strcpy(CVar,Clean(Stk[3]));
|
|
ValidVar(CVar);
|
|
if(iMatchWrd(Stk[Ndx-1],"as"))
|
|
{
|
|
strcpy(SOF,Stk[Ndx]);
|
|
GetTypeInfo(SOF, &w, &id, &vt);
|
|
if(vt==vt_STRLIT||vt==vt_DECFUNC||vt==vt_NUMBER||(vt==vt_VOID&&inchr(Stk[Ndx],"*")==0))
|
|
{
|
|
Abort(join(2,Stk[Ndx]," is not a valid type"));
|
|
}
|
|
Ndx-=2;
|
|
}
|
|
else
|
|
{
|
|
vt=DataType(Stk[3]);
|
|
id=0;
|
|
strcpy(SOF,GetVarTypeName(vt));
|
|
}
|
|
Use_DynamicA=TRUE;
|
|
*ZZ=0;
|
|
for(i=4; i<=Ndx; i+=1)
|
|
{
|
|
strcat(ZZ,Stk[i]);
|
|
}
|
|
dms=tally(ZZ,"][")+1;
|
|
if(dms>1)
|
|
{
|
|
strcpy(ZZ,replace(ZZ,"][",","));
|
|
}
|
|
strcpy(ZZ,Clean(ZZ));
|
|
RemoveAll(ZZ,"[]");
|
|
if(vt==vt_STRVAR)
|
|
{
|
|
vt=vt_CHAR;
|
|
strcpy(SOF,"char");
|
|
dms++;
|
|
strcat(ZZ,",65535");
|
|
}
|
|
if(Use_GenFree)
|
|
{
|
|
GlobalDynaCnt++;
|
|
strcpy(GlobalDynaStr[GlobalDynaCnt], join(9,"if (",CVar,") { DestroyArr((void **)",CVar,",",str(dms),", 1); ",CVar,"=NULL; }"));
|
|
}
|
|
AddGlobal(CVar,vt,id,"",dms,0,0,0);
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",Scoot,CVar,"= (",SOF,stringx(dms,42),")CreateArr (",CVar,",sizeof(",SOF,"),0,",trim(str(dms)),",",ZZ,");");
|
|
break;
|
|
}
|
|
IsPointer=0;
|
|
strcpy(Var,Clean(Stk[2+IsVolatile]));
|
|
ValidVar(Var);
|
|
if(iMatchWrd(Stk[Ndx-1],"as"))
|
|
{
|
|
if(inchr(Stk[Ndx],"*"))
|
|
{
|
|
IsPointer=tally(Stk[Ndx],"*");
|
|
strcpy(Stk[Ndx],RemoveStr(Stk[Ndx],"*"));
|
|
}
|
|
*DimType=0;
|
|
for(i=3+IsVolatile; i<=Ndx-2; i+=1)
|
|
{
|
|
strcat(DimType,Stk[i]);
|
|
}
|
|
GetTypeInfo(Stk[Ndx], &w, &id, &vt);
|
|
}
|
|
else
|
|
{
|
|
*DimType=0;
|
|
i=3+IsVolatile;
|
|
while(i<=Ndx)
|
|
{
|
|
strcat(DimType,Stk[i]);
|
|
i++;
|
|
}
|
|
vt=DataType(Stk[2+IsVolatile]);
|
|
id=0;
|
|
}
|
|
if(vt==vt_STRVAR)
|
|
{
|
|
strcat(DimType,"[65535]");
|
|
}
|
|
if(IsShared)
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
AddGlobal(Var,vt,id,DimType,IsPointer,0,5,0);
|
|
}
|
|
else
|
|
{
|
|
AddGlobal(Var,vt,id,DimType,IsPointer,0,2,0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(IsVolatile)
|
|
{
|
|
AddGlobal(Var,vt,id,DimType,IsPointer,0,3,0);
|
|
}
|
|
else
|
|
{
|
|
AddGlobal(Var,vt,id,DimType,IsPointer,0,0,0);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"while")==0)
|
|
{
|
|
EmitIfCond("while");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"wend")==0 || str_cmp(Lookup,"endwhile")==0)
|
|
{
|
|
BumpDown();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"}");
|
|
BumpDown();
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"exit")==0)
|
|
{
|
|
if(CaseFlag)
|
|
{
|
|
NoBreak2=TRUE;
|
|
}
|
|
if(iMatchWrd(Stk[2],"sub"))
|
|
{
|
|
if(LocalDynaCnt!=0)
|
|
{
|
|
for(j=1; j<=LocalDynaCnt; j+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,DynaStr[j]);
|
|
}
|
|
}
|
|
if(LocalDynArrCount!=0)
|
|
{
|
|
for(i=1; i<=LocalDynArrCount; i+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,LocalDynArrName[i]);
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s\n",Scoot,"return;");
|
|
break;
|
|
}
|
|
if(iMatchWrd(Stk[2],"function"))
|
|
{
|
|
if(LocalDynaCnt!=0)
|
|
{
|
|
for(j=1; j<=LocalDynaCnt; j+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,DynaStr[j]);
|
|
}
|
|
}
|
|
if(LocalDynArrCount!=0)
|
|
{
|
|
for(i=1; i<=LocalDynArrCount; i+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,LocalDynArrName[i]);
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s\n",Scoot,"return 0;");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"break;");
|
|
}
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"goto")==0)
|
|
{
|
|
if(CaseFlag)
|
|
{
|
|
NoBreak2=TRUE;
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"goto ",ucase(Stk[2]),";");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"print")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,PrintWriteFormat(0));
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"write")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,PrintWriteFormat(1));
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"run")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s",Scoot,"Run (");
|
|
for(A=2; A<=Ndx; A+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[A]));
|
|
}
|
|
fprintf(Outfile,"%s%s\n",Scoot,");");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"color")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s",Scoot,"color (");
|
|
for(A=2; A<=Ndx; A+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[A]));
|
|
}
|
|
fprintf(Outfile,"%s\n",");");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"locate")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s",Scoot,"locate (");
|
|
for(A=2; A<=Ndx; A+=1)
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[A]));
|
|
}
|
|
fprintf(Outfile,"%s\n",");");
|
|
break;
|
|
}
|
|
if(str_cmp(Lookup,"cls")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,"cls();");
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
for(B=1; B<=Ndx; B+=1)
|
|
{
|
|
if(str_cmp(Stk[B],"=")==0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if(B-1==Ndx)
|
|
{
|
|
*lszTmp=0;
|
|
for(Tmp=1; Tmp<=Ndx; Tmp+=1)
|
|
{
|
|
strcat(lszTmp,Clean(Stk[Tmp]));
|
|
}
|
|
strcat(lszTmp,";");
|
|
if(FuncRetnFlag==2)
|
|
{
|
|
fprintf(Outfile,"%s\n",lszTmp);
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,lszTmp);
|
|
}
|
|
if(FuncRetnFlag==2)
|
|
{
|
|
FuncRetnFlag=0;
|
|
*Stk[1]=0;
|
|
if(ZZ)free(ZZ);
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
for(i=2; i<=B-1; i+=1)
|
|
{
|
|
strcat(Stk[1],Stk[i]);
|
|
}
|
|
A=inchr(Stk[1],"*");
|
|
if(A)
|
|
{
|
|
if(!(inchr(Stk[1],"$")&&A>1))
|
|
{
|
|
RemoveAll(Stk[1],"$");
|
|
goto PROCESSNUMERIC;
|
|
}
|
|
}
|
|
static int strtest;
|
|
memset(&strtest,0,sizeof(strtest));
|
|
static int varid;
|
|
memset(&varid,0,sizeof(varid));
|
|
static struct _VarInfo* vi;
|
|
memset(&vi,0,sizeof(VarInfo *));
|
|
static char vr[2048];
|
|
memset(&vr,0,sizeof(vr));
|
|
static int brcnt;
|
|
memset(&brcnt,0,sizeof(brcnt));
|
|
strtest=DataType(Stk[1]);
|
|
if(strtest==vt_INTEGER)
|
|
{
|
|
brcnt=tally(Stk[1],"[");
|
|
strcpy(vr,extract(Stk[1],"["));
|
|
strtest=CheckLocal(vr, &varid);
|
|
if(strtest==vt_UNKNOWN)
|
|
{
|
|
strtest=CheckGlobal(vr, &varid);
|
|
vi= &(GlobalVars[varid]);
|
|
}
|
|
else
|
|
{
|
|
vi= &(LocalVars[varid]);
|
|
}
|
|
if(strtest==vt_CHAR)
|
|
{
|
|
strtest=vt_STRVAR;
|
|
}
|
|
if(strtest==vt_STRVAR)
|
|
{
|
|
if(vi->VarPntr!=0)
|
|
{
|
|
goto PROCESSNUMERIC;
|
|
}
|
|
if(tally(vi->VarDim,"[")==brcnt)
|
|
{
|
|
goto PROCESSNUMERIC;
|
|
}
|
|
if(tally(vi->VarDim,"[")!=brcnt+1)
|
|
{
|
|
goto PROCESSNUMERIC;
|
|
}
|
|
}
|
|
}
|
|
if(strtest==vt_STRVAR)
|
|
{
|
|
if(B+1==Ndx)
|
|
{
|
|
if(str_cmp(Stk[Ndx],DDQ)==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"*",Clean(Stk[1]),"=0;");
|
|
goto STRINGEXIT;
|
|
}
|
|
}
|
|
if(Ndx==3)
|
|
{
|
|
strcpy(Stk[1],Clean(Stk[1]));
|
|
strcpy(Stk[3],Clean(Stk[3]));
|
|
if(str_cmp(Stk[1],"BCX_RetStr")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"BCX_RetStr=BCX_TmpStr(strlen(",Stk[3],"));");
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"strcpy(",Stk[1],",",Stk[3],");");
|
|
goto STRINGEXIT;
|
|
}
|
|
*Arg=0;
|
|
*lszTmp=0;
|
|
j=k=0;
|
|
if(iMatchLft(Stk[3],"$$"))
|
|
{
|
|
HasStorage=TRUE;
|
|
}
|
|
strcpy(Var,Clean(Stk[1]));
|
|
if(str_cmp(Clean(Stk[B+1]),Var)==0)
|
|
{
|
|
k=TRUE;
|
|
}
|
|
for(A=B+1; A<=Ndx; A+=1)
|
|
{
|
|
if(str_cmp(Stk[A],"&")==0 && str_cmp(Stk[A-1],",")!=0 && str_cmp(Stk[A-1],"(")!=0)
|
|
{
|
|
j++;
|
|
strcat(Arg,lszTmp);
|
|
strcpy(lszTmp,",");
|
|
}
|
|
else
|
|
{
|
|
strcat(lszTmp,Clean(Stk[A]));
|
|
}
|
|
}
|
|
if(*lszTmp!=0&&str_cmp(lszTmp,",")!=0)
|
|
{
|
|
strcat(Arg,lszTmp);
|
|
}
|
|
RemoveAll(Var,SPC);
|
|
if(j==0)
|
|
{
|
|
if(str_cmp(Var,"BCX_RetStr")==0)
|
|
{
|
|
if(HasStorage)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"BCX_RetStr=",Arg,";");
|
|
goto STRINGEXIT;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"BCX_RetStr=BCX_TmpStr(strlen(",Arg,"));");
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"strcpy(",Var,",",Arg,");");
|
|
goto STRINGEXIT;
|
|
}
|
|
if(k==TRUE&&j==1)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s\n",Scoot,"strcat(",Arg,");");
|
|
goto STRINGEXIT;
|
|
}
|
|
strcpy(lszTmp,ltrim(str(++j)));
|
|
Use_Join=TRUE;
|
|
if(str_cmp(Var,"BCX_RetStr")==0)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Scoot,"BCX_RetStr=join(",lszTmp,",",Arg,");");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s\n",Scoot,"strcpy(",Var,", join(",lszTmp,",",Arg,"));");
|
|
}
|
|
|
|
STRINGEXIT:;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
|
|
PROCESSNUMERIC:;
|
|
for(i=2; i<=B; i+=1)
|
|
{
|
|
*Stk[i]=0;
|
|
}
|
|
strcpy(Stk[B],"=");
|
|
if(str_cmp(Stk[B+1],Stk[1])==0 && Ndx==5)
|
|
{
|
|
if(Inset(Stk[B+2],"+-*/")&&str_cmp(Stk[B+3],">")!=0)
|
|
{
|
|
strcpy(Stk[B], join(2,Stk[B+2],Stk[B]));
|
|
*Stk[B+1]=0;
|
|
*Stk[B+2]=0;
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s",Scoot,Clean(Stk[1]));
|
|
for(A=2; A<=Ndx; A+=1)
|
|
{
|
|
if(str_cmp(Stk[A],"!")==0)
|
|
{
|
|
fprintf(Outfile,"%s","!");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[A]));
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n",";");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(FuncRetnFlag==1)
|
|
{
|
|
if(LocalDynaCnt!=0)
|
|
{
|
|
for(j=1; j<=LocalDynaCnt; j+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s\n",Scoot,DynaStr[j]);
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s\n",Scoot,"return BCX_RetStr;");
|
|
}
|
|
if(ZZ)free(ZZ);
|
|
}
|
|
|
|
|
|
void Abort (char *Z)
|
|
{
|
|
int i=0;
|
|
int j=0;
|
|
int k=0;
|
|
int varnum=0;
|
|
char t[2048];
|
|
char frmt[2048];
|
|
*WarnMsg=0;
|
|
if(str_cmp(left(AbortSrc,11),"$BCXVERSION")==0)
|
|
{
|
|
strcat(WarnMsg,Z);
|
|
}
|
|
else
|
|
{
|
|
strcpy(WarnMsg, join(7,WarnMsg,Z," at line",str(ModuleLineNos[ModuleNdx])," in Module: ",trim(Modules[ModuleNdx]),CRLF));
|
|
strcpy(WarnMsg, join(3,WarnMsg,"Original line",CRLF));
|
|
strcpy(WarnMsg, join(3,WarnMsg,AbortSrc,CRLF));
|
|
strcpy(WarnMsg, join(3,WarnMsg,"==============",CRLF));
|
|
strcpy(WarnMsg, join(3,WarnMsg,"Current Tokens",CRLF));
|
|
strcpy(WarnMsg, join(3,WarnMsg,"==============",CRLF));
|
|
for(k=1; k<=Ndx; k+=1)
|
|
{
|
|
j=strlen(Stk[k]);
|
|
if(j<40)
|
|
{
|
|
j=40-j;
|
|
}
|
|
else
|
|
{
|
|
j=8-imod(j,8);
|
|
}
|
|
strcpy(frmt,lpad(str(k),3));
|
|
strcpy(WarnMsg, join(6,WarnMsg,frmt," ",Stk[k],stringx(j,32),CRLF));
|
|
strcpy(t,Clean(Stk[k]));
|
|
i=CheckLocal(t, &varnum);
|
|
if(i!=vt_UNKNOWN)
|
|
{
|
|
strcpy(WarnMsg, join(3,WarnMsg,"is a LOCAL defined at line",str(LocalVars[varnum].VarLine)));
|
|
strcpy(WarnMsg, join(4,WarnMsg," in Module: ",LocalVars[varnum].VarModule,CRLF));
|
|
}
|
|
else
|
|
{
|
|
i=CheckGlobal(t, &varnum);
|
|
if(i!=vt_UNKNOWN)
|
|
{
|
|
strcpy(WarnMsg, join(3,WarnMsg,"is a GLOBAL defined at line",str(GlobalVars[varnum].VarLine)));
|
|
strcpy(WarnMsg, join(4,WarnMsg," in Module: ",GlobalVars[varnum].VarModule,CRLF));
|
|
strcpy(WarnMsg, join(5,WarnMsg," ",Stk[k],GlobalVars[varnum].VarDim," as "));
|
|
if(GlobalVars[varnum].VarDef)
|
|
{
|
|
strcpy(WarnMsg, join(3,WarnMsg,trim(TypeDefs[GlobalVars[varnum].VarDef].VarName),CRLF));
|
|
}
|
|
else
|
|
{
|
|
strcpy(WarnMsg, join(3,WarnMsg,trim(GetVarTypeName(GlobalVars[varnum].VarType)),CRLF));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(Stk[k][0]==34)
|
|
{
|
|
strcpy(WarnMsg, join(3,WarnMsg,"is a STRING LITERAL",CRLF));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
strcpy(WarnMsg, join(3,WarnMsg,"===============",CRLF));
|
|
strcpy(WarnMsg, join(3,WarnMsg,"Original Tokens",CRLF));
|
|
strcpy(WarnMsg, join(3,WarnMsg,"===============",CRLF));
|
|
XParse(AbortSrc);
|
|
for(k=1; k<=Ndx; k+=1)
|
|
{
|
|
j=strlen(Stk[k]);
|
|
if(j<40)
|
|
{
|
|
j=40-j;
|
|
}
|
|
else
|
|
{
|
|
j=8-imod(j,8);
|
|
}
|
|
strcpy(frmt,lpad(str(k),3));
|
|
strcpy(WarnMsg, join(6,WarnMsg,frmt," ",Stk[k],stringx(j,32),CRLF));
|
|
strcpy(t,Clean(Stk[k]));
|
|
i=CheckLocal(t, &varnum);
|
|
if(i!=vt_UNKNOWN)
|
|
{
|
|
strcpy(WarnMsg, join(3,WarnMsg,"is a LOCAL defined at line",str(LocalVars[varnum].VarLine)));
|
|
strcpy(WarnMsg, join(4,WarnMsg," in Module: ",LocalVars[varnum].VarModule,CRLF));
|
|
}
|
|
else
|
|
{
|
|
i=CheckGlobal(t, &varnum);
|
|
if(i!=vt_UNKNOWN)
|
|
{
|
|
strcpy(WarnMsg, join(3,WarnMsg,"is a GLOBAL defined at line",str(GlobalVars[varnum].VarLine)));
|
|
strcpy(WarnMsg, join(4,WarnMsg," in Module: ",GlobalVars[varnum].VarModule,CRLF));
|
|
strcpy(WarnMsg, join(5,WarnMsg," ",Stk[k],GlobalVars[varnum].VarDim," as "));
|
|
if(GlobalVars[varnum].VarDef)
|
|
{
|
|
strcpy(WarnMsg, join(3,WarnMsg,TypeDefs[GlobalVars[varnum].VarDef].VarName,CRLF));
|
|
}
|
|
else
|
|
{
|
|
strcpy(WarnMsg, join(3,WarnMsg,GetVarTypeName(GlobalVars[varnum].VarType),CRLF));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(Stk[k][0]==34)
|
|
{
|
|
strcpy(WarnMsg, join(3,WarnMsg,"is a string literal",CRLF));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
strcat(WarnMsg,CRLF);
|
|
CloseAll();
|
|
remove (ovrFile);
|
|
remove (FileOut);
|
|
remove (prcFile);
|
|
remove (udtFile);
|
|
remove (hdrFile);
|
|
remove (cstFile);
|
|
remove (datFile);
|
|
remove (setFile);
|
|
remove (enuFile);
|
|
remove ("$t$e$m$p");
|
|
if(ErrFile)
|
|
{
|
|
if((fpErr=fopen(FileErr,"a"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",FileErr);
|
|
exit(1);
|
|
}
|
|
fprintf(fpErr,"%s%s%d%s%s\n",Z," at line",(int)ModuleLineNos[ModuleNdx]," in Module: ",trim(Modules[ModuleNdx]));
|
|
if(fpErr)
|
|
{
|
|
fclose(fpErr);
|
|
fpErr=NULL;
|
|
}
|
|
}
|
|
printf("%s%s%s%s%s\n","Error!",CRLF,FileIn,CRLF,WarnMsg);
|
|
FreeGlobals();
|
|
fflush(stdout);
|
|
exit(1);
|
|
}
|
|
|
|
|
|
void BumpDown (void)
|
|
{
|
|
Indent--;
|
|
Indent--;
|
|
if(Indent<0)
|
|
{
|
|
Indent=0;
|
|
}
|
|
strcpy(Scoot,space(Indent));
|
|
}
|
|
|
|
|
|
void BumpUp (void)
|
|
{
|
|
if(Indent<0)
|
|
{
|
|
Indent=0;
|
|
}
|
|
Indent++;
|
|
Indent++;
|
|
strcpy(Scoot,space(Indent));
|
|
}
|
|
|
|
|
|
int BraceCount (char *Arg)
|
|
{
|
|
char* p;
|
|
int braces;
|
|
p=Arg;
|
|
braces=0;
|
|
while(*p)
|
|
{
|
|
if(*p==c_DblQt)
|
|
{
|
|
p++;
|
|
while(*p!=c_DblQt)
|
|
{
|
|
if(*p==0)
|
|
{
|
|
return braces;
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
if(*p==125)
|
|
{
|
|
braces--;
|
|
}
|
|
if(*p==123)
|
|
{
|
|
braces++;
|
|
}
|
|
p++;
|
|
}
|
|
return braces;
|
|
}
|
|
|
|
|
|
char* BracketHandler (char *Src, int l)
|
|
{
|
|
char* s;
|
|
s=Src;
|
|
for(;;)
|
|
{
|
|
if(l==0)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(*s==0)
|
|
{
|
|
break;
|
|
}
|
|
if(*s==c_DblQt)
|
|
{
|
|
s++;
|
|
while(*s!=c_DblQt)
|
|
{
|
|
if(*s==0)
|
|
{
|
|
break;
|
|
}
|
|
s++;
|
|
}
|
|
}
|
|
if(*s==c_LtBkt)
|
|
{
|
|
s++;
|
|
s=BracketHandler(s,1);
|
|
}
|
|
if(*s==c_LPar)
|
|
{
|
|
s++;
|
|
s=BracketHandler(s,2);
|
|
}
|
|
s++;
|
|
}
|
|
break;
|
|
}
|
|
if(l==1)
|
|
{
|
|
while(*s!=c_RtBkt)
|
|
{
|
|
if(*s==c_DblQt)
|
|
{
|
|
s++;
|
|
while(*s!=c_DblQt)
|
|
{
|
|
if(*s==0)
|
|
{
|
|
break;
|
|
}
|
|
s++;
|
|
}
|
|
}
|
|
if(*s==c_LtBkt)
|
|
{
|
|
s++;
|
|
s=BracketHandler(s,1);
|
|
}
|
|
if(*s==c_LPar)
|
|
{
|
|
s++;
|
|
s=BracketHandler(s,2);
|
|
}
|
|
if(*s==c_Komma)
|
|
{
|
|
*s=1;
|
|
}
|
|
if(*s==0)
|
|
{
|
|
break;
|
|
}
|
|
s++;
|
|
}
|
|
break;
|
|
}
|
|
if(l==2)
|
|
{
|
|
while(*s!=c_RPar)
|
|
{
|
|
if(*s==c_DblQt)
|
|
{
|
|
s++;
|
|
while(*s!=c_DblQt)
|
|
{
|
|
if(*s==0)
|
|
{
|
|
break;
|
|
}
|
|
s++;
|
|
}
|
|
}
|
|
if(*s==c_LtBkt)
|
|
{
|
|
s++;
|
|
s=BracketHandler(s,1);
|
|
}
|
|
if(*s==c_LPar)
|
|
{
|
|
s++;
|
|
s=BracketHandler(s,2);
|
|
}
|
|
if(*s==0)
|
|
{
|
|
break;
|
|
}
|
|
s++;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(l==0)
|
|
{
|
|
strcpy(Src,replace(Src,chr(1),"]["));
|
|
return Src;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
void Push (char *Z)
|
|
{
|
|
strcpy(CaseStk[++Pusher],Z);
|
|
}
|
|
|
|
|
|
void Pop (char *Z)
|
|
{
|
|
strcpy(Z,CaseStk[--Pusher]);
|
|
}
|
|
|
|
|
|
void EmitEpilog (void)
|
|
{
|
|
if(NoMain+EndOfProgram==0)
|
|
{
|
|
fprintf(Outfile,"%s\n","return 0; // End of main program");
|
|
BumpDown();
|
|
fprintf(Outfile,"%s\n","}");
|
|
fflush(Outfile);
|
|
}
|
|
}
|
|
|
|
|
|
void EmitProlog (void)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","int main(int argc, char *argv[])");
|
|
fflush(Outfile);
|
|
}
|
|
|
|
|
|
void DeclareVariables (void)
|
|
{
|
|
int i;
|
|
int A;
|
|
char P[2048];
|
|
char VarName[2048];
|
|
char VarDim[2048];
|
|
char Storage[2048];
|
|
if((FP1=fopen(FileOut,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",FileOut);
|
|
exit(1);
|
|
}
|
|
if((Outfile=fopen("$t$e$m$p","w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n","$t$e$m$p");
|
|
exit(1);
|
|
}
|
|
if((FP3=fopen(cstFile,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",cstFile);
|
|
exit(1);
|
|
}
|
|
if(lof(cstFile)>0)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s%s\n","// ",BCX_STR_USR_CONST);
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
while(!EoF(FP3))
|
|
{
|
|
Z[0]=0;
|
|
AR_fgets_retval=fgets(Z,65535,FP3);
|
|
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
|
|
fprintf(Outfile,"%s\n",ltrim(Z));
|
|
}
|
|
if(FP3)
|
|
{
|
|
fclose(FP3);
|
|
FP3=NULL;
|
|
}
|
|
if(Use_EnumFile)
|
|
{
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","// User's GLOBAL ENUM blocks");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
if((FP8=fopen(enuFile,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",enuFile);
|
|
exit(1);
|
|
}
|
|
while(!EoF(FP8))
|
|
{
|
|
Z[0]=0;
|
|
AR_fgets_retval=fgets(Z,65535,FP8);
|
|
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
|
|
fprintf(Outfile,"%s\n",Z);
|
|
}
|
|
if(FP8)
|
|
{
|
|
fclose(FP8);
|
|
FP8=NULL;
|
|
}
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
if((FP3=fopen(udtFile,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",udtFile);
|
|
exit(1);
|
|
}
|
|
if(lof(udtFile)>0)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s%s\n","// ",BCX_STR_USR_TYPES);
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
while(!EoF(FP3))
|
|
{
|
|
Z[0]=0;
|
|
AR_fgets_retval=fgets(Z,65535,FP3);
|
|
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
|
|
fprintf(Outfile,"%s%s\n",Scoot,Z);
|
|
}
|
|
}
|
|
if(FP3)
|
|
{
|
|
fclose(FP3);
|
|
FP3=NULL;
|
|
}
|
|
if(HFileCnt>0)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","// User Include Files");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
A=0;
|
|
while(A<HFileCnt)
|
|
{
|
|
fprintf(Outfile,"%s\n",HFiles[A]);
|
|
A++;
|
|
}
|
|
fprintf(Outfile,"%s\n","#include <term.h>");
|
|
}
|
|
if(Use_SingleFile==TRUE)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s%s\n","// ",BCX_STR_SYS_VARS);
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
if(Use_RegEx)
|
|
{
|
|
fprintf(Outfile,"%s\n","typedef struct _REGEX");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int count;");
|
|
fprintf(Outfile,"%s\n"," regmatch_t matches[1024];");
|
|
fprintf(Outfile,"%s\n"," PCHAR results[1024];");
|
|
fprintf(Outfile,"%s\n","}REGEX, *LPREGEX;\n");
|
|
}
|
|
if(Use_Time)
|
|
{
|
|
fprintf(Outfile,"%s\n","enum TIME_OPTIONS");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," TIME,");
|
|
fprintf(Outfile,"%s\n"," HOUR,");
|
|
fprintf(Outfile,"%s\n"," MINUTE,");
|
|
fprintf(Outfile,"%s\n"," SECOND,");
|
|
fprintf(Outfile,"%s\n"," APM,");
|
|
fprintf(Outfile,"%s\n"," YEAR,");
|
|
fprintf(Outfile,"%s\n"," MONTH,");
|
|
fprintf(Outfile,"%s\n"," DAY,");
|
|
fprintf(Outfile,"%s\n"," DAYNAME,");
|
|
fprintf(Outfile,"%s\n"," WEEKDAY,");
|
|
fprintf(Outfile,"%s\n"," YEARDAY,");
|
|
fprintf(Outfile,"%s\n"," WEEKNUMBER,");
|
|
fprintf(Outfile,"%s\n"," DATE,");
|
|
fprintf(Outfile,"%s\n"," FULLDATE");
|
|
fprintf(Outfile,"%s\n"," };\n");
|
|
}
|
|
if(Use_Findfirst||Use_Findnext)
|
|
{
|
|
fprintf(Outfile,"%s\n","typedef struct _FILE_FIND_DATA");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," DWORD dwFileAttributes;");
|
|
fprintf(Outfile,"%s\n"," DWORD ftCreationTime;");
|
|
fprintf(Outfile,"%s\n"," DWORD ftLastAccessTime;");
|
|
fprintf(Outfile,"%s\n"," DWORD ftLastWriteTime;");
|
|
fprintf(Outfile,"%s\n"," DWORD nFileSizeHigh;");
|
|
fprintf(Outfile,"%s\n"," DWORD nFileSizeLow;");
|
|
fprintf(Outfile,"%s\n"," char cFileSpec[MAX_PATH];");
|
|
fprintf(Outfile,"%s\n"," char cFileName[MAX_PATH];");
|
|
fprintf(Outfile,"%s\n"," char path[MAX_PATH];");
|
|
fprintf(Outfile,"%s\n"," DIR *FileHandle;");
|
|
fprintf(Outfile,"%s\n","}FILE_FIND_DATA, *LPFILE_FIND_DATA;\n");
|
|
}
|
|
if(Use_Ldouble)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define LDOUBLE long double");
|
|
}
|
|
if(Use_Idxqsort)
|
|
{
|
|
fprintf(Outfile,"%s\n","char*** pppStr;");
|
|
}
|
|
if(Use_Idxqsort||Use_IdxqsortSt||Use_PtrqsortSt)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Key;");
|
|
}
|
|
if(Use_IdxqsortSt)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* cmp1;");
|
|
fprintf(Outfile,"%s\n","int StructSize;");
|
|
}
|
|
if(Use_PtrqsortSt)
|
|
{
|
|
fprintf(Outfile,"%s\n","int OffSet;");
|
|
}
|
|
if(Use_NUL)
|
|
{
|
|
fprintf(Outfile,"%s\n","char NUL [1]={0}; // Null");
|
|
}
|
|
if(Use_BEL)
|
|
{
|
|
fprintf(Outfile,"%s\n","char BEL [2]={7,0}; // Bell");
|
|
}
|
|
if(Use_BS)
|
|
{
|
|
fprintf(Outfile,"%s\n","char BS [2]={8,0}; // Back Space");
|
|
}
|
|
if(Use_TAB)
|
|
{
|
|
fprintf(Outfile,"%s\n","char TAB [2]={9,0}; // Horz Tab");
|
|
}
|
|
if(Use_LF)
|
|
{
|
|
fprintf(Outfile,"%s\n","char LF [2]={10,0}; // Line Feed");
|
|
}
|
|
if(Use_VT)
|
|
{
|
|
fprintf(Outfile,"%s\n","char VT [2]={11,0}; // Vert Tab");
|
|
}
|
|
if(Use_FF)
|
|
{
|
|
fprintf(Outfile,"%s\n","char FF [2]={12,0}; // Form Feed");
|
|
}
|
|
if(Use_CR)
|
|
{
|
|
fprintf(Outfile,"%s\n","char CR [2]={13,0}; // Carr Rtn");
|
|
}
|
|
if(Use_EOF)
|
|
{
|
|
fprintf(Outfile,"%s\n","char EF [2]={26,0}; // End-of-File");
|
|
}
|
|
if(Use_ESC)
|
|
{
|
|
fprintf(Outfile,"%s\n","char ESC [2]={27,0}; // Escape");
|
|
}
|
|
if(Use_SPC)
|
|
{
|
|
fprintf(Outfile,"%s\n","char SPC [2]={32,0}; // Space");
|
|
}
|
|
if(Use_DQ)
|
|
{
|
|
fprintf(Outfile,"%s\n","char DQ [2]={34,0}; // Double-Quote");
|
|
}
|
|
if(Use_DDQ)
|
|
{
|
|
fprintf(Outfile,"%s\n","char DDQ [3]={34,34,0}; // Double-Double-Quote");
|
|
}
|
|
if(Use_Crlf)
|
|
{
|
|
fprintf(Outfile,"%s\n","char CRLF[3]={13,10,0}; // Carr Rtn & Line Feed");
|
|
}
|
|
if(Use_Console)
|
|
{
|
|
fprintf(Outfile,"%s\n","int color_fg = 7;");
|
|
fprintf(Outfile,"%s\n","int color_bg = 0;");
|
|
}
|
|
if(Use_Lineinput)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *AR_fgets_retval;");
|
|
}
|
|
if(Use_Scan)
|
|
{
|
|
fprintf(Outfile,"%s\n","int ScanError;");
|
|
}
|
|
if(Use_Inputbuffer==TRUE)
|
|
{
|
|
fprintf(Outfile,"%s\n","char InputBuffer[65535];");
|
|
}
|
|
if(Use_Findfirst||Use_Findnext)
|
|
{
|
|
fprintf(Outfile,"%s\n","FILE_FIND_DATA FindData;");
|
|
}
|
|
if(Use_Gosub)
|
|
{
|
|
fprintf(Outfile,"%s\n","jmp_buf GosubStack[32];");
|
|
fprintf(Outfile,"%s\n","int GosubNdx;");
|
|
}
|
|
if(Use_Dynacall)
|
|
{
|
|
fprintf(Outfile,"%s\n","HINSTANCE BCX_DllStore[256];");
|
|
}
|
|
}
|
|
if(GlobalVarCnt)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s%s\n","// ",BCX_STR_USR_VARS);
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
for(i=1; i<=GlobalVarCnt; i+=1)
|
|
{
|
|
if(GlobalVars[i].VarEmitFlag)
|
|
{
|
|
continue;
|
|
}
|
|
if(str_cmp("",GlobalVars[i].VarDim)==0 && GlobalVars[i].VarCondLevel==0)
|
|
{
|
|
*P=0;
|
|
if(GlobalVars[i].VarPntr)
|
|
{
|
|
strcpy(P,stringx(GlobalVars[i].VarPntr,42));
|
|
}
|
|
A=GlobalVars[i].VarType;
|
|
if(GlobalVars[i].VarSF)
|
|
{
|
|
strcpy(VarName, join(3,"(*",GlobalVars[i].VarName,")"));
|
|
}
|
|
else
|
|
{
|
|
strcpy(VarName,GlobalVars[i].VarName);
|
|
}
|
|
strcpy(Storage, join(2,VarStorage[GlobalVars[i].VarExtn],VarConst[GlobalVars[i].VarConstant]));
|
|
strcpy(VarDim,GlobalVars[i].VarDim);
|
|
PrintGlobal(A,i,Storage,P,VarName,VarDim);
|
|
}
|
|
}
|
|
for(i=1; i<=GlobalVarCnt; i+=1)
|
|
{
|
|
if(GlobalVars[i].VarEmitFlag)
|
|
{
|
|
continue;
|
|
}
|
|
if(str_cmp("",GlobalVars[i].VarDim)!=0 && GlobalVars[i].VarCondLevel==0)
|
|
{
|
|
if(instr_b(GlobalVars[i].VarDim,"{")==0)
|
|
{
|
|
*P=0;
|
|
if(GlobalVars[i].VarPntr)
|
|
{
|
|
strcpy(P,stringx(GlobalVars[i].VarPntr,42));
|
|
}
|
|
A=GlobalVars[i].VarType;
|
|
if(GlobalVars[i].VarSF)
|
|
{
|
|
strcpy(VarName, join(4,"(*",GlobalVars[i].VarName,extract(GlobalVars[i].VarDim,"("),")"));
|
|
strcpy(VarDim,mid(GlobalVars[i].VarDim,instr_b(GlobalVars[i].VarDim,"(")));
|
|
}
|
|
else
|
|
{
|
|
strcpy(VarName,GlobalVars[i].VarName);
|
|
strcpy(VarDim,GlobalVars[i].VarDim);
|
|
}
|
|
strcpy(Storage, join(2,VarStorage[GlobalVars[i].VarExtn],VarConst[GlobalVars[i].VarConstant]));
|
|
PrintGlobal(A,i,Storage,P,VarName,VarDim);
|
|
}
|
|
}
|
|
}
|
|
char LastDef[2048];
|
|
int LastLevel;
|
|
*LastDef=0;
|
|
LastLevel=1;
|
|
for(i=1; i<=GlobalVarCnt; i+=1)
|
|
{
|
|
if(GlobalVars[i].VarEmitFlag)
|
|
{
|
|
continue;
|
|
}
|
|
if(GlobalVars[i].VarCondLevel)
|
|
{
|
|
if(LastDef[0]==0)
|
|
{
|
|
strcpy(LastDef,GlobalVars[i].VarCondDef);
|
|
LastLevel=GlobalVars[i].VarCondLevel;
|
|
fprintf(Outfile,"%s\n",LastDef);
|
|
}
|
|
if(str_cmp(LastDef,GlobalVars[i].VarCondDef)!=0)
|
|
{
|
|
if(str_cmp(GlobalVars[i].VarCondDef,"#else")==0)
|
|
{
|
|
while(LastLevel>GlobalVars[i].VarCondLevel)
|
|
{
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
LastLevel--;
|
|
}
|
|
fprintf(Outfile,"%s\n","#else");
|
|
strcpy(LastDef,GlobalVars[i].VarCondDef);
|
|
}
|
|
else
|
|
{
|
|
while(LastLevel>=GlobalVars[i].VarCondLevel)
|
|
{
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
LastLevel--;
|
|
}
|
|
strcpy(LastDef,GlobalVars[i].VarCondDef);
|
|
LastLevel=GlobalVars[i].VarCondLevel;
|
|
fprintf(Outfile,"%s\n",LastDef);
|
|
}
|
|
}
|
|
*P=0;
|
|
if(GlobalVars[i].VarPntr)
|
|
{
|
|
strcpy(P,stringx(GlobalVars[i].VarPntr,42));
|
|
}
|
|
A=GlobalVars[i].VarType;
|
|
if(GlobalVars[i].VarSF)
|
|
{
|
|
strcpy(VarName, join(3,"(*",GlobalVars[i].VarName,")"));
|
|
}
|
|
else
|
|
{
|
|
strcpy(VarName,GlobalVars[i].VarName);
|
|
}
|
|
strcpy(VarDim,GlobalVars[i].VarDim);
|
|
strcpy(Storage, join(2,VarStorage[GlobalVars[i].VarExtn],VarConst[GlobalVars[i].VarConstant]));
|
|
PrintGlobal(A,i,Storage,P,VarName,VarDim);
|
|
}
|
|
}
|
|
if(*LastDef)
|
|
{
|
|
while(LastLevel)
|
|
{
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
LastLevel--;
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n","");
|
|
if(DllCnt)
|
|
{
|
|
int i;
|
|
char AR_DllName[2048];
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// **********[ DLL Declarations ]**********");
|
|
fprintf(Outfile,"%s\n","");
|
|
for(i=0; i<=LoadLibsCnt-1; i+=1)
|
|
{
|
|
if(inchr(Loadlibs[i],"-"))
|
|
{
|
|
strcpy(AR_DllName,extract(Loadlibs[i],"-"));
|
|
}
|
|
else if(inchr(Loadlibs[i],"."))
|
|
{
|
|
strcpy(AR_DllName,extract(Loadlibs[i],"."));
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s%s\n","void *H_",ucase(AR_DllName)," = dlopen(",enc(Loadlibs[i]),", RTLD_LAZY);");
|
|
}
|
|
for(i=1; i<=DllCnt; i+=1)
|
|
{
|
|
fprintf(Outfile,"%s\n",DllDecl[i]);
|
|
}
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// ****************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
if((FP5=fopen(datFile,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",datFile);
|
|
exit(1);
|
|
}
|
|
if(lof(datFile)>0)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","// User Data Statements");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","char * DATA [] =");
|
|
fprintf(Outfile,"%s\n","{");
|
|
while(!EoF(FP5))
|
|
{
|
|
Z[0]=0;
|
|
AR_fgets_retval=fgets(Z,65535,FP5);
|
|
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
|
|
fprintf(Outfile,"%s\n",Z);
|
|
}
|
|
fprintf(Outfile,"%s\n","};");
|
|
}
|
|
if(FP5)
|
|
{
|
|
fclose(FP5);
|
|
FP5=NULL;
|
|
}
|
|
while(!EoF(FP1))
|
|
{
|
|
Z[0]=0;
|
|
AR_fgets_retval=fgets(Z,65535,FP1);
|
|
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
|
|
fprintf(Outfile,"%s\n",Z);
|
|
}
|
|
CloseAll();
|
|
remove (FileOut);
|
|
rename ("$t$e$m$p",FileOut);
|
|
}
|
|
|
|
|
|
int GetNumArgs (int Strt,int* NdxPos)
|
|
{
|
|
int CountR=0;
|
|
int CountS=0;
|
|
int i;
|
|
int j=0;
|
|
int k=1;
|
|
for(i=Strt; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],"(")==0)
|
|
{
|
|
CountR++;
|
|
k++;
|
|
}
|
|
else if(str_cmp(Stk[i],")")==0)
|
|
{
|
|
CountR--;
|
|
k--;
|
|
if(k==0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else if(str_cmp(Stk[i],"[")==0)
|
|
{
|
|
CountS++;
|
|
}
|
|
else if(str_cmp(Stk[i],"]")==0)
|
|
{
|
|
CountS--;
|
|
}
|
|
else if(str_cmp(Stk[i],",")==0 && CountR==0&&CountS==0)
|
|
{
|
|
j++;
|
|
if(NdxPos)
|
|
{
|
|
*NdxPos=i;
|
|
}
|
|
}
|
|
}
|
|
return j;
|
|
}
|
|
|
|
|
|
void GetVarCode (VARCODE* varcode)
|
|
{
|
|
char CB[2048];
|
|
char PT[2048];
|
|
char PTH[2048];
|
|
char VAR[2048];
|
|
int vn;
|
|
char RF[2048];
|
|
if(varcode->Method==mt_Opts3)
|
|
{
|
|
strcat(varcode->Proto,varcode->Token);
|
|
if(str_cmp(varcode->Token,",")==0)
|
|
{
|
|
strcat(varcode->Header,varcode->Token);
|
|
}
|
|
return;
|
|
}
|
|
if(varcode->Method==mt_FuncSubx1)
|
|
{
|
|
strcpy(varcode->Proto, join(3,varcode->Proto,varcode->AsToken,"(*)("));
|
|
strcpy(varcode->Header, join(5,varcode->Header,varcode->AsToken," (*",varcode->Token,")("));
|
|
return;
|
|
}
|
|
if(varcode->Method==mt_FuncSubx2)
|
|
{
|
|
strcat(varcode->Proto,varcode->AsToken);
|
|
strcpy(varcode->Header, join(4,varcode->Header,varcode->AsToken," ",varcode->Token));
|
|
return;
|
|
}
|
|
if(IsCallBack)
|
|
{
|
|
strcpy(CB,"CALLBACK ");
|
|
}
|
|
else
|
|
{
|
|
*CB=0;
|
|
}
|
|
if(inchr(varcode->Token,"*")||inchr(varcode->AsToken,"*")||varcode->IsPtrFlag)
|
|
{
|
|
RemoveAll(varcode->Token,"*");
|
|
RemoveAll(varcode->AsToken,"*");
|
|
strcpy(PT, join(2,stringx(varcode->IsPtrFlag,42)," "));
|
|
strcpy(PTH,PT);
|
|
}
|
|
else
|
|
{
|
|
strcpy(PTH," ");
|
|
*PT=0;
|
|
}
|
|
if(inchr(varcode->Token,"&"))
|
|
{
|
|
strcpy(RF," &");
|
|
}
|
|
else
|
|
{
|
|
*RF=0;
|
|
}
|
|
vn=varcode->VarNo;
|
|
strcpy(VAR,GetVarTypeName(vn));
|
|
for(;;)
|
|
{
|
|
if(vn==vt_STRVAR)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(varcode->Method==mt_ProcessSetCommand)
|
|
{
|
|
strcpy(varcode->StaticOut, join(2,"static char ",Clean(varcode->Token)));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_FuncSubDecC_Dec)
|
|
{
|
|
strcpy(varcode->Functype, join(2,"char * ",CB));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_FuncSubDecC_Dec2)
|
|
{
|
|
if(!inchr(varcode->Token,"["))
|
|
{
|
|
strcpy(varcode->Header, join(4,varcode->Header,"char *",Clean(varcode->Token),", "));
|
|
strcat(varcode->Proto,"char *, ");
|
|
}
|
|
else
|
|
{
|
|
strcpy(varcode->Header, join(4,varcode->Header,"char ",RemoveStr(Clean(varcode->Token),"*"),", "));
|
|
strcat(varcode->Proto,"char [][65535], ");
|
|
}
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_Opts)
|
|
{
|
|
strcpy(varcode->Functype,"char *");
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_Opts2)
|
|
{
|
|
strcpy(varcode->Header, join(3,varcode->Header,"char * ",Clean(varcode->Token)));
|
|
strcat(varcode->Proto,"char* ");
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_OverLoad)
|
|
{
|
|
strcpy(varcode->Functype,"char *");
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_OverLoad2)
|
|
{
|
|
strcpy(varcode->Header, join(4,varcode->Header,"char *",Clean(varcode->Token),", "));
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(vn==vt_BOOL||vn==vt_BYTE||vn==vt_COLORREF||vn==vt_DOUBLE||vn==vt_DWORD||vn==vt_FARPROC||vn==vt_HDC||vn==vt_HANDLE||vn==vt_HINSTANCE||vn==vt_HWND||vn==vt_INTEGER||vn==vt_LONG||vn==vt_LPBYTE||vn==vt_LRESULT||vn==vt_SHORT||vn==vt_SINGLE||vn==vt_UINT||vn==vt_ULONG||vn==vt_USHORT||vn==vt_VARIANT||vn==vt_VOID||vn==vt_LDOUBLE)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(varcode->Method==mt_ProcessSetCommand)
|
|
{
|
|
strcpy(varcode->StaticOut, join(4,"static ",VAR," ",Clean(varcode->Token)));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_FuncSubDecC_Dec)
|
|
{
|
|
strcpy(varcode->Functype, join(3,VAR,PTH,CB));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_FuncSubDecC_Dec2)
|
|
{
|
|
strcpy(varcode->Header, join(5,varcode->Header,VAR,PTH,Clean(varcode->Token),", "));
|
|
strcpy(varcode->Proto, join(5,varcode->Proto,VAR,RF,PT,", "));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_Opts)
|
|
{
|
|
strcpy(varcode->Functype, join(2,VAR,PTH));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_Opts2)
|
|
{
|
|
strcpy(varcode->Header, join(4,varcode->Header,VAR,PTH,Clean(varcode->Token)));
|
|
strcpy(varcode->Proto, join(4,varcode->Proto,VAR,RF,PT));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_OverLoad)
|
|
{
|
|
strcpy(varcode->Functype, join(2,VAR," "));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_OverLoad2)
|
|
{
|
|
strcpy(varcode->Header, join(5,varcode->Header,VAR,PTH,Clean(varcode->Token),", "));
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(vn==vt_FILEPTR||vn==vt_CHAR)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(varcode->Method==mt_FuncSubDecC_Dec)
|
|
{
|
|
strcpy(varcode->Functype, join(3,VAR,PTH,CB));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_FuncSubDecC_Dec2)
|
|
{
|
|
strcpy(varcode->Header, join(5,varcode->Header,VAR,PTH,Clean(varcode->Token),", "));
|
|
strcpy(varcode->Proto, join(4,varcode->Proto,VAR,PT,", "));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_Opts)
|
|
{
|
|
strcpy(varcode->Functype, join(2,VAR,PTH));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_Opts2)
|
|
{
|
|
strcpy(varcode->Header, join(4,varcode->Header,VAR,PTH,Clean(varcode->Token)));
|
|
strcpy(varcode->Proto, join(3,varcode->Proto,VAR,PT));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_OverLoad)
|
|
{
|
|
strcpy(varcode->Functype, join(2,VAR," "));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_OverLoad2)
|
|
{
|
|
strcpy(varcode->Header, join(5,varcode->Header,VAR,PTH,Clean(varcode->Token),", "));
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if(vn==vt_UDT||vn==vt_STRUCT||vn==vt_UNION)
|
|
{
|
|
for(;;)
|
|
{
|
|
if(varcode->Method==mt_ProcessSetCommand)
|
|
{
|
|
if(vn==vt_UNION)
|
|
{
|
|
strcpy(varcode->StaticOut, join(2,"static union ",Clean(varcode->Token)));
|
|
}
|
|
else
|
|
{
|
|
strcpy(varcode->StaticOut, join(3,"static struct _",Clean(varcode->Token)," "));
|
|
}
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_FuncSubDecC_Dec)
|
|
{
|
|
strcpy(varcode->Functype, join(3,varcode->AsToken,PTH,CB));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_FuncSubDecC_Dec2)
|
|
{
|
|
strcpy(varcode->Header, join(5,varcode->Header,varcode->AsToken,PTH,Clean(varcode->Token),", "));
|
|
strcpy(varcode->Proto, join(5,varcode->Proto,varcode->AsToken,RF,PT,", "));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_Opts)
|
|
{
|
|
strcpy(varcode->Functype, join(2,varcode->AsToken,PTH));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_Opts2)
|
|
{
|
|
strcpy(varcode->Header, join(5,varcode->Header,Clean(varcode->AsToken),PTH," ",Clean(varcode->Token)));
|
|
strcpy(varcode->Proto, join(4,varcode->Proto,Clean(varcode->AsToken),RF,PT));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_OverLoad)
|
|
{
|
|
strcpy(varcode->Functype, join(2,VAR," "));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_OverLoad2)
|
|
{
|
|
strcpy(varcode->Header, join(5,varcode->Header,varcode->AsToken,PTH,Clean(varcode->Token),", "));
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
// case else
|
|
{
|
|
for(;;)
|
|
{
|
|
if(varcode->Method==mt_FuncSubDecC_Dec)
|
|
{
|
|
strcpy(varcode->Functype, join(3,varcode->AsToken,PTH,CB));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_FuncSubDecC_Dec2)
|
|
{
|
|
strcpy(varcode->Header, join(5,varcode->Header,varcode->AsToken,PTH,Clean(varcode->Token),", "));
|
|
strcpy(varcode->Proto, join(5,varcode->Proto,varcode->AsToken,RF,PT,", "));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_Opts)
|
|
{
|
|
strcpy(varcode->Functype, join(2,varcode->AsToken,PTH));
|
|
break;
|
|
}
|
|
if(varcode->Method==mt_Opts2)
|
|
{
|
|
strcpy(varcode->Header, join(4,varcode->Header,Clean(varcode->AsToken)," ",Clean(varcode->Token)));
|
|
strcat(varcode->Proto,Clean(varcode->AsToken));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void AddProtos (void)
|
|
{
|
|
char SaveMain[2048];
|
|
char *ZZ;
|
|
ZZ=(char*)calloc(256+65535,1);
|
|
int A;
|
|
*SaveMain=0;
|
|
if((FP1=fopen(FileOut,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",FileOut);
|
|
exit(1);
|
|
}
|
|
if((Outfile=fopen("$t$e$m$p","w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n","$t$e$m$p");
|
|
exit(1);
|
|
}
|
|
while(!EoF(FP1))
|
|
{
|
|
ZZ[0]=0;
|
|
AR_fgets_retval=fgets(ZZ,65535,FP1);
|
|
if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
|
|
if(instr_b(ZZ,"int main"))
|
|
{
|
|
strcpy(SaveMain,ZZ);
|
|
break;
|
|
}
|
|
fprintf(Outfile,"%s\n",ZZ);
|
|
}
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s%s\n","// ",BCX_STR_STD_MACROS);
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
if(Use_BcxSplitPath)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define FDRV 2");
|
|
fprintf(Outfile,"%s\n","#define FPATH 4");
|
|
fprintf(Outfile,"%s\n","#define FNAME 8");
|
|
fprintf(Outfile,"%s\n","#define FEXT 16");
|
|
}
|
|
if(Use_Cbool)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define CBOOL(A)(A!=0)?1:0");
|
|
}
|
|
if(Use_Isptr)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define IsPtr(a)((DWORD)a)");
|
|
}
|
|
if(Use_Band)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define BAND &");
|
|
}
|
|
if(Use_Bor)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define BOR |");
|
|
}
|
|
if(Use_Bnot)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define BNOT ~(int)");
|
|
}
|
|
if(Use_Ubound)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define ubound(T)(sizeof((T))/sizeof((T[0]))-1)");
|
|
}
|
|
if(Use_Clear)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define Clear(arg)memset(&arg,0,sizeof(arg))");
|
|
}
|
|
if(Use_Imod)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define imod(a,b)((a)%(b))");
|
|
}
|
|
if(Use_Get)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define GET(A,B,C) F_GetVal=fread(B,1,C,A)");
|
|
AddGlobal("F_GetVal",vt_INTEGER,0,"",0,0,0,0);
|
|
}
|
|
if(Use_Put)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define PUT(A,B,C) F_PutVal=fwrite(B,1,C,A)");
|
|
AddGlobal("F_PutVal",vt_INTEGER,0,"",0,0,0,0);
|
|
}
|
|
if(Use_Strptr)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define STRPTR(A)((char*)&(A))");
|
|
}
|
|
if(Use_Val)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define VAL(a)(double)atof(a)");
|
|
}
|
|
if(Use_Vall)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define VALL(a) (long double)strtold(a,(char**)NULL)");
|
|
}
|
|
if(Use_Fint)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define FINT(a)floor(a)");
|
|
}
|
|
if(Use_Frac)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define FRAC(a)(double)(a-FIX(a))");
|
|
Use_Fix=TRUE;
|
|
}
|
|
if(Use_Fracl)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define FRACL(a)(long double)(a-FIX(a))");
|
|
Use_Fix=TRUE;
|
|
}
|
|
if(Use_Fix)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define FIX(a)(int)((a))");
|
|
}
|
|
if(Use_Csng)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define CSNG(a)((float)(a))");
|
|
}
|
|
if(Use_Cdbl)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define CDBL(a)((double)(a))");
|
|
}
|
|
if(Use_Cldbl)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define CLDBL(a)((long double)(a))");
|
|
}
|
|
if(Use_Threads)
|
|
{
|
|
fprintf(Outfile,"%s\n","#define BCX_THREAD(fn,arg) ({ pthread_t tid; pthread_create(&tid, NULL, (void*(*)(void*))fn, arg); tid;})");
|
|
fprintf(Outfile,"%s\n","#define BCX_THREADWAIT(a) pthread_join(a, NULL)");
|
|
fprintf(Outfile,"%s\n","#define BCX_INITLOCK(a) pthread_mutex_init(a, NULL)");
|
|
fprintf(Outfile,"%s\n","#define BCX_THREADLOCK(a) pthread_mutex_lock (a)");
|
|
fprintf(Outfile,"%s\n","#define BCX_THREADUNLOCK(a) pthread_mutex_unlock (a)");
|
|
fprintf(Outfile,"%s\n","#define BCX_THREADKILL(t) pthread_cancel(t)");
|
|
fprintf(Outfile,"%s\n","#define BCX_THREADEND pthread_exit(0)");
|
|
}
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s%s\n","// ",BCX_STR_STD_PROTOS);
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
if(NoRT==FALSE)
|
|
{
|
|
if(Use_Clng)
|
|
{
|
|
fprintf(Outfile,"%s\n","long CLNG(double);");
|
|
}
|
|
if(Use_Cint)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Cint(double);");
|
|
}
|
|
if(Use_StartupCode)
|
|
{
|
|
fprintf(Outfile,"%s\n","int BCX_StartupCode_(void);");
|
|
}
|
|
if(Use_ExitCode)
|
|
{
|
|
fprintf(Outfile,"%s\n","int BCX_ExitCode_(void);");
|
|
}
|
|
if(Use_Str_Cmp)
|
|
{
|
|
fprintf(Outfile,"%s\n","int str_cmp(char*, char*);");
|
|
}
|
|
if(Use_Eof)
|
|
{
|
|
fprintf(Outfile,"%s\n","int EoF (FILE*);");
|
|
}
|
|
if(Use_CopyFile)
|
|
{
|
|
fprintf(Outfile,"%s\n","void CopyFile (char *,char *,int=FALSE);");
|
|
}
|
|
if(Use_QBColor)
|
|
{
|
|
fprintf(Outfile,"%s\n","int qbcolor (int);");
|
|
}
|
|
if(Use_Cls)
|
|
{
|
|
fprintf(Outfile,"%s\n","void cls(void);");
|
|
}
|
|
if(Use_Color)
|
|
{
|
|
fprintf(Outfile,"%s\n","void color (int,int);");
|
|
}
|
|
if(Use_Locate)
|
|
{
|
|
fprintf(Outfile,"%s\n","void locate (int,int,int=1,int=12);");
|
|
}
|
|
if(Use_Run)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Run (char*, int =1, int =0);");
|
|
}
|
|
if(Use_Randomize)
|
|
{
|
|
fprintf(Outfile,"%s\n","void randomize (unsigned int);");
|
|
}
|
|
if(Use_Midstr)
|
|
{
|
|
fprintf(Outfile,"%s\n","void midstr (char*, int, int, char *);");
|
|
}
|
|
if(Use_Swap)
|
|
{
|
|
fprintf(Outfile,"%s\n","void swap (UCHAR*,UCHAR*,int);");
|
|
}
|
|
if(UseFlag)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* BCX_TmpStr(size_t);");
|
|
}
|
|
if(Use_sziif)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* sziif (bool,char*,char*);");
|
|
}
|
|
if(Use_Using)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* Using (char*,double);");
|
|
}
|
|
if(Use_TempFileName)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* TempFileName (char*,char*);");
|
|
}
|
|
if(Use_AppExePath)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* AppExePath (void);");
|
|
}
|
|
if(Use_AppExeName)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* AppExeName (void);");
|
|
}
|
|
if(Use_Lcase)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* lcase (char*);");
|
|
}
|
|
if(Use_Ucase)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* ucase (char*);");
|
|
}
|
|
if(Use_Mid)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* mid (char*, int, int=-1);");
|
|
}
|
|
if(Use_Ltrim)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* ltrim (char*,char=32);");
|
|
}
|
|
if(Use_Rtrim)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* rtrim (char*,char=32);");
|
|
}
|
|
if(Use_Trim)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* trim (char*);");
|
|
}
|
|
if(Use_Strim)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* strim (char*);");
|
|
}
|
|
if(Use_Left)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* left (char*,int);");
|
|
}
|
|
if(Use_Right)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* right (char*,int);");
|
|
}
|
|
if(Use_Rpad)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* rpad (char*,int,int=32);");
|
|
}
|
|
if(Use_Lpad)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* lpad (char*,int,int=32);");
|
|
}
|
|
if(Use_String)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* stringx (int,int);");
|
|
}
|
|
if(Use_Repeat)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* repeat (int,char*);");
|
|
}
|
|
if(Use_Extract)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* extract (char*,char*);");
|
|
}
|
|
if(Use_Remain)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* remain (char*,char*);");
|
|
}
|
|
if(Use_Reverse)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* reverse (char*);");
|
|
}
|
|
if(Use_Command)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* command (int=-1);");
|
|
}
|
|
if(Use_Mcase)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* mcase (char*);");
|
|
}
|
|
if(Use_Replace)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* replace (char*,char*,char*);");
|
|
}
|
|
if(Use_iReplace)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* iReplace (char*,char*,char*);");
|
|
}
|
|
if(Use_Shell)
|
|
{
|
|
fprintf(Outfile,"%s\n","void Shell (char *);");
|
|
}
|
|
if(Use_Space)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* space (int a);");
|
|
}
|
|
if(Use_Str)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* str (double);");
|
|
}
|
|
if(Use_Strl)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* strl (long double);");
|
|
}
|
|
if(Use_Findfirst)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* findfirst (char*, FILE_FIND_DATA*);");
|
|
}
|
|
if(Use_Findnext)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* findnext (FILE_FIND_DATA*);");
|
|
}
|
|
if(Use_Curdir)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* curdir (void);");
|
|
}
|
|
if(Use_Sysdir)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* sysdir (void);");
|
|
}
|
|
if(Use_Tempdir)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* tempdir (void);");
|
|
}
|
|
if(Use_Environ)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* Environ (char*);");
|
|
}
|
|
if(Use_Boolstr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* BoolStr (int);");
|
|
}
|
|
if(Use_Hex)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* hex (int);");
|
|
}
|
|
if(Use_Bin)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* Bin (int);");
|
|
}
|
|
if(Use_Oct)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* oct (int);");
|
|
}
|
|
if(Use_Now)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* now (void);");
|
|
}
|
|
if(Use_SearchPath)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* SEARCHPATH (char *);");
|
|
}
|
|
if(Use_StrUpLow)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* _strupr_(char *);");
|
|
fprintf(Outfile,"%s\n","char* _strlwr_(char *);");
|
|
}
|
|
if(Use_BcxSplitPath)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* BcxSplitPath (char *, int);");
|
|
fprintf(Outfile,"%s\n","void _splitpath_(const char* path, char* drv, char* dir, char* name, char* ext);");
|
|
}
|
|
if(Use_Strtoken)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* StrToken (char*,char*,int);");
|
|
}
|
|
if(Use_FileLocked)
|
|
{
|
|
fprintf(Outfile,"%s\n","int FileLocked (char*);");
|
|
}
|
|
if(Use_FillArray)
|
|
{
|
|
fprintf(Outfile,"%s\n","int fillarray (char *, int, int, void *);");
|
|
}
|
|
if(Use_Remove)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* RemoveStr (char*,char*);");
|
|
}
|
|
if(Use_IRemove)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* IRemoveStr (char*,char*);");
|
|
}
|
|
if(Use_Time)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* timef (int i=0);");
|
|
}
|
|
if(Use_Join)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* join (int, ... );");
|
|
}
|
|
if(Use_Enclose)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* enc (char*, int=0, int=0);");
|
|
}
|
|
if(Use_Chr)
|
|
{
|
|
fprintf(Outfile,"%s","char* chr");
|
|
fprintf(Outfile,"%s\n","(int,int=0,int=0,int=0,int=0,int=0,int=0,int=0,int=0,int=0);");
|
|
}
|
|
if(Use_VChr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* vchr (int,...);");
|
|
}
|
|
if(Use_Freefile)
|
|
{
|
|
fprintf(Outfile,"%s\n","FILE* FreeFile (void);");
|
|
}
|
|
if(Use_PeekStr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* peekstr (LPVOID,int);");
|
|
}
|
|
if(Use_Asc)
|
|
{
|
|
fprintf(Outfile,"%s\n","int asc (char*,int=0);");
|
|
}
|
|
if(Use_Instrrev)
|
|
{
|
|
fprintf(Outfile,"%s\n","int InstrRev (char*,char*,int=0,int=0);");
|
|
}
|
|
if(Use_Instr)
|
|
{
|
|
fprintf(Outfile,"%s\n","int instr_b(char*,char*,int=0,int=0);");
|
|
}
|
|
if(UseLCaseTbl)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *MakeLCaseTbl(void);");
|
|
}
|
|
if(Use_Stristr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *_stristr_(char*,char*);");
|
|
}
|
|
if(Use_StrStr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *_strstr_(char*,char*);");
|
|
}
|
|
if(Use_Verify)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Verify (char *, char *);");
|
|
fprintf(Outfile,"%s\n","int VerifyInstr(char*,char*,int=0);");
|
|
}
|
|
if(Use_Retain)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* Retain (char*,char *);");
|
|
}
|
|
if(Use_LoadFile)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* LoadFile (char*);");
|
|
}
|
|
if(Use_Inchr)
|
|
{
|
|
fprintf(Outfile,"%s\n","int inchr (char*,char*);");
|
|
}
|
|
if(Use_Idxqsort)
|
|
{
|
|
fprintf(Outfile,"%s\n","int IdxCompare (const void *,const void *);");
|
|
}
|
|
if(Use_IdxqsortSt)
|
|
{
|
|
fprintf(Outfile,"%s\n","int IdxCompareSt (const void *,const void *);");
|
|
}
|
|
if(Use_PtrqsortSt)
|
|
{
|
|
fprintf(Outfile,"%s\n","int PtrCompareSt (const void *,const void *);");
|
|
}
|
|
if(Use_Strqsorta)
|
|
{
|
|
fprintf(Outfile,"%s\n","int StrCompareA (const void *,const void *);");
|
|
}
|
|
if(Use_Strqsortd)
|
|
{
|
|
fprintf(Outfile,"%s\n","int StrCompareD (const void *,const void *);");
|
|
}
|
|
if(Use_DynStrqsorta)
|
|
{
|
|
fprintf(Outfile,"%s\n","int DynStrCompareA (const void *,const void *);");
|
|
}
|
|
if(Use_DynStrqsortd)
|
|
{
|
|
fprintf(Outfile,"%s\n","int DynStrCompareD (const void *,const void *);");
|
|
}
|
|
if(Use_Numqsortaint)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareAint (const void *,const void *);");
|
|
}
|
|
if(Use_Numqsortdint)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareDint (const void *,const void *);");
|
|
}
|
|
if(Use_Numqsortafloat)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareAfloat (const void *,const void *);");
|
|
}
|
|
if(Use_Numqsortdfloat)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareDfloat (const void *,const void *);");
|
|
}
|
|
if(Use_Numqsortadouble)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareAdouble (const void *,const void *);");
|
|
}
|
|
if(Use_Numqsortddouble)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareDdouble (const void *,const void *);");
|
|
}
|
|
if(Use_Like)
|
|
{
|
|
fprintf(Outfile,"%s\n","int like (char*,char*);");
|
|
}
|
|
if(Use_Tally)
|
|
{
|
|
fprintf(Outfile,"%s\n","int tally (char*,char*,int=0);");
|
|
}
|
|
if(Use_Inkey)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* inkey (void);");
|
|
}
|
|
if(Use_InkeyD)
|
|
{
|
|
fprintf(Outfile,"%s\n","int inkeyd (void);");
|
|
}
|
|
if(Use_Instat)
|
|
{
|
|
fprintf(Outfile,"%s\n","int kbhit(void);");
|
|
}
|
|
if(Use_GetCh)
|
|
{
|
|
fprintf(Outfile,"%s\n","int _getch_(int);");
|
|
}
|
|
if(Use_Bin2dec)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Bin2Dec (char*);");
|
|
}
|
|
if(Use_Hex2Dec)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Hex2Dec (char*);");
|
|
}
|
|
if(Use_Download)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Download (char*,char*);");
|
|
}
|
|
if(Use_Embed)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* GetResource (int* );");
|
|
}
|
|
if(Use_Exist)
|
|
{
|
|
if(Use_Osx)
|
|
{
|
|
fprintf(Outfile,"%s\n","bool Exist (char*);");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n","BOOL Exist (char*);");
|
|
}
|
|
}
|
|
if(Use_Ins)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* ins (char *S, int i, char *a);");
|
|
}
|
|
if(Use_Del)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* del (char*,int,int);");
|
|
}
|
|
if(Use_Pause)
|
|
{
|
|
fprintf(Outfile,"%s\n","void Pause (void);");
|
|
}
|
|
if(Use_Keypress)
|
|
{
|
|
fprintf(Outfile,"%s\n","int keypress (void);");
|
|
}
|
|
if(Use_Lof)
|
|
{
|
|
fprintf(Outfile,"%s\n","DWORD lof (char*);");
|
|
}
|
|
if(Use_Sgn)
|
|
{
|
|
fprintf(Outfile,"%s\n","double sgn (double);");
|
|
}
|
|
if(Use_Round)
|
|
{
|
|
fprintf(Outfile,"%s\n","double Round (double,int);");
|
|
}
|
|
if(Use_Rnd)
|
|
{
|
|
fprintf(Outfile,"%s\n","float rnd (void);");
|
|
}
|
|
if(Use_Exp)
|
|
{
|
|
fprintf(Outfile,"%s\n","double Exp (double);");
|
|
}
|
|
if(Use_Min)
|
|
{
|
|
fprintf(Outfile,"%s\n","double _MIN_ (double,double);");
|
|
}
|
|
if(Use_Max)
|
|
{
|
|
fprintf(Outfile,"%s\n","double _MAX_ (double,double);");
|
|
}
|
|
if(Use_Timer)
|
|
{
|
|
fprintf(Outfile,"%s\n","float timer (void);");
|
|
}
|
|
if(Use_Iif)
|
|
{
|
|
fprintf(Outfile,"%s\n","double iif (bool,double,double);");
|
|
}
|
|
if(Use_Loc)
|
|
{
|
|
fprintf(Outfile,"%s\n","int loc (FILE *fp, int fplen);");
|
|
}
|
|
if(Use_Rec)
|
|
{
|
|
fprintf(Outfile,"%s\n","int rec (FILE *fp, int fplen);");
|
|
}
|
|
if(Use_RecCount)
|
|
{
|
|
fprintf(Outfile,"%s\n","int reccount (FILE *fp, int fplen);");
|
|
}
|
|
if(Use_Scan)
|
|
{
|
|
fprintf(Outfile,"%s\n","int scan (char *input, char *format, ... );");
|
|
}
|
|
if(Use_Split)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Split (char [][65535], char*, char*, int=0);");
|
|
}
|
|
if(Use_DSplit)
|
|
{
|
|
fprintf(Outfile,"%s\n","int DSplit (PCHAR *, char*, char*, int=0);");
|
|
}
|
|
if(Use_SysStr)
|
|
{
|
|
fprintf(Outfile,"%s\n","BSTR SysStr (char * szIn, int=0, int=0);");
|
|
}
|
|
if(Use_WideToAnsi)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* WideToAnsi (wchar_t *, UINT=0, DWORD=0);");
|
|
}
|
|
if(Use_AnsiToWide)
|
|
{
|
|
fprintf(Outfile,"%s\n","wchar_t* AnsiToWide (char*,UINT=0,DWORD=0);");
|
|
}
|
|
if(Use_Cvi)
|
|
{
|
|
fprintf(Outfile,"%s\n","short CVI (char*);");
|
|
}
|
|
if(Use_Mki)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* MKI (short);");
|
|
}
|
|
if(Use_Cvl)
|
|
{
|
|
fprintf(Outfile,"%s\n","long CVL (char*);");
|
|
}
|
|
if(Use_Mkl)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* MKL (int);");
|
|
}
|
|
if(Use_Cvs)
|
|
{
|
|
fprintf(Outfile,"%s\n","float CVS (char*);");
|
|
}
|
|
if(Use_Mks)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* MKS (float);");
|
|
}
|
|
if(Use_Cvd)
|
|
{
|
|
fprintf(Outfile,"%s\n","double CVD (char*);");
|
|
}
|
|
if(Use_Cvld)
|
|
{
|
|
fprintf(Outfile,"%s\n","long double CVLD (char*);");
|
|
}
|
|
if(Use_Mkd)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* MKD (double);");
|
|
}
|
|
if(Use_Mkld)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* MKLD (long double);");
|
|
}
|
|
if(Use_OSVersion)
|
|
{
|
|
fprintf(Outfile,"%s\n","int OSVersion (void);");
|
|
}
|
|
if(Use_Dynacall)
|
|
{
|
|
fprintf(Outfile,"%s\n","HINSTANCE BCX_LoadDll(char *);");
|
|
fprintf(Outfile,"%s\n","void BCX_UnloadDll(void);");
|
|
fprintf(Outfile,"%s\n","typedef int (CALLBACK *DYNACALL1)(void);");
|
|
fprintf(Outfile,"%s\n","int BCX_DynaCall(char *, char *, int, ...);");
|
|
}
|
|
if(Use_DynamicA)
|
|
{
|
|
fprintf(Outfile,"%s\n","void* CreateArr (void*,int,int,int,...);");
|
|
fprintf(Outfile,"%s\n","void* CreateArr_internal(void*, int, int, int, va_list);");
|
|
fprintf(Outfile,"%s\n","void DestroyArr (void**,int,int);");
|
|
}
|
|
if(Use_ContainedIn)
|
|
{
|
|
fprintf(Outfile,"%s\n","int containedin(char * ,char **,int=0);");
|
|
}
|
|
if(Use_FindInType)
|
|
{
|
|
fprintf(Outfile,"%s\n","int FindInType(char *,char *,int,int,int,int=0,int* =0);");
|
|
}
|
|
if(Use_SingleFile==FALSE)
|
|
{
|
|
if((fpHFile=fopen(HFile,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",HFile);
|
|
exit(1);
|
|
}
|
|
}
|
|
/*****2010-11-24ChangeTOemitwxAppCLASSDefinitionFORWXCONSOLEApps-AIR*****/;
|
|
if(Use_Wx)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s%s%s\n","class ",BcxSplitPath(FileIn,FNAME),": public wxApp {");
|
|
fprintf(Outfile,"%s\n"," public:");
|
|
fprintf(Outfile,"%s\n"," virtual bool OnInit();");
|
|
fprintf(Outfile,"%s\n","};");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s%s%s\n","IMPLEMENT_APP(",BcxSplitPath(FileIn,FNAME),")");
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
if(Use_Socket)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","sockaddr_in sock_addr (char* ,int=80);");
|
|
fprintf(Outfile,"%s\n","int connect_socket (sockaddr_in);");
|
|
fprintf(Outfile,"%s\n","int BcxSocket (char* ,int=80);");
|
|
fprintf(Outfile,"%s\n","int BcxSocketSend (int, char *);");
|
|
fprintf(Outfile,"%s\n","int BcxSocketRead (int, char *);");
|
|
fprintf(Outfile,"%s\n","void BcxSocketClose(int);");
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
if(Use_RegEx)
|
|
{
|
|
fprintf(Outfile,"%s\n","bool regmatch (char *, char *, REGEX* );");
|
|
}
|
|
}
|
|
if(ProtoCnt)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s%s\n","// ",BCX_STR_USR_PROTOS);
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
char LastDef[2048];
|
|
int LastLevel;
|
|
*LastDef=0;
|
|
LastLevel=1;
|
|
for(A=1; A<=ProtoCnt; A+=1)
|
|
{
|
|
if(LastDef[0]==0)
|
|
{
|
|
strcpy(LastDef,ProtoType[A].Condition);
|
|
LastLevel=ProtoType[A].CondLevel;
|
|
if(Use_SingleFile==FALSE)
|
|
{
|
|
if(LastDef[0]>0)
|
|
{
|
|
fprintf(fpHFile,"%s\n",LastDef);
|
|
}
|
|
}
|
|
if(LastDef[0]>0)
|
|
{
|
|
fprintf(Outfile,"%s\n",LastDef);
|
|
}
|
|
}
|
|
if(str_cmp(LastDef,ProtoType[A].Condition)!=0)
|
|
{
|
|
if(str_cmp(ProtoType[A].Condition,"#else")==0)
|
|
{
|
|
while(LastLevel>ProtoType[A].CondLevel)
|
|
{
|
|
if(Use_SingleFile==FALSE)
|
|
{
|
|
fprintf(fpHFile,"%s\n","#endif");
|
|
}
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
LastLevel--;
|
|
}
|
|
if(Use_SingleFile==FALSE)
|
|
{
|
|
fprintf(fpHFile,"%s\n","#else");
|
|
}
|
|
fprintf(Outfile,"%s\n","#else");
|
|
strcpy(LastDef,ProtoType[A].Condition);
|
|
LastLevel=ProtoType[A].CondLevel;
|
|
}
|
|
else
|
|
{
|
|
while(LastLevel>ProtoType[A].CondLevel)
|
|
{
|
|
if(Use_SingleFile==FALSE)
|
|
{
|
|
fprintf(fpHFile,"%s\n","#endif");
|
|
}
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
LastLevel--;
|
|
}
|
|
strcpy(LastDef,ProtoType[A].Condition);
|
|
LastLevel=ProtoType[A].CondLevel;
|
|
if(Use_SingleFile==FALSE)
|
|
{
|
|
if(LastDef[0]>0)
|
|
{
|
|
fprintf(fpHFile,"%s\n",LastDef);
|
|
}
|
|
}
|
|
if(LastDef[0]>0)
|
|
{
|
|
fprintf(Outfile,"%s\n",LastDef);
|
|
}
|
|
}
|
|
}
|
|
if(UseStdCall&&UseCpp)
|
|
{
|
|
if(str_cmp(left(ProtoType[A].Prototype,9),"C_EXPORT ")==0)
|
|
{
|
|
EmitExportDef(ProtoType[A].Prototype);
|
|
}
|
|
}
|
|
strcpy(T,extract(ProtoType[A].Prototype,SPC));
|
|
strcpy(T, join(2,rpad(T,7),SPC));
|
|
strcpy(ProtoType[A].Prototype, join(2,T,remain(ProtoType[A].Prototype,SPC)));
|
|
if(Use_SingleFile==FALSE)
|
|
{
|
|
fprintf(fpHFile,"%s\n",ProtoType[A].Prototype);
|
|
}
|
|
if(UseCpp==FALSE&&!instr_b(ProtoType[A].Prototype,"::"))
|
|
{
|
|
fprintf(Outfile,"%s\n",ProtoType[A].Prototype);
|
|
}
|
|
}
|
|
if(*LastDef)
|
|
{
|
|
while(LastLevel>0)
|
|
{
|
|
if(Use_SingleFile==FALSE)
|
|
{
|
|
fprintf(fpHFile,"%s\n","#endif");
|
|
}
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
LastLevel--;
|
|
}
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n","");
|
|
char P[2048];
|
|
int i;
|
|
char VarName[2048];
|
|
char VarDim[2048];
|
|
char Storage[2048];
|
|
char VAR[2048];
|
|
if(GlobalVarCnt>0)
|
|
{
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","// User Global Initialized Arrays");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
for(i=1; i<=GlobalVarCnt; i+=1)
|
|
{
|
|
if(GlobalVars[i].VarEmitFlag)
|
|
{
|
|
continue;
|
|
}
|
|
if(str_cmp("",GlobalVars[i].VarDim)!=0 && GlobalVars[i].VarCondLevel==0)
|
|
{
|
|
if(instr_b(GlobalVars[i].VarDim,"{"))
|
|
{
|
|
*P=0;
|
|
if(GlobalVars[i].VarPntr)
|
|
{
|
|
strcpy(P,stringx(GlobalVars[i].VarPntr,42));
|
|
}
|
|
A=GlobalVars[i].VarType;
|
|
if(GlobalVars[i].VarSF)
|
|
{
|
|
strcpy(VarName, join(4,"(*",GlobalVars[i].VarName,extract(GlobalVars[i].VarDim,"("),")"));
|
|
strcpy(VarDim,mid(GlobalVars[i].VarDim,instr_b(GlobalVars[i].VarDim,"(")));
|
|
}
|
|
else
|
|
{
|
|
strcpy(VarName,GlobalVars[i].VarName);
|
|
strcpy(VarDim,GlobalVars[i].VarDim);
|
|
}
|
|
strcpy(Storage, join(2,VarStorage[GlobalVars[i].VarExtn],VarConst[GlobalVars[i].VarConstant]));
|
|
for(;;)
|
|
{
|
|
if(A==vt_STRVAR)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Storage,"char ",VarName,VarDim,";");
|
|
break;
|
|
}
|
|
if(A==vt_FILEPTR)
|
|
{
|
|
strcpy(GlobalVars[i].VarName,RemoveStr(GlobalVars[i].VarName,"@"));
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Storage,"FILE *",VarName,VarDim,";");
|
|
break;
|
|
}
|
|
if(A==vt_BOOL)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Storage,"bool ",VarName,VarDim,";");
|
|
break;
|
|
}
|
|
if(A==vt_UDT||A==vt_STRUCT||A==vt_UNION)
|
|
{
|
|
strcpy(VAR,TypeDefs[GlobalVars[i].VarDef].VarName);
|
|
strcpy(VAR,rpad(VAR,7));
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
|
|
break;
|
|
}
|
|
if(A>=vt_VarMin&&A<=vt_VarMax)
|
|
{
|
|
strcpy(VAR,GetVarTypeName(GlobalVars[i].VarType));
|
|
strcpy(VAR,rpad(VAR,7));
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
if(Use_Overloaded)
|
|
{
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","// User's Overloaded Subs/Functions ");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
if((FP8=fopen(ovrFile,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",ovrFile);
|
|
exit(1);
|
|
}
|
|
while(!EoF(FP8))
|
|
{
|
|
ZZ[0]=0;
|
|
AR_fgets_retval=fgets(ZZ,65535,FP8);
|
|
if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
|
|
if(instr_b(ZZ,"overloaded"))
|
|
{
|
|
fprintf(Outfile,"%s\n","\n");
|
|
}
|
|
fprintf(Outfile,"%s\n",ZZ);
|
|
}
|
|
if(FP8)
|
|
{
|
|
fclose(FP8);
|
|
FP8=NULL;
|
|
}
|
|
fprintf(Outfile,"%s\n","\n\n");
|
|
}
|
|
if((FP5=fopen(setFile,"r"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",setFile);
|
|
exit(1);
|
|
}
|
|
if(lof(setFile)>0)
|
|
{
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","// User GLOBAL SET Statements");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
while(!EoF(FP5))
|
|
{
|
|
Z[0]=0;
|
|
AR_fgets_retval=fgets(Z,65535,FP5);
|
|
if(Z[strlen(Z)-1]==10)Z[strlen(Z)-1]=0;
|
|
fprintf(Outfile,"%s\n",Z);
|
|
}
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
if(FP5)
|
|
{
|
|
fclose(FP5);
|
|
FP5=NULL;
|
|
}
|
|
if(Use_SingleFile==FALSE)
|
|
{
|
|
if(fpHFile)
|
|
{
|
|
fclose(fpHFile);
|
|
fpHFile=NULL;
|
|
}
|
|
}
|
|
if(NoMain==0)
|
|
{
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s%s\n","// ",BCX_STR_MAIN_PROG);
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
}
|
|
if(NoMain==FALSE)
|
|
{
|
|
fprintf(Outfile,"%s\n",SaveMain);
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," G_argc = argc;");
|
|
fprintf(Outfile,"%s\n"," G_argv = argv;");
|
|
BumpUp();
|
|
}
|
|
while(!EoF(FP1))
|
|
{
|
|
ZZ[0]=0;
|
|
AR_fgets_retval=fgets(ZZ,65535,FP1);
|
|
if(ZZ[strlen(ZZ)-1]==10)ZZ[strlen(ZZ)-1]=0;
|
|
fprintf(Outfile,"%s%s\n",Scoot,ZZ);
|
|
}
|
|
if(Use_SingleFile==TRUE)
|
|
{
|
|
RunTimeFunctions();
|
|
}
|
|
fflush(Outfile);
|
|
CloseAll();
|
|
remove (FileOut);
|
|
rename ("$t$e$m$p",FileOut);
|
|
if(ZZ)free(ZZ);
|
|
}
|
|
|
|
|
|
void RunTimeFunctions (void)
|
|
{
|
|
static char X1[2048];
|
|
memset(&X1,0,sizeof(X1));
|
|
static char O1[2048];
|
|
memset(&O1,0,sizeof(O1));
|
|
static char D1[2048];
|
|
memset(&D1,0,sizeof(D1));
|
|
static char D2[2048];
|
|
memset(&D2,0,sizeof(D2));
|
|
static char T0[2048];
|
|
memset(&T0,0,sizeof(T0));
|
|
static char T1[2048];
|
|
memset(&T1,0,sizeof(T1));
|
|
static char T2[2048];
|
|
memset(&T2,0,sizeof(T2));
|
|
static char T3[2048];
|
|
memset(&T3,0,sizeof(T3));
|
|
static char T4[2048];
|
|
memset(&T4,0,sizeof(T4));
|
|
static char T5[2048];
|
|
memset(&T5,0,sizeof(T5));
|
|
static char T6[2048];
|
|
memset(&T6,0,sizeof(T6));
|
|
static char T7[2048];
|
|
memset(&T7,0,sizeof(T7));
|
|
static char T8[2048];
|
|
memset(&T8,0,sizeof(T8));
|
|
static char T9[2048];
|
|
memset(&T9,0,sizeof(T9));
|
|
static char T10[2048];
|
|
memset(&T10,0,sizeof(T10));
|
|
static char T11[2048];
|
|
memset(&T11,0,sizeof(T11));
|
|
static char T12[2048];
|
|
memset(&T12,0,sizeof(T12));
|
|
static char T13[2048];
|
|
memset(&T13,0,sizeof(T13));
|
|
static char TDIR[2048];
|
|
memset(&TDIR,0,sizeof(TDIR));
|
|
strcpy(D1,vchr(8,34,37,32,46,49,53,71,34));
|
|
strcpy(D2,vchr(9,34,37,32,46,49,57,76,71,34));
|
|
strcpy(O1,vchr(4,34,37,111,34));
|
|
strcpy(T0,vchr(10,34,37,72,58,37,77,58,37,83,34));
|
|
strcpy(T1,vchr(4,34,37,72,34));
|
|
strcpy(T2,vchr(4,34,37,77,34));
|
|
strcpy(T3,vchr(4,34,37,83,34));
|
|
strcpy(T4,vchr(4,34,37,112,34));
|
|
strcpy(T5,vchr(4,34,37,89,34));
|
|
strcpy(T6,vchr(4,34,37,109,34));
|
|
strcpy(T7,vchr(4,34,37,100,34));
|
|
strcpy(T8,vchr(4,34,37,65,34));
|
|
strcpy(T9,vchr(4,34,37,119,34));
|
|
strcpy(T10,vchr(4,34,37,106,34));
|
|
strcpy(T11,vchr(4,34,37,86,34));
|
|
strcpy(T12,vchr(10,34,37,109,47,37,100,47,37,121,34));
|
|
strcpy(T13,vchr(15,34,37,65,44,32,37,66,32,37,100,44,32,37,89,34));
|
|
strcpy(X1,vchr(4,34,37,88,34));
|
|
strcpy(TDIR,enc("/tmp/mbc.XXXXXXXX"));
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s%s\n","// ",BCX_STR_RUNTIME);
|
|
fprintf(Outfile,"%s\n","// *************************************************");
|
|
fprintf(Outfile,"%s\n","");
|
|
if(NoRT==TRUE)
|
|
{
|
|
return;
|
|
}
|
|
if(UseFlag)
|
|
{
|
|
if(Use_Turbo)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *BCX_TmpStr (size_t Bites)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static int StrCnt;");
|
|
fprintf(Outfile,"%s%d%s\n"," static char *StrFunc[",(int)TurboSize,"];");
|
|
fprintf(Outfile,"%s%d%s\n"," StrCnt=((StrCnt+1) &",(int)TurboSize-1,");");
|
|
fprintf(Outfile,"%s\n"," #if defined BCX_MAX_VAR_SIZE");
|
|
fprintf(Outfile,"%s\n"," if(Bites*sizeof(char)>BCX_MAX_VAR_SIZE)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s%s%s\n"," printf(",enc("Buffer Overflow caught in BCX_TmpStr - requested space of %d EXCEEDS %d\\n"),",(int)(Bites*sizeof(char)),BCX_MAX_VAR_SIZE);");
|
|
fprintf(Outfile,"%s\n"," abort();");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," #endif");
|
|
fprintf(Outfile,"%s\n"," StrFunc[StrCnt]=(char*)realloc(StrFunc[StrCnt],Bites + 128);");
|
|
fprintf(Outfile,"%s\n"," return (char*)memset(StrFunc[StrCnt],0,Bites+128);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s\n","char *BCX_TmpStr (size_t Bites)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static int StrCnt;");
|
|
fprintf(Outfile,"%s\n"," static char *StrFunc[65535];");
|
|
fprintf(Outfile,"%s\n"," StrCnt=(StrCnt + 1) & 65535;");
|
|
fprintf(Outfile,"%s\n"," if(StrFunc[StrCnt]) free (StrFunc[StrCnt]);");
|
|
fprintf(Outfile,"%s\n"," #if defined BCX_MAX_VAR_SIZE");
|
|
fprintf(Outfile,"%s\n"," if(Bites*sizeof(char)>BCX_MAX_VAR_SIZE)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s%s%s\n"," printf(",enc("Buffer Overflow caught in BCX_TmpStr - requested space of %d EXCEEDS %d\\n"),",(int)(Bites*sizeof(char)),BCX_MAX_VAR_SIZE);");
|
|
fprintf(Outfile,"%s\n"," abort();");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," #endif");
|
|
fprintf(Outfile,"%s\n"," return StrFunc[StrCnt]=(char*)calloc(Bites+128,sizeof(char));");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
}
|
|
if(Use_CopyFile)
|
|
{
|
|
fprintf(Outfile,"%s\n","void CopyFile (char *InFile,char *TmpFile,int OverWrite)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," #define BLOCKCOPYSIZE (10 * 1000*1024)");
|
|
fprintf(Outfile,"%s\n"," char* tmp=0;");
|
|
fprintf(Outfile,"%s\n"," UINT blocks=1;");
|
|
fprintf(Outfile,"%s\n"," UINT overage=0;");
|
|
fprintf(Outfile,"%s\n"," UINT i;");
|
|
fprintf(Outfile,"%s\n"," FILE *FP1,*FP2;");
|
|
fprintf(Outfile,"%s\n"," if(!OverWrite)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(Exist(TmpFile)) return;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(Exist(InFile))");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," UINT length = lof(InFile);");
|
|
fprintf(Outfile,"%s\n"," if(length > BLOCKCOPYSIZE)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," blocks = length/BLOCKCOPYSIZE;");
|
|
fprintf(Outfile,"%s\n"," overage= length % BLOCKCOPYSIZE;");
|
|
fprintf(Outfile,"%s\n"," length = BLOCKCOPYSIZE;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," tmp=(char*)calloc(16+length,1);");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s%s%s\n"," if((FP1=fopen(InFile,",enc("rb"),"))==0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s%s%s\n"," fprintf(stderr,",enc("Can't open file %s\\n"),",InFile);");
|
|
fprintf(Outfile,"%s\n"," exit(1);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s%s%s\n"," if((FP2=fopen(TmpFile,",enc("wb+"),"))==0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s%s%s\n"," fprintf(stderr,",enc("Can't open file %s\\n"),",TmpFile);");
|
|
fprintf(Outfile,"%s\n"," exit(1);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," for(i=0; i<blocks; i+=1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," fread(tmp,1,length,FP1);");
|
|
fprintf(Outfile,"%s\n"," fwrite(tmp,1,length,FP2);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(overage>0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," fread(tmp,1,overage,FP1);");
|
|
fprintf(Outfile,"%s\n"," fwrite(tmp,1,overage,FP2);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," fclose(FP2); fclose(FP1);");
|
|
fprintf(Outfile,"%s\n"," if(tmp) free(tmp);");
|
|
fprintf(Outfile,"%s\n"," struct stat st;");
|
|
fprintf(Outfile,"%s\n"," if(stat(InFile, &st) != -1)");
|
|
fprintf(Outfile,"%s\n"," chmod(TmpFile,st.st_mode);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Str_Cmp)
|
|
{
|
|
fprintf(Outfile,"%s\n","int str_cmp (char *a, char *b)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int counter=0;");
|
|
fprintf(Outfile,"%s\n"," for(;;)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if((a[counter]^b[counter]))");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if((UINT) a[counter]>= (UINT) b[counter])");
|
|
fprintf(Outfile,"%s\n"," return 1;");
|
|
fprintf(Outfile,"%s\n"," return -1;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(!a[counter]) return 0;");
|
|
fprintf(Outfile,"%s\n"," counter++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Eof)
|
|
{
|
|
fprintf(Outfile,"%s\n","int EoF (FILE* stream)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int c, status = ((c = fgetc(stream)) == EOF);");
|
|
fprintf(Outfile,"%s\n"," ungetc(c,stream);");
|
|
fprintf(Outfile,"%s\n"," return status;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Cint)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Cint (double A)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return (A >=0 ? (int)(A+0.5) : (int)(A-0.5));");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Clng)
|
|
{
|
|
fprintf(Outfile,"%s\n","long CLNG (double A)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," float r=.5;");
|
|
fprintf(Outfile,"%s\n"," double a=A-(long)A;");
|
|
fprintf(Outfile,"%s\n"," if(A<0) { r=-.5; a=-a; }");
|
|
fprintf(Outfile,"%s\n"," if(((long)A % 2)==0&&a<=.5)");
|
|
fprintf(Outfile,"%s\n"," return (long)A;");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," return (long)(A+r);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Left)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *left (char *S, int length)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int tmplen = strlen(S);");
|
|
fprintf(Outfile,"%s\n"," if(length<1) return BCX_TmpStr(1);");
|
|
fprintf(Outfile,"%s\n"," if(length<tmplen) tmplen=length;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(tmplen);");
|
|
fprintf(Outfile,"%s\n"," return (char*)memcpy(strtmp,S,tmplen);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Right)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *right (char *S, int length)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int tmplen = strlen(S);");
|
|
fprintf(Outfile,"%s\n"," char *BCX_RetStr = BCX_TmpStr(tmplen);");
|
|
fprintf(Outfile,"%s\n"," tmplen -= length;");
|
|
fprintf(Outfile,"%s\n"," if (tmplen<0) tmplen = 0;");
|
|
fprintf(Outfile,"%s\n"," return strcpy(BCX_RetStr, &S[tmplen]);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Rpad)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *rpad (char *a, int L, int c)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp;");
|
|
fprintf(Outfile,"%s\n"," int s = strlen(a);");
|
|
fprintf(Outfile,"%s\n"," if((L-s)<1) return a;");
|
|
fprintf(Outfile,"%s\n"," strtmp=BCX_TmpStr(L);");
|
|
fprintf(Outfile,"%s\n"," strcpy(strtmp,a);");
|
|
fprintf(Outfile,"%s\n"," memset(&strtmp[s],c,(L-s));");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Lpad)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *lpad (char *a, int L, int c)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp;");
|
|
fprintf(Outfile,"%s\n"," L=L-strlen(a);");
|
|
fprintf(Outfile,"%s\n"," if(L<1) return a;");
|
|
fprintf(Outfile,"%s\n"," strtmp = BCX_TmpStr(L);");
|
|
fprintf(Outfile,"%s\n"," memset(strtmp,c,L);");
|
|
fprintf(Outfile,"%s\n"," return strcat(strtmp,a);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Mid)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *mid (char *S, int start, int length)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp;");
|
|
fprintf(Outfile,"%s\n"," int tmplen = strlen(S);");
|
|
fprintf(Outfile,"%s\n"," if(start>tmplen||start<1) return BCX_TmpStr(1);");
|
|
fprintf(Outfile,"%s\n"," if (length<0 || length>(tmplen-start)+1)");
|
|
fprintf(Outfile,"%s\n"," length = (tmplen-start)+1;");
|
|
fprintf(Outfile,"%s\n"," strtmp = BCX_TmpStr(length);");
|
|
fprintf(Outfile,"%s\n"," return (char*)memcpy(strtmp,&S[start-1],length);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Trim)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *trim (char *S)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," while(*S==32 || *S==9 || *S==10 || *S==11 || *S==13)");
|
|
fprintf(Outfile,"%s\n"," S++;");
|
|
fprintf(Outfile,"%s\n"," int i = strlen(S);");
|
|
fprintf(Outfile,"%s\n"," while( i>0 && (S[i-1]==32 || S[i-1]==9 || S[i-1]==10");
|
|
fprintf(Outfile,"%s\n"," || S[i-1]==11 || S[i-1]==13))");
|
|
fprintf(Outfile,"%s\n"," i--;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp=BCX_TmpStr(i);");
|
|
fprintf(Outfile,"%s\n"," return (char*)memcpy(strtmp,S,i);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Ltrim)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *ltrim (char *S, char c)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(S[0]==0) return S;");
|
|
fprintf(Outfile,"%s\n"," while((*S==32 || *S==c) && *S !=0) S++;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(strlen(S));");
|
|
fprintf(Outfile,"%s\n"," return strcpy(strtmp,S);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Rtrim)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *rtrim (char *S,char c)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(S[0]==0) return S;");
|
|
fprintf(Outfile,"%s\n"," int i = strlen(S);");
|
|
fprintf(Outfile,"%s\n"," while(i>0 && (S[i-1]==c || S[i-1]==32))");
|
|
fprintf(Outfile,"%s\n"," i--;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(i);");
|
|
fprintf(Outfile,"%s\n"," return (char*)memcpy(strtmp,S,i);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Strim)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *strim (char *src)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(strlen(src));");
|
|
fprintf(Outfile,"%s\n"," char *dst = strtmp;");
|
|
fprintf(Outfile,"%s\n"," while (isspace((unsigned char)*src)) src++;");
|
|
fprintf(Outfile,"%s\n"," do");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," while (*src && !isspace((unsigned char)*src)) *dst++ = *src++;");
|
|
fprintf(Outfile,"%s\n"," if (*src)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," *dst++ = *src++;");
|
|
fprintf(Outfile,"%s\n"," while (isspace((unsigned char)*src)) src++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," } while (*src);");
|
|
fprintf(Outfile,"%s\n"," if (isspace((unsigned char)*(--dst))) *dst = 0;");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Command)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *command (int nArg)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," int i = 0;");
|
|
fprintf(Outfile,"%s\n"," char *retstr=BCX_TmpStr(1);");
|
|
fprintf(Outfile,"%s\n"," if(nArg < i) // return entire commandline");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," retstr = BCX_TmpStr(G_argc * 2048);");
|
|
fprintf(Outfile,"%s\n"," for(i=1; i < G_argc; i++)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," strcat(retstr, G_argv[i]);");
|
|
fprintf(Outfile,"%s\n"," strcat(retstr, SPC);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," else if(nArg < G_argc)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," retstr = BCX_TmpStr(strlen(G_argv[nArg]) + 1);");
|
|
fprintf(Outfile,"%s\n"," strcpy(retstr, G_argv[nArg]);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return retstr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Extract)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *extract (char *mane, char *match)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *a;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(strlen(mane));");
|
|
fprintf(Outfile,"%s\n"," if(*match!=0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," a=_strstr_(mane,match);");
|
|
fprintf(Outfile,"%s\n"," if(a) return (char*)memcpy(strtmp,mane,a-mane);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return strcpy(strtmp,mane);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Remain)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *remain (char *mane, char *mat)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *p = strstr(mane,mat);");
|
|
fprintf(Outfile,"%s\n"," if(p)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," p+=(strlen(mat));");
|
|
fprintf(Outfile,"%s\n"," return p;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return mane;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Replace)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *replace (char *src, char *pat, char *rep)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," size_t patsz, repsz, tmpsz, delta;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp, *p, *q, *r;");
|
|
fprintf(Outfile,"%s\n"," if (!pat || !*pat)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," strtmp = BCX_TmpStr(strlen(src));");
|
|
fprintf(Outfile,"%s\n"," if (!strtmp) return NULL;");
|
|
fprintf(Outfile,"%s\n"," return strcpy(strtmp, src);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," repsz = strlen(rep);");
|
|
fprintf(Outfile,"%s\n"," patsz = strlen(pat);");
|
|
fprintf(Outfile,"%s\n"," for (tmpsz=0, p=src; (q=_strstr_(p,pat))!=0; p=q+patsz)");
|
|
fprintf(Outfile,"%s\n"," tmpsz += (size_t) (q - p) + repsz;");
|
|
fprintf(Outfile,"%s\n"," tmpsz += strlen(p);");
|
|
fprintf(Outfile,"%s\n"," strtmp = BCX_TmpStr(tmpsz);");
|
|
fprintf(Outfile,"%s\n"," if (!strtmp) return NULL;");
|
|
fprintf(Outfile,"%s\n"," for (r=strtmp,p=src; (q=_strstr_(p,pat))!=0;p=q+patsz)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," delta = (size_t) (q-p);");
|
|
fprintf(Outfile,"%s\n"," memcpy(r,p,delta); r += delta;");
|
|
fprintf(Outfile,"%s\n"," strcpy(r,rep); r += repsz;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," strcpy(r,p);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Reverse)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *reverse (char *s)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int j=strlen(s);");
|
|
fprintf(Outfile,"%s\n"," char *rstr = BCX_TmpStr(j);");
|
|
fprintf(Outfile,"%s\n"," while(j) rstr[--j] = *(s++);");
|
|
fprintf(Outfile,"%s\n"," return rstr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Findfirst)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *findfirst (char *filespec, FILE_FIND_DATA *FindData)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," struct dirent *dp;");
|
|
fprintf(Outfile,"%s\n"," struct stat st;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if(FindData->FileHandle)");
|
|
fprintf(Outfile,"%s\n"," closedir(FindData->FileHandle);");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," strcpy(FindData->path, BcxSplitPath(filespec, FDRV|FPATH));");
|
|
fprintf(Outfile,"%s\n"," strcpy(FindData->cFileSpec,BcxSplitPath(filespec, FNAME|FEXT));");
|
|
fprintf(Outfile,"%s%s%s\n"," if(*FindData->path==0) strcpy(FindData->path, ",enc("."),");");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," FindData->FileHandle=opendir(FindData->path);");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," while(FindData->FileHandle)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," dp=readdir(FindData->FileHandle);");
|
|
fprintf(Outfile,"%s\n"," if(dp==NULL) break;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if(like(dp->d_name,FindData->cFileSpec))");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," strcpy(FindData->cFileName,dp->d_name);");
|
|
fprintf(Outfile,"%s\n"," lstat(join(2,FindData->path,dp->d_name), &st);");
|
|
fprintf(Outfile,"%s\n"," FindData->dwFileAttributes = st.st_mode;");
|
|
fprintf(Outfile,"%s\n"," return FindData->cFileName;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," *FindData->cFileName=0;");
|
|
fprintf(Outfile,"%s\n"," return FindData->cFileName;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Findnext)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *findnext (FILE_FIND_DATA *FindData)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," struct dirent *dp;");
|
|
fprintf(Outfile,"%s\n"," struct stat st;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," while(FindData->FileHandle)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," dp=readdir(FindData->FileHandle);");
|
|
fprintf(Outfile,"%s\n"," if(dp==NULL) break;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if(like(dp->d_name,FindData->cFileSpec))");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," strcpy(FindData->cFileName,dp->d_name);");
|
|
fprintf(Outfile,"%s\n"," lstat(join(2,FindData->path,dp->d_name), &st);");
|
|
fprintf(Outfile,"%s\n"," FindData->dwFileAttributes = st.st_mode;");
|
|
fprintf(Outfile,"%s\n"," return FindData->cFileName;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," *FindData->cFileName=0;");
|
|
fprintf(Outfile,"%s\n"," return FindData->cFileName;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Ucase)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *ucase (char *S)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(strlen(S));");
|
|
fprintf(Outfile,"%s\n"," return _strupr_(strcpy(strtmp,S));");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Lcase)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *lcase (char *S)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(strlen(S));");
|
|
fprintf(Outfile,"%s\n"," return _strlwr_(strcpy(strtmp,S));");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Mcase)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *mcase (char *S)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(strlen(S)+1);");
|
|
fprintf(Outfile,"%s\n"," char *s = strtmp;");
|
|
fprintf(Outfile,"%s\n"," _strlwr_(strcpy(strtmp,S));");
|
|
fprintf(Outfile,"%s\n"," while(*s)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(islower(*s))");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," *s-=32;");
|
|
fprintf(Outfile,"%s\n"," while(isalpha(*++s));");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," s++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Remove)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *RemoveStr (char *a, char *b)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp, *p, *d;");
|
|
fprintf(Outfile,"%s\n"," int tmplen;");
|
|
fprintf(Outfile,"%s\n"," strtmp = d = BCX_TmpStr(strlen(a));");
|
|
fprintf(Outfile,"%s\n"," if(!b || !*b) return strcpy(strtmp,a);");
|
|
fprintf(Outfile,"%s\n"," p=_strstr_(a,b); tmplen = strlen(b);");
|
|
fprintf(Outfile,"%s\n"," while(p)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," memcpy(d,a,p-a);");
|
|
fprintf(Outfile,"%s\n"," d+= (p-a);");
|
|
fprintf(Outfile,"%s\n"," a=p+tmplen;");
|
|
fprintf(Outfile,"%s\n"," p=_strstr_(a,b);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," strcpy(d,a);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_IRemove)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *IRemoveStr (char *a, char *b)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp, *p, *d;");
|
|
fprintf(Outfile,"%s\n"," int tmplen;");
|
|
fprintf(Outfile,"%s\n"," strtmp = d = BCX_TmpStr(strlen(a));");
|
|
fprintf(Outfile,"%s\n"," if(!b || !*b) return strcpy(strtmp,a);");
|
|
fprintf(Outfile,"%s\n"," p=_stristr_(a,b); tmplen = strlen(b);");
|
|
fprintf(Outfile,"%s\n"," while(p)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," memcpy(d,a,p-a);");
|
|
fprintf(Outfile,"%s\n"," d+= (p-a);");
|
|
fprintf(Outfile,"%s\n"," a=p+tmplen;");
|
|
fprintf(Outfile,"%s\n"," p=_stristr_(a,b);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," strcpy(d,a);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Ins)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *ins (char *S, int i, char *a)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int j = strlen(S);");
|
|
fprintf(Outfile,"%s\n"," if(i<1 || i>j+1) return S;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(j + strlen(a));");
|
|
fprintf(Outfile,"%s\n"," memcpy(strtmp,S,--i);");
|
|
fprintf(Outfile,"%s\n"," strcpy(&strtmp[i],a);");
|
|
fprintf(Outfile,"%s\n"," return strcat(strtmp,&S[i]);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Del)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *del (char *S, int i, int j)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int ln = strlen(S);");
|
|
fprintf(Outfile,"%s\n"," if(i<1 || i>ln) return S;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(ln);");
|
|
fprintf(Outfile,"%s\n"," memcpy(strtmp,S,--i);");
|
|
fprintf(Outfile,"%s\n"," return strcat(strtmp,&S[i+j]);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Str)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *str (double d)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(16);");
|
|
fprintf(Outfile,"%s%s%s\n"," sprintf(strtmp,",D1,",d);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Strl)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *strl (long double d)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(27);");
|
|
fprintf(Outfile,"%s%s%s\n"," sprintf(strtmp,",D2,",d);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Curdir)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *curdir (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(2048);");
|
|
fprintf(Outfile,"%s\n"," char *res=getcwd(strtmp, 1024);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Hex)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *hex (int a)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(16);");
|
|
fprintf(Outfile,"%s%s%s\n"," sprintf(strtmp,",enc("%02X"),",a);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Tempdir)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *tempdir (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(2048);");
|
|
fprintf(Outfile,"%s%s%s\n"," if(!Exist(",enc("/tmp/mbc.compiler"),")) {");
|
|
fprintf(Outfile,"%s%s%s\n"," mkdir (",enc("/tmp/mbc.compiler"),",0755);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s%s%s\n"," strcpy(strtmp,",enc("/tmp/mbc.compiler"),");");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Sysdir)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *sysdir (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(2048);");
|
|
fprintf(Outfile,"%s\n"," GetSystemDirectory (strtmp,2048);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Repeat)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *repeat (int count, char *a)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr((1+count)*strlen(a));");
|
|
fprintf(Outfile,"%s\n"," while(count-->0) strtmp = strcat(strtmp, a);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_String)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *stringx (int count, int a)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(count<1) return BCX_TmpStr(1);");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(count);");
|
|
fprintf(Outfile,"%s\n"," return (char*)memset(strtmp,a,count);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Shell)
|
|
{
|
|
fprintf(Outfile,"%s\n","void Shell (char *cmd)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int res=system(cmd);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Space)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *space (int count)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(count<1) return BCX_TmpStr(1);");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(count);");
|
|
fprintf(Outfile,"%s\n"," return (char*)memset(strtmp,32,count);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Time)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *timef (int t)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," time_t elapse_time;");
|
|
fprintf(Outfile,"%s\n"," struct tm *tp;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(256);");
|
|
fprintf(Outfile,"%s\n"," time (&elapse_time);");
|
|
fprintf(Outfile,"%s\n"," tp = localtime(&elapse_time);");
|
|
fprintf(Outfile,"%s\n"," switch (t)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," case 0:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T0,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 1:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T1,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 2:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T2,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 3:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T3,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 4:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T4,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 5:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T5,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 6:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T6,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 7:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T7,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 8:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T8,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 9:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T9,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 10:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T10,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 11:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T11,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 12:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T12,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," case 13:");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",T13,",tp); break;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Enclose)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *enc (char *A, int L, int R)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *BCX_RetStr = BCX_TmpStr(strlen(A)+3);");
|
|
fprintf(Outfile,"%s\n"," if(L==0) L=34;");
|
|
fprintf(Outfile,"%s\n"," if(R==0) R=L;");
|
|
fprintf(Outfile,"%s%s%s%s%s\n"," sprintf(BCX_RetStr,",enc("%c%s%c%s"),",L,A,R,",enc("\0"),");");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Chr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *chr (int a,int b,int c,int d,int e,int f,int g,int h,int i,int j)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(11);");
|
|
fprintf(Outfile,"%s\n"," strtmp[0] = a;");
|
|
fprintf(Outfile,"%s\n"," strtmp[1] = b;");
|
|
fprintf(Outfile,"%s\n"," strtmp[2] = c;");
|
|
fprintf(Outfile,"%s\n"," strtmp[3] = d;");
|
|
fprintf(Outfile,"%s\n"," strtmp[4] = e;");
|
|
fprintf(Outfile,"%s\n"," strtmp[5] = f;");
|
|
fprintf(Outfile,"%s\n"," strtmp[6] = g;");
|
|
fprintf(Outfile,"%s\n"," strtmp[7] = h;");
|
|
fprintf(Outfile,"%s\n"," strtmp[8] = i;");
|
|
fprintf(Outfile,"%s\n"," strtmp[9] = j;");
|
|
fprintf(Outfile,"%s\n"," strtmp[10] = 0;");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_VChr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *vchr(int charcount, ...)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int c = 0, i = charcount;");
|
|
fprintf(Outfile,"%s\n"," char *s_ = BCX_TmpStr(charcount + 1);");
|
|
fprintf(Outfile,"%s\n"," va_list marker;");
|
|
fprintf(Outfile,"%s\n"," s_[i] = 0;");
|
|
fprintf(Outfile,"%s\n"," va_start(marker, charcount);");
|
|
fprintf(Outfile,"%s\n"," while(i-- > 0) s_[c++] = va_arg(marker,int);");
|
|
fprintf(Outfile,"%s\n"," va_end(marker);");
|
|
fprintf(Outfile,"%s\n"," return s_;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Join)
|
|
{
|
|
fprintf(Outfile,"%s\n","char * join(int n, ...)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int i = n, tmplen = 0;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp, *s_;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," va_list marker;");
|
|
fprintf(Outfile,"%s\n"," va_start(marker, n); // Initialize variable arguments");
|
|
fprintf(Outfile,"%s\n"," while(i-- > 0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," s_ = va_arg(marker, char *);");
|
|
fprintf(Outfile,"%s\n"," if(s_) tmplen += strlen(s_);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," strtmp = BCX_TmpStr(tmplen);");
|
|
fprintf(Outfile,"%s\n"," va_end(marker); // Reset variable arguments");
|
|
fprintf(Outfile,"%s\n"," i = n;");
|
|
fprintf(Outfile,"%s\n"," va_start(marker, n); // Initialize variable arguments");
|
|
fprintf(Outfile,"%s\n"," while(i-- > 0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," s_ = va_arg(marker, char *);");
|
|
fprintf(Outfile,"%s\n"," if(s_) strcat(strtmp, s_);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," va_end(marker); // Reset variable arguments");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Environ)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* Environ(char *S)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp, *tmp;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," tmp = getenv(S);");
|
|
fprintf(Outfile,"%s\n"," if(tmp != NULL) {");
|
|
fprintf(Outfile,"%s\n"," strtmp = BCX_TmpStr(strlen(tmp)+1);");
|
|
fprintf(Outfile,"%s\n"," return strcpy(strtmp, tmp);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return BCX_TmpStr(1);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Oct)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *oct (int a)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(2048);");
|
|
fprintf(Outfile,"%s%s%s\n"," sprintf(strtmp,",O1,",a);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Bin)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* Bin(int number)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(2048);");
|
|
fprintf(Outfile,"%s\n"," itoa(number,strtmp,2);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Pause)
|
|
{
|
|
fprintf(Outfile,"%s\n","void Pause(void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s%s%s%s%s\n"," printf(",enc("\\n%s\\n"),",",enc("Press any key to continue . . ."),");");
|
|
fprintf(Outfile,"%s\n"," _getch_(TRUE);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Keypress)
|
|
{
|
|
fprintf(Outfile,"%s\n","int keypress(void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return _getch_(TRUE);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Inkey)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* inkey(void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(2);");
|
|
fprintf(Outfile,"%s\n"," strtmp[0] = _getch_(FALSE);");
|
|
fprintf(Outfile,"%s\n"," if(strtmp[0] == -1) strtmp[0] = 0;");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_InkeyD)
|
|
{
|
|
fprintf(Outfile,"%s\n","int inkeyd(void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return _getch_(TRUE);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Instat)
|
|
{
|
|
fprintf(Outfile,"%s\n","int kbhit(void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," struct termios oldt, newt;");
|
|
fprintf(Outfile,"%s\n"," int ch;");
|
|
fprintf(Outfile,"%s\n"," int oldf;");
|
|
fprintf(Outfile,"%s\n"," tcgetattr(STDIN_FILENO, &oldt);");
|
|
fprintf(Outfile,"%s\n"," newt = oldt;");
|
|
fprintf(Outfile,"%s\n"," newt.c_lflag &= ~(ICANON | ECHO);");
|
|
fprintf(Outfile,"%s\n"," tcsetattr(STDIN_FILENO, TCSANOW, &newt);");
|
|
fprintf(Outfile,"%s\n"," oldf = fcntl(STDIN_FILENO, F_GETFL, 0);");
|
|
fprintf(Outfile,"%s\n"," fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);");
|
|
fprintf(Outfile,"%s\n"," ch = getchar();");
|
|
fprintf(Outfile,"%s\n"," tcsetattr(STDIN_FILENO, TCSANOW, &oldt);");
|
|
fprintf(Outfile,"%s\n"," fcntl(STDIN_FILENO, F_SETFL, oldf);");
|
|
fprintf(Outfile,"%s\n"," if(ch != EOF)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," ungetc(ch, stdin);");
|
|
fprintf(Outfile,"%s\n"," return 1;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_GetCh)
|
|
{
|
|
fprintf(Outfile,"%s\n","int _getch_(int waitkey)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," struct termios initial_settings, new_settings;");
|
|
fprintf(Outfile,"%s\n"," unsigned char ch;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," tcgetattr(0,&initial_settings);");
|
|
fprintf(Outfile,"%s\n"," new_settings = initial_settings;");
|
|
fprintf(Outfile,"%s\n"," new_settings.c_lflag &= ~ICANON;");
|
|
fprintf(Outfile,"%s\n"," new_settings.c_lflag &= ~ECHO;");
|
|
fprintf(Outfile,"%s\n"," new_settings.c_lflag &= ~ISIG;");
|
|
fprintf(Outfile,"%s\n"," new_settings.c_cc[VMIN] = waitkey;");
|
|
fprintf(Outfile,"%s\n"," new_settings.c_cc[VTIME] = 0;");
|
|
fprintf(Outfile,"%s\n"," tcsetattr(0, TCSANOW, &new_settings);");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," //read(0,&ch,1);");
|
|
fprintf(Outfile,"%s\n"," ch = getchar();");
|
|
fprintf(Outfile,"%s\n"," tcsetattr(0, TCSANOW, &initial_settings);");
|
|
fprintf(Outfile,"%s\n"," return ch;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Now)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *now (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," time_t elapse_time;");
|
|
fprintf(Outfile,"%s\n"," struct tm *tp;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp = BCX_TmpStr(2048);");
|
|
fprintf(Outfile,"%s\n"," time(&elapse_time);");
|
|
fprintf(Outfile,"%s\n"," tp=localtime(&elapse_time);");
|
|
fprintf(Outfile,"%s%s%s\n"," strftime(strtmp,256,",enc("%m/%d/%y %I:%M:%S: %p"),",tp);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}");
|
|
}
|
|
if(Use_AppExePath)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *AppExePath (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char fullpath[MAX_PATH];");
|
|
fprintf(Outfile,"%s\n"," int length;");
|
|
#if defined (__APPLE__)
|
|
fprintf(Outfile,"%s\n"," pid_t pid = getpid();");
|
|
fprintf(Outfile,"%s\n"," length = proc_pidpath (pid, fullpath, sizeof(fullpath));");
|
|
#else
|
|
fprintf(Outfile,"%s%s%s\n"," length = readlink(",enc("/proc/self/exe"),", fullpath, MAX_PATH);");
|
|
#endif
|
|
fprintf(Outfile,"%s\n"," if(length < 1) return BCX_TmpStr(1);");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," fullpath[length] = 0;");
|
|
fprintf(Outfile,"%s\n"," return BcxSplitPath(fullpath, FDRV|FPATH);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_AppExeName)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *AppExeName (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return BcxSplitPath(G_argv[0], FNAME|FEXT);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_TempFileName)
|
|
{
|
|
fprintf(Outfile,"%s\n","char * TempFileName (char *dr, char *prefix)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static unsigned int count;");
|
|
fprintf(Outfile,"%s\n"," char *f, *tmpstr = BCX_TmpStr(MAX_PATH);");
|
|
fprintf(Outfile,"%s\n"," int i, length;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if(!count) srand(time(0));");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if(dr) strcpy(tmpstr, dr);");
|
|
fprintf(Outfile,"%s\n"," length = strlen(tmpstr);");
|
|
fprintf(Outfile,"%s\n"," if(length && (tmpstr[length-1] != '\\\\' && tmpstr[length-1] != '/'))");
|
|
fprintf(Outfile,"%s\n"," tmpstr[length++] = '/';");
|
|
fprintf(Outfile,"%s\n"," if(prefix) strcpy(&tmpstr[length], prefix);");
|
|
fprintf(Outfile,"%s\n"," f = &tmpstr[strlen(tmpstr)];");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," do {");
|
|
fprintf(Outfile,"%s\n"," count++;");
|
|
fprintf(Outfile,"%s\n"," for(i=0; i<5; i+=1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," do {");
|
|
fprintf(Outfile,"%s\n"," f[i]=(char)(rnd()*122);");
|
|
fprintf(Outfile,"%s\n"," }while((f[i]<65)||(f[i]>90&&f[i]<97));");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s%s%s\n"," snprintf(&f[5],3,",enc("%x"),", count);");
|
|
fprintf(Outfile,"%s\n"," } while (Exist(tmpstr));");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," return tmpstr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Boolstr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char * BoolStr (int a)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *BCX_RetStr=BCX_TmpStr(5);");
|
|
fprintf(Outfile,"%s%s%s\n"," if(a) return strcpy(BCX_RetStr,",enc("True"),");");
|
|
fprintf(Outfile,"%s%s%s\n"," return strcpy(BCX_RetStr,",enc("False"),");");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Using)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *Using (char *Mask, double Num)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int Spaces = 0;");
|
|
fprintf(Outfile,"%s\n"," int CntDec = 0;");
|
|
fprintf(Outfile,"%s\n"," int Decimals = 0;");
|
|
fprintf(Outfile,"%s\n"," int Dollar = 0;");
|
|
fprintf(Outfile,"%s\n"," char* BCX_RetStr = BCX_TmpStr(512);");
|
|
fprintf(Outfile,"%s\n"," char Buf_1[512]={0};");
|
|
fprintf(Outfile,"%s\n"," char* p = Mask;");
|
|
fprintf(Outfile,"%s\n"," char* r;");
|
|
fprintf(Outfile,"%s\n"," int len;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," while (*p)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if (*p == 36) Dollar++;");
|
|
fprintf(Outfile,"%s\n"," if (*p == 32) Spaces++;");
|
|
fprintf(Outfile,"%s\n"," if ((*p == 32 || *p == 35)&& CntDec) Decimals++;");
|
|
fprintf(Outfile,"%s\n"," if (*p == 46) CntDec = 1;");
|
|
fprintf(Outfile,"%s\n"," p++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s%s%s\n"," sprintf(Buf_1,",enc("%1.*f"),",Decimals,Num);");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," len = strlen(Buf_1)-Decimals-(Decimals>0?1:0);");
|
|
fprintf(Outfile,"%s\n"," r = BCX_RetStr+Dollar+Spaces;");
|
|
fprintf(Outfile,"%s\n"," p = Buf_1;");
|
|
fprintf(Outfile,"%s\n"," while (*p)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," *r++ = *p++;");
|
|
fprintf(Outfile,"%s\n"," if (--len>2 && *(p-1) != '-' && len % 3 == 0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," *r++ = ',';");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(Dollar) BCX_RetStr[Spaces]=36;");
|
|
fprintf(Outfile,"%s\n"," if(Spaces) memset(BCX_RetStr,32,Spaces);");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_SearchPath)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *SEARCHPATH (char *szFile)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *BCX_RetStr=BCX_TmpStr(MAX_PATH+1);");
|
|
fprintf(Outfile,"%s\n"," PCHAR lpbs=0;");
|
|
fprintf(Outfile,"%s\n"," SearchPath(0,szFile,0,MAX_PATH,BCX_RetStr,&lpbs);");
|
|
fprintf(Outfile,"%s\n"," if(lpbs) *lpbs=0;");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Instrrev)
|
|
{
|
|
fprintf(Outfile,"%s\n","int InstrRev (char *s, char *p, int os, int sens)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int sl, pl, ox;");
|
|
fprintf(Outfile,"%s\n"," int (*cmp)(const char *, const char *, size_t );");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (!s || !p) return 0;");
|
|
fprintf(Outfile,"%s\n"," sl = strlen(s); pl = strlen(p);");
|
|
fprintf(Outfile,"%s\n"," if (os > sl || sl == 0 || pl == 0 || (ox = sl - pl) < 0)");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (os <= 0) ");
|
|
fprintf(Outfile,"%s\n"," os = ox ;");
|
|
fprintf(Outfile,"%s\n"," else if(os >= pl)");
|
|
fprintf(Outfile,"%s\n"," os = os - pl ;");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," cmp = (sens ? strncasecmp : strncmp);");
|
|
fprintf(Outfile,"%s\n"," do { if (cmp(s + os , p, pl) == 0)");
|
|
fprintf(Outfile,"%s\n"," return os+1;");
|
|
fprintf(Outfile,"%s\n"," } while (os--);");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Instr)
|
|
{
|
|
fprintf(Outfile,"%s\n","int instr_b(char* mane,char* match,int offset,int sensflag)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *s;");
|
|
fprintf(Outfile,"%s\n"," if (!mane || !match || ! *match || offset>(int)strlen(mane)) return 0;");
|
|
fprintf(Outfile,"%s\n"," if (sensflag)");
|
|
fprintf(Outfile,"%s\n"," s = _stristr_(offset>0 ? mane+offset-1 : mane,match);");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," s = _strstr_(offset>0 ? mane+offset-1 : mane,match);");
|
|
fprintf(Outfile,"%s\n"," return s ? (int)(s-mane)+1 : 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(UseLCaseTbl)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *MakeLCaseTbl (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static char tbl[256];");
|
|
fprintf(Outfile,"%s\n"," if(!tbl['a'])");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," int i; for (i=0; i < 256; i++)");
|
|
fprintf(Outfile,"%s\n"," tbl[i] = (char)(int)tolower(i);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return tbl;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Stristr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *_stristr_(char *String, char *Pattern)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int mi=-1;");
|
|
fprintf(Outfile,"%s\n"," char *LowCase = MakeLCaseTbl();");
|
|
fprintf(Outfile,"%s\n"," while(Pattern[++mi])");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(String[mi]==0) return 0;");
|
|
fprintf(Outfile,"%s\n"," if(LowCase[(unsigned char)String[mi]]!=LowCase[(unsigned char)Pattern[mi]])");
|
|
fprintf(Outfile,"%s\n"," { String++; mi=-1; }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return String;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_StrStr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *_strstr_(char *String, char *Pattern)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int mi=-1;");
|
|
fprintf(Outfile,"%s\n"," while(Pattern[++mi])");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(String[mi]==0) return 0;");
|
|
fprintf(Outfile,"%s\n"," if(String[mi]!=Pattern[mi])");
|
|
fprintf(Outfile,"%s\n"," { String++; mi=-1; }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return String;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Inchr)
|
|
{
|
|
fprintf(Outfile,"%s\n","int inchr (char *A, char *B)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char* C=A;");
|
|
fprintf(Outfile,"%s\n"," while(*C)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(*C==*B) return C-A+1;");
|
|
fprintf(Outfile,"%s\n"," C++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Asc)
|
|
{
|
|
fprintf(Outfile,"%s\n","extern int asc (char *z,int index)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return (unsigned char) z[index];");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Sgn)
|
|
{
|
|
fprintf(Outfile,"%s\n","double sgn (double a)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(a<0) return -1;");
|
|
fprintf(Outfile,"%s\n"," if(a>0) return 1;");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Round)
|
|
{
|
|
fprintf(Outfile,"%s\n","double Round (double n, int d)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return (floor((n)*pow(10.0,(d))+0.5)/pow(10.0,(d)));");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Embed)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* GetResource (int *resource)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *BCX_RetStr={0};");
|
|
fprintf(Outfile,"%s\n"," static char* dat;");
|
|
fprintf(Outfile,"%s\n"," memset(&dat,0,sizeof(char *));");
|
|
fprintf(Outfile,"%s\n"," dat=(char*)resource;");
|
|
fprintf(Outfile,"%s\n"," BCX_RetStr=BCX_TmpStr(strlen(dat));");
|
|
fprintf(Outfile,"%s\n"," strcpy(BCX_RetStr,dat);");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Exist)
|
|
{
|
|
fprintf(Outfile,"%s\n","bool Exist (char *szFilePath)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int retstat;");
|
|
fprintf(Outfile,"%s\n"," struct stat sb;");
|
|
fprintf(Outfile,"%s\n"," retstat = stat(szFilePath, &sb);");
|
|
fprintf(Outfile,"%s\n"," if(retstat != -1)");
|
|
fprintf(Outfile,"%s\n"," return TRUE;");
|
|
fprintf(Outfile,"%s\n"," return FALSE;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Tally)
|
|
{
|
|
fprintf(Outfile,"%s\n","int tally (char *szLine, char *szChar, int sensflag)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(!*szChar) return 0;");
|
|
fprintf(Outfile,"%s\n"," int mlen = strlen(szChar);");
|
|
fprintf(Outfile,"%s\n"," int iCount = 0;");
|
|
fprintf(Outfile,"%s\n"," char *p = (sensflag == 0 ? _strstr_(szLine, szChar) : _stristr_(szLine, szChar));");
|
|
fprintf(Outfile,"%s\n"," while (p)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," iCount++;");
|
|
fprintf(Outfile,"%s\n"," p+=mlen;");
|
|
fprintf(Outfile,"%s\n"," p = (sensflag == 0 ? _strstr_(p, szChar) : _stristr_(p, szChar));");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return iCount;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Timer)
|
|
{
|
|
fprintf(Outfile,"%s\n","float timer (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return ((double)clock()/CLOCKS_PER_SEC);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Rnd)
|
|
{
|
|
fprintf(Outfile,"%s\n","float rnd (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return (float)rand()/RAND_MAX;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Exp)
|
|
{
|
|
fprintf(Outfile,"%s\n","double Exp (double arg)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return pow(2.718281828459045,arg);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Randomize)
|
|
{
|
|
fprintf(Outfile,"%s\n","void randomize (unsigned int seed)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," srand(seed);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Max)
|
|
{
|
|
fprintf(Outfile,"%s\n","double _MAX_ (double a, double b)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(a>b)");
|
|
fprintf(Outfile,"%s\n"," return a;");
|
|
fprintf(Outfile,"%s\n"," return b;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Min)
|
|
{
|
|
fprintf(Outfile,"%s\n","double _MIN_ (double a, double b)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(a<b)");
|
|
fprintf(Outfile,"%s\n"," return a;");
|
|
fprintf(Outfile,"%s\n"," return b;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Locate)
|
|
{
|
|
fprintf(Outfile,"%s\n","void locate (int row,int col,int show,int shape)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s%s\n"," printf(",enc("%c%s%u%s%u%s"),",27,",enc("["),",row,",enc(";"),",col,",enc("H"),");");
|
|
fprintf(Outfile,"%s\n"," // find cursor size/shape function!");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Cls)
|
|
{
|
|
fprintf(Outfile,"%s\n","void cls (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n"," printf(",enc("%s%s%s%s"),",ESC,",enc("[2J"),",ESC,",enc("[H"),");");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Color)
|
|
{
|
|
fprintf(Outfile,"%s\n","void color (int fg,int bg)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s%s%s\n"," printf(",enc("%c%s%u%s%u%s"),",27,",enc("["),",30+(fg&7),",enc(";"),",40+(bg&7),",enc("m"),");");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Midstr)
|
|
{
|
|
fprintf(Outfile,"%s\n","void midstr (char *src, int st, int length, char *rep)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int srclen = strlen(src);");
|
|
fprintf(Outfile,"%s\n"," if(st>srclen++ || st<1) return;");
|
|
fprintf(Outfile,"%s\n"," int replen = strlen(rep);");
|
|
fprintf(Outfile,"%s\n"," if(replen < length || length==-1) length=replen;");
|
|
fprintf(Outfile,"%s\n"," if((st+length) > srclen) length=srclen-st;");
|
|
fprintf(Outfile,"%s\n"," memcpy(&src[st-1],rep,length);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Swap)
|
|
{
|
|
fprintf(Outfile,"%s\n","void swap ( UCHAR* A, UCHAR* B, int length)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," UCHAR t;");
|
|
fprintf(Outfile,"%s\n"," while(length--)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," t = *A;");
|
|
fprintf(Outfile,"%s\n"," *(A++) = *B;");
|
|
fprintf(Outfile,"%s\n"," *(B++) = t;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Like)
|
|
{
|
|
fprintf(Outfile,"%s\n","int like (char *raw, char *pat)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char a, b, d;");
|
|
fprintf(Outfile,"%s\n"," char *r, *p;");
|
|
fprintf(Outfile,"%s\n"," int star = 0;");
|
|
fprintf(Outfile,"%s\n"," for(;;) {");
|
|
fprintf(Outfile,"%s\n"," if ((d = *pat++)==0) return (star || !*raw);");
|
|
fprintf(Outfile,"%s\n"," else if (d == '*') star = 1;");
|
|
fprintf(Outfile,"%s\n"," else if (d == '?') { if (!*raw++) return 0; }");
|
|
fprintf(Outfile,"%s\n"," else break;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," b = d;");
|
|
fprintf(Outfile,"%s\n"," do if ((a = *raw++) == b) {");
|
|
fprintf(Outfile,"%s\n"," r = raw;");
|
|
fprintf(Outfile,"%s\n"," p = pat;");
|
|
fprintf(Outfile,"%s\n"," do {");
|
|
fprintf(Outfile,"%s\n"," if ((d = *p++) == '*')");
|
|
fprintf(Outfile,"%s\n"," if (like(r, p - 1)) return 1;");
|
|
fprintf(Outfile,"%s\n"," else break;");
|
|
fprintf(Outfile,"%s\n"," else if (!d) {");
|
|
fprintf(Outfile,"%s\n"," if (!*r) return 1;");
|
|
fprintf(Outfile,"%s\n"," else break;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," } while (*r++ == d || d == '?');");
|
|
fprintf(Outfile,"%s\n"," } while (star && a);");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Lof)
|
|
{
|
|
fprintf(Outfile,"%s\n","DWORD lof (char *FileName)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," int retstat;");
|
|
fprintf(Outfile,"%s\n"," struct stat sb;");
|
|
fprintf(Outfile,"%s\n"," retstat = stat(FileName, &sb);");
|
|
fprintf(Outfile,"%s\n"," if(retstat != -1)");
|
|
fprintf(Outfile,"%s\n"," return sb.st_size;");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Iif)
|
|
{
|
|
fprintf(Outfile,"%s\n","double iif (bool cond, double tp, double fp)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(cond) return tp;");
|
|
fprintf(Outfile,"%s\n"," return fp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_sziif)
|
|
{
|
|
fprintf(Outfile,"%s\n","char * sziif (bool i, char *a, char *b)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(i) return a;");
|
|
fprintf(Outfile,"%s\n"," return b;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_DynamicA)
|
|
{
|
|
fprintf(Outfile,"%s\n","void *CreateArr(void *a, int elem_size, int update, int num_dims, ... )");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," va_list ap;");
|
|
fprintf(Outfile,"%s\n"," void *RetPtr;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," va_start(ap, num_dims);");
|
|
fprintf(Outfile,"%s\n"," RetPtr = CreateArr_internal(a, elem_size, update, num_dims, ap);");
|
|
fprintf(Outfile,"%s\n"," va_end(ap);");
|
|
fprintf(Outfile,"%s\n"," return (RetPtr);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
fprintf(Outfile,"%s\n","void *CreateArr_internal(void *a, int elem_size, int update, int num_dims, va_list ap)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," size_t s, s1, s2;");
|
|
fprintf(Outfile,"%s\n"," void **vp;");
|
|
fprintf(Outfile,"%s\n"," va_list marker;");
|
|
fprintf(Outfile,"%s\n"," ");
|
|
fprintf(Outfile,"%s\n","#ifdef va_copy");
|
|
fprintf(Outfile,"%s\n"," va_copy(marker, ap);");
|
|
fprintf(Outfile,"%s\n","#else");
|
|
fprintf(Outfile,"%s\n"," marker = ap;");
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
fprintf(Outfile,"%s\n"," s = va_arg(marker, size_t);");
|
|
fprintf(Outfile,"%s\n"," s2 = s + 2;");
|
|
fprintf(Outfile,"%s\n"," if(num_dims == 1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(update && a)");
|
|
fprintf(Outfile,"%s\n"," a=realloc(a,s2*elem_size);");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," a=calloc(s2,elem_size);");
|
|
fprintf(Outfile,"%s\n"," return a;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," if(update && a)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," s1 = 0;");
|
|
fprintf(Outfile,"%s\n"," vp = (void**)a;");
|
|
fprintf(Outfile,"%s\n"," while(*vp && s1 <= s)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," vp++;");
|
|
fprintf(Outfile,"%s\n"," s1++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(s1 > s)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," vp--;");
|
|
fprintf(Outfile,"%s\n"," DestroyArr(vp, num_dims, 0);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," a=realloc(a,s2*sizeof(int));");
|
|
fprintf(Outfile,"%s\n"," s1 = 0;");
|
|
fprintf(Outfile,"%s\n"," vp = (void**)a;");
|
|
fprintf(Outfile,"%s\n"," while(*vp && s1 <= s)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," vp++;");
|
|
fprintf(Outfile,"%s\n"," s1++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," while(s1 < s2)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," *(((int *)vp)) = 0;");
|
|
fprintf(Outfile,"%s\n"," vp++;");
|
|
fprintf(Outfile,"%s\n"," s1++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," a=calloc(s2*sizeof(int),1);");
|
|
fprintf(Outfile,"%s\n"," vp = (void**)a;");
|
|
fprintf(Outfile,"%s\n"," if(--num_dims > 0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," for(s1 = 0; s1 < s; s1++)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," vp[s1] = CreateArr_internal(vp[s1], elem_size, update, num_dims, marker);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return a;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
fprintf(Outfile,"%s\n","void DestroyArr (void** a,int num_dims, int top_free)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int i = 0;");
|
|
fprintf(Outfile,"%s\n"," static int s = 0;");
|
|
fprintf(Outfile,"%s\n"," if(num_dims == 1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," free(a);");
|
|
fprintf(Outfile,"%s\n"," return;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," s++;");
|
|
fprintf(Outfile,"%s\n"," num_dims--; ");
|
|
fprintf(Outfile,"%s\n"," while(a[i])");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," DestroyArr((void**)a[i], num_dims, top_free);");
|
|
fprintf(Outfile,"%s\n"," if(num_dims > 1)");
|
|
fprintf(Outfile,"%s\n"," free(a[i]);");
|
|
fprintf(Outfile,"%s\n"," a[i++]=NULL;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," s--;");
|
|
fprintf(Outfile,"%s\n"," if(s == 0 && top_free)");
|
|
fprintf(Outfile,"%s\n"," free(a);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Idxqsort)
|
|
{
|
|
fprintf(Outfile,"%s\n","int IdxCompare (const void *one, const void *two)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int *ptr1 = (int *)(one);");
|
|
fprintf(Outfile,"%s\n"," int *ptr2 = (int *)(two);");
|
|
fprintf(Outfile,"%s\n"," return strcasecmp (pppStr[Key][*ptr1],pppStr[Key][*ptr2]);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_IdxqsortSt)
|
|
{
|
|
fprintf(Outfile,"%s\n","int IdxCompareSt (const void* one, const void* two)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n","#define compare1 cmp1+(StructSize * (*(UINT *)(one)))");
|
|
fprintf(Outfile,"%s\n","#define compare2 cmp1+(StructSize * (*(UINT *)(two)))");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (Key==0)");
|
|
fprintf(Outfile,"%s\n"," return strcasecmp(compare1, compare2);");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (Key==1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if (*(int*)(compare1) < *(int*)(compare2)) return -1;");
|
|
fprintf(Outfile,"%s\n"," if (*(int*)(compare1) > *(int*)(compare2)) return 1;");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (Key==2)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if (*(double*)(compare1) < *(double*)(compare2)) return -1;");
|
|
fprintf(Outfile,"%s\n"," if (*(double*)(compare1) > *(double*)(compare2)) return 1;");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (Key==3)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if (*(UINT*)(compare1) < *(UINT*)(compare2)) return -1;");
|
|
fprintf(Outfile,"%s\n"," if (*(UINT*)(compare1) > *(UINT*)(compare2)) return 1;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","return 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_PtrqsortSt)
|
|
{
|
|
fprintf(Outfile,"%s\n","int PtrCompareSt (const void* one, const void* two)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n","#define pcompare1 ((char*)(one)+OffSet)");
|
|
fprintf(Outfile,"%s\n","#define pcompare2 ((char*)(two)+OffSet)");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (Key==0)");
|
|
fprintf(Outfile,"%s\n"," return strcasecmp(pcompare1, pcompare2);");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (Key==1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if (*(int*)(pcompare1) < *(int*)(pcompare2)) return -1;");
|
|
fprintf(Outfile,"%s\n"," if (*(int*)(pcompare1) > *(int*)(pcompare2)) return 1;");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (Key==2)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if (*(double*)(pcompare1) < *(double*)(pcompare2)) return -1;");
|
|
fprintf(Outfile,"%s\n"," if (*(double*)(pcompare1) > *(double*)(pcompare2)) return 1;");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (Key==3)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if (*(UINT*)(pcompare1) < *(UINT*)(pcompare2)) return -1;");
|
|
fprintf(Outfile,"%s\n"," if (*(UINT*)(pcompare1) > *(UINT*)(pcompare2)) return 1;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","return 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Strqsorta)
|
|
{
|
|
fprintf(Outfile,"%s\n","int StrCompareA (const void *arg1, const void *arg2)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *v1 = (char*) arg1;");
|
|
fprintf(Outfile,"%s\n"," char *v2 = (char*) arg2;");
|
|
fprintf(Outfile,"%s\n"," return strcasecmp (v1,v2);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Strqsortd)
|
|
{
|
|
fprintf(Outfile,"%s\n","int StrCompareD (const void *arg1, const void *arg2)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *v1 = (char*) arg1;");
|
|
fprintf(Outfile,"%s\n"," char *v2 = (char*) arg2;");
|
|
fprintf(Outfile,"%s\n"," return strcasecmp (v2,v1);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_DynStrqsorta)
|
|
{
|
|
fprintf(Outfile,"%s\n","int DynStrCompareA (const void *arg1, const void *arg2)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *v1 = *(char **) arg1;");
|
|
fprintf(Outfile,"%s\n"," char *v2 = *(char **) arg2;");
|
|
fprintf(Outfile,"%s\n"," return strcasecmp(v1, v2);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_DynStrqsortd)
|
|
{
|
|
fprintf(Outfile,"%s\n","int DynStrCompareD (const void *arg1, const void *arg2)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *v1 = *(char **) arg1;");
|
|
fprintf(Outfile,"%s\n"," char *v2 = *(char **) arg2;");
|
|
fprintf(Outfile,"%s\n"," return strcasecmp(v2, v1);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Numqsortaint)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareAint (const void *one, const void *two)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int *ptr1 = (int *)(one);");
|
|
fprintf(Outfile,"%s\n"," int *ptr2 = (int *)(two);");
|
|
fprintf(Outfile,"%s\n"," if (*ptr1 < *ptr2) return -1;");
|
|
fprintf(Outfile,"%s\n"," else if (*ptr1 == *ptr2) return 0;");
|
|
fprintf(Outfile,"%s\n"," else return 1;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Numqsortdint)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareDint (const void *one, const void *two)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int *ptr1 = (int *)(one);");
|
|
fprintf(Outfile,"%s\n"," int *ptr2 = (int *)(two);");
|
|
fprintf(Outfile,"%s\n"," if (*ptr1 > *ptr2) return -1;");
|
|
fprintf(Outfile,"%s\n"," else if (*ptr1 == *ptr2) return 0;");
|
|
fprintf(Outfile,"%s\n"," else return 1;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Numqsortafloat)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareAfloat (const void *one, const void *two)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," float *ptr1 = (float *)(one);");
|
|
fprintf(Outfile,"%s\n"," float *ptr2 = (float *)(two);");
|
|
fprintf(Outfile,"%s\n"," if (*ptr1 < *ptr2) return -1;");
|
|
fprintf(Outfile,"%s\n"," else if (*ptr1 == *ptr2) return 0;");
|
|
fprintf(Outfile,"%s\n"," else return 1;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Numqsortdfloat)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareDfloat (const void *one, const void *two)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," float *ptr1 = (float *)(one);");
|
|
fprintf(Outfile,"%s\n"," float *ptr2 = (float *)(two);");
|
|
fprintf(Outfile,"%s\n"," if (*ptr1 > *ptr2) return -1;");
|
|
fprintf(Outfile,"%s\n"," else if (*ptr1 == *ptr2) return 0;");
|
|
fprintf(Outfile,"%s\n"," else return 1;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Numqsortadouble)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareAdouble (const void *one, const void *two)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," double *ptr1 = (double *)(one);");
|
|
fprintf(Outfile,"%s\n"," double *ptr2 = (double *)(two);");
|
|
fprintf(Outfile,"%s\n"," if (*ptr1 < *ptr2) return -1;");
|
|
fprintf(Outfile,"%s\n"," else if (*ptr1 == *ptr2) return 0;");
|
|
fprintf(Outfile,"%s\n"," else return 1;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Numqsortddouble)
|
|
{
|
|
fprintf(Outfile,"%s\n","int NumCompareDdouble (const void *one, const void *two)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," double *ptr1 = (double *)(one);");
|
|
fprintf(Outfile,"%s\n"," double *ptr2 = (double *)(two);");
|
|
fprintf(Outfile,"%s\n"," if (*ptr1 > *ptr2) return -1;");
|
|
fprintf(Outfile,"%s\n"," else if (*ptr1 == *ptr2) return 0;");
|
|
fprintf(Outfile,"%s\n"," else return 1;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_FillArray)
|
|
{
|
|
fprintf(Outfile,"%s\n","int fillarray(char *input, int ArrayType, int MaxCnt, void *Array)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(MaxCnt < 1) return -1;");
|
|
fprintf(Outfile,"%s\n"," int c = 0, cnt=-1, cnt2;");
|
|
fprintf(Outfile,"%s\n"," char A[65535];");
|
|
fprintf(Outfile,"%s\n"," int *intptr = (int *)Array;");
|
|
fprintf(Outfile,"%s\n"," float *floatptr = (float *)Array;");
|
|
fprintf(Outfile,"%s\n"," double *doubleptr = (double *)Array;");
|
|
fprintf(Outfile,"%s\n"," long double *ldoubleptr = (long double *)Array;");
|
|
fprintf(Outfile,"%s\n"," for(;;)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," cnt2=0;");
|
|
fprintf(Outfile,"%s\n"," while(input[++cnt]!=',')");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(input[cnt]==0) break;");
|
|
fprintf(Outfile,"%s\n"," A[cnt2++]=input[cnt];");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," A[cnt2]=0;");
|
|
fprintf(Outfile,"%s\n"," if(cnt2==0||c==MaxCnt) break;");
|
|
fprintf(Outfile,"%s\n"," ");
|
|
fprintf(Outfile,"%s\n"," if(ArrayType==2)");
|
|
fprintf(Outfile,"%s\n"," intptr[c++] = atoi(A);");
|
|
fprintf(Outfile,"%s\n"," else if(ArrayType==3)");
|
|
fprintf(Outfile,"%s\n"," floatptr[c++] = atof(A);");
|
|
fprintf(Outfile,"%s\n"," else if(ArrayType==4)");
|
|
fprintf(Outfile,"%s\n"," doubleptr[c++] = atof(A);");
|
|
fprintf(Outfile,"%s\n"," else if(ArrayType==5)");
|
|
fprintf(Outfile,"%s\n"," ldoubleptr[c++] = atof(A);");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if(input[cnt]==0) break;");
|
|
fprintf(Outfile,"%s\n"," } ");
|
|
fprintf(Outfile,"%s\n"," return (c-1);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Loc)
|
|
{
|
|
fprintf(Outfile,"%s\n","int loc(FILE *fp, int fplen)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," fpos_t t;");
|
|
fprintf(Outfile,"%s\n"," fgetpos(fp, &t);");
|
|
fprintf(Outfile,"%s\n","#if defined( __POCC__ )");
|
|
fprintf(Outfile,"%s\n"," t.off %= fplen;");
|
|
fprintf(Outfile,"%s\n"," return (int)t.off;");
|
|
fprintf(Outfile,"%s\n","#else");
|
|
fprintf(Outfile,"%s\n"," t %= fplen;");
|
|
fprintf(Outfile,"%s\n"," return (int)t;");
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Rec)
|
|
{
|
|
fprintf(Outfile,"%s\n","int rec(FILE *fp, int fplen)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," fpos_t t;");
|
|
fprintf(Outfile,"%s\n"," fgetpos(fp, &t);");
|
|
fprintf(Outfile,"%s\n","#if defined( __POCC__ )");
|
|
fprintf(Outfile,"%s\n"," t.off /= fplen;");
|
|
fprintf(Outfile,"%s\n"," return (int)++t.off;");
|
|
fprintf(Outfile,"%s\n","#else");
|
|
fprintf(Outfile,"%s\n"," t /= fplen;");
|
|
fprintf(Outfile,"%s\n"," return (int)++t;");
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_RecCount)
|
|
{
|
|
fprintf(Outfile,"%s\n","int reccount(FILE *fp, int fplen)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," fpos_t t;");
|
|
fprintf(Outfile,"%s\n"," fseek(fp,0,SEEK_END);");
|
|
fprintf(Outfile,"%s\n"," fgetpos(fp, &t);");
|
|
fprintf(Outfile,"%s\n","#if defined( __POCC__ )");
|
|
fprintf(Outfile,"%s\n"," t.off /= fplen;");
|
|
fprintf(Outfile,"%s\n"," return (int)t.off;");
|
|
fprintf(Outfile,"%s\n","#else");
|
|
fprintf(Outfile,"%s\n"," t /= fplen;");
|
|
fprintf(Outfile,"%s\n"," return (int)t;");
|
|
fprintf(Outfile,"%s\n","#endif");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Scan)
|
|
{
|
|
fprintf(Outfile,"%s\n","int scan(char *input, char *format, ... )");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int c,d ;");
|
|
fprintf(Outfile,"%s\n"," char *s_;");
|
|
fprintf(Outfile,"%s\n"," int *intptr;");
|
|
fprintf(Outfile,"%s\n"," float *floatptr;");
|
|
fprintf(Outfile,"%s\n"," double *doubleptr;");
|
|
fprintf(Outfile,"%s\n"," char A[50][65535];");
|
|
fprintf(Outfile,"%s\n"," va_list marker;");
|
|
fprintf(Outfile,"%s\n"," c = 0;");
|
|
fprintf(Outfile,"%s%s%s\n"," d = Split(A,input,",enc(","),");");
|
|
fprintf(Outfile,"%s\n"," va_start(marker, format); //Initialize arguments");
|
|
fprintf(Outfile,"%s\n"," while(d && *format)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(*format == '%') format++;");
|
|
fprintf(Outfile,"%s\n"," if(*format == 's')");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," s_ = va_arg(marker, char *);");
|
|
fprintf(Outfile,"%s\n"," strcpy(s_, A[c]);");
|
|
fprintf(Outfile,"%s\n"," c++;");
|
|
fprintf(Outfile,"%s\n"," d--;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(*format == 'd')");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," intptr = va_arg(marker, int *);");
|
|
fprintf(Outfile,"%s\n"," *intptr = atoi(A[c]);");
|
|
fprintf(Outfile,"%s\n"," c++;");
|
|
fprintf(Outfile,"%s\n"," d--;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(*format == 'g')");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," floatptr = va_arg(marker, float *);");
|
|
fprintf(Outfile,"%s\n"," *floatptr = atof(A[c]);");
|
|
fprintf(Outfile,"%s\n"," c++;");
|
|
fprintf(Outfile,"%s\n"," d--;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(*format == 'l')");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," format++;");
|
|
fprintf(Outfile,"%s\n"," doubleptr = va_arg(marker, double *);");
|
|
fprintf(Outfile,"%s\n"," *doubleptr = atof(A[c]);");
|
|
fprintf(Outfile,"%s\n"," c++;");
|
|
fprintf(Outfile,"%s\n"," d--;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," format++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," va_end(marker); // Reset variable arguments");
|
|
fprintf(Outfile,"%s\n"," if(d) return(1); // More data than variables");
|
|
fprintf(Outfile,"%s\n"," if(*format == 0) return(0); // OK");
|
|
fprintf(Outfile,"%s\n"," return(-1); // More variables than data");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Split)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Split (char Buf[][65535], char *T, char *Delim, int Flg)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int Begin = 0;");
|
|
fprintf(Outfile,"%s\n"," int Count = 0;");
|
|
fprintf(Outfile,"%s\n"," int Quote = 0;");
|
|
fprintf(Outfile,"%s\n"," int Index,i;");
|
|
fprintf(Outfile,"%s\n"," int lenT = strlen(T);");
|
|
fprintf(Outfile,"%s\n"," char Chr34[2]={34,0};");
|
|
fprintf(Outfile,"%s\n"," for(Index=1;Index<=lenT;Index++)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(instr_b(Delim,mid(T,Index,1))&&!Quote)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," strcpy(Buf[Count],(char*)mid(T,Begin,Index-Begin));");
|
|
fprintf(Outfile,"%s\n"," if ((Flg & 2) == 0) // 0 if old version");
|
|
fprintf(Outfile,"%s\n"," Count++;");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," if (Buf[Count][0] != 0) Count++;");
|
|
fprintf(Outfile,"%s\n"," Begin=0;");
|
|
fprintf(Outfile,"%s\n"," if((Flg & 1) == 1) // 1 if true");
|
|
fprintf(Outfile,"%s\n"," strcpy(Buf[Count++],(char*)mid(T,Index,1));");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(strcmp(mid(T,Index,1),Chr34)==0) Quote=!Quote;");
|
|
fprintf(Outfile,"%s\n"," if(Begin==0) Begin=Index;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(Begin)");
|
|
fprintf(Outfile,"%s\n"," strcpy(Buf[Count++],(char*)mid(T,Begin,Index-Begin));");
|
|
fprintf(Outfile,"%s\n"," if((Flg & 1) == 0) // 0 if false");
|
|
fprintf(Outfile,"%s\n"," for(i=0;i<Count;i++) strcpy(Buf[i],(char*)RemoveStr(Buf[i],Chr34));");
|
|
fprintf(Outfile,"%s\n"," return Count;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_DSplit)
|
|
{
|
|
fprintf(Outfile,"%s\n","int DSplit (PCHAR *Buf, char *T, char *Delim, int Flg)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int Begin=0;");
|
|
fprintf(Outfile,"%s\n"," int Count=0;");
|
|
fprintf(Outfile,"%s\n"," int Quote=0;");
|
|
fprintf(Outfile,"%s\n"," int Index=0;");
|
|
fprintf(Outfile,"%s\n"," int lenT = strlen(T);");
|
|
fprintf(Outfile,"%s\n"," char Chr34[2]={34,0};");
|
|
fprintf(Outfile,"%s\n"," for(Index=1;Index<=lenT;Index++)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(instr_b(Delim,mid(T,Index,1))&&!Quote)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," strcpy(Buf[Count],(char*)mid(T,Begin,Index-Begin));");
|
|
fprintf(Outfile,"%s\n"," if ((Flg & 2) == 0) // 0 if old version");
|
|
fprintf(Outfile,"%s\n"," Count++;");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," if (Buf[Count][0] != 0) Count++;");
|
|
fprintf(Outfile,"%s\n"," Begin=0;");
|
|
fprintf(Outfile,"%s\n"," if((Flg & 1) == 1) // 1 if true");
|
|
fprintf(Outfile,"%s\n"," strcpy(Buf[Count++],(char*)mid(T,Index,1));");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(strcmp(mid(T,Index,1),Chr34)==0) Quote=!Quote;");
|
|
fprintf(Outfile,"%s\n"," if(Begin==0) Begin=Index;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(Begin) strcpy(Buf[Count++],(char*)mid(T,Begin,Index-Begin));");
|
|
fprintf(Outfile,"%s\n"," if((Flg & 1) == 0) // 0 if false");
|
|
fprintf(Outfile,"%s\n"," for(Index=0;Index<Count;Index++) strcpy(Buf[Index],(char*)RemoveStr(Buf[Index],Chr34));");
|
|
fprintf(Outfile,"%s\n"," return Count;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Bin2dec)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Bin2Dec (char *cptr)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int i, j = 0;");
|
|
fprintf(Outfile,"%s%s%s\n"," while(cptr && *cptr && strchr(",enc("01"),", *cptr))");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," i = *cptr++ - '0';");
|
|
fprintf(Outfile,"%s\n"," j <<= 1;");
|
|
fprintf(Outfile,"%s\n"," j |= (i & 0x01);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return(j);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Hex2Dec)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Hex2Dec (char *szInput)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char ch;");
|
|
fprintf(Outfile,"%s\n"," char *dwLen = szInput+strlen(szInput);");
|
|
fprintf(Outfile,"%s\n"," char *LowCase = MakeLCaseTbl();");
|
|
fprintf(Outfile,"%s\n"," DWORD dwOut = 0;");
|
|
fprintf(Outfile,"%s\n"," while(*szInput)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," ch = LowCase[(unsigned char)*szInput++];");
|
|
fprintf(Outfile,"%s\n"," if((ch >= 'a' && ch <= 'f') || (ch >= '0' && ch <= '9'))");
|
|
fprintf(Outfile,"%s\n"," dwOut |=((int)ch - (ch>'9' ? 'a'-10 : '0')) << ((dwLen - szInput) << 2);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return dwOut;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Verify)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Verify (char *Src, char *Allowed)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int i, j;");
|
|
fprintf(Outfile,"%s\n"," for (i=1; i<=strlen(Src); i++)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," j=VerifyInstr(Allowed,mid(Src,i,1));");
|
|
fprintf(Outfile,"%s\n"," if (!j) return 0;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return TRUE;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
fprintf(Outfile,"%s\n","int VerifyInstr(char* mane,char* match,int offset)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *s;");
|
|
fprintf(Outfile,"%s\n"," if (!mane || !match || !*match || offset>(int)strlen(mane)) return 0;");
|
|
fprintf(Outfile,"%s\n"," s = strstr (offset>0 ? mane+offset-1 : mane,match);");
|
|
fprintf(Outfile,"%s\n"," return s ? (int)(s-mane)+1 : 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Retain)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *Retain (char *Text, char *ValidChars)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *BCX_RetStr=BCX_TmpStr(strlen(Text));");
|
|
fprintf(Outfile,"%s\n"," char *temp=BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n"," while(*Text)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(strchr(ValidChars,*Text)) *(temp++) = *Text;");
|
|
fprintf(Outfile,"%s\n"," Text++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_LoadFile)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* LoadFile (char *N)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," FILE* FP1;");
|
|
fprintf(Outfile,"%s\n"," char* BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n"," if(Exist(N))");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," BCX_RetStr=BCX_TmpStr(lof(N));");
|
|
fprintf(Outfile,"%s%s%s\n"," if((FP1=fopen(N,",enc("rb"),"))!=0)");
|
|
fprintf(Outfile,"%s\n"," GET(FP1,BCX_RetStr,lof(N));");
|
|
fprintf(Outfile,"%s\n"," fclose(FP1);");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," BCX_RetStr=BCX_TmpStr(64);");
|
|
fprintf(Outfile,"%s%s%s\n"," return strcpy(BCX_RetStr,",enc("File Not Found"),");");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Freefile)
|
|
{
|
|
fprintf(Outfile,"%s\n","FILE* FreeFile (void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static FILE *pf;");
|
|
fprintf(Outfile,"%s\n"," if(pf){free(pf);pf=NULL;}");
|
|
fprintf(Outfile,"%s\n"," pf = (FILE*)calloc(sizeof(FILE*),sizeof(FILE*));");
|
|
fprintf(Outfile,"%s\n"," return pf;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Run)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Run (char* Cmdline, int ShowHide, int WaitState)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int processId;");
|
|
fprintf(Outfile,"%s\n"," char *s, *p, *cmd_line;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," cmd_line=(char*)malloc(strlen(Cmdline)+1);");
|
|
fprintf(Outfile,"%s\n"," if(cmd_line==NULL) return -2;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," strcpy(cmd_line, Cmdline);");
|
|
fprintf(Outfile,"%s\n"," p = s = cmd_line;");
|
|
fprintf(Outfile,"%s\n"," processId=fork();");
|
|
fprintf(Outfile,"%s\n"," if(processId==0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," PCHAR argv[30];");
|
|
fprintf(Outfile,"%s\n"," int i=0;");
|
|
fprintf(Outfile,"%s\n"," while(*p)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(*p==34)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," while(*(++p)!=34) {}");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(*p==32)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," while(*(p+1)==32) p++;");
|
|
fprintf(Outfile,"%s\n"," argv[i++]=s;");
|
|
fprintf(Outfile,"%s\n"," *p=0; s=p+1;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," p++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," argv[i] = s;");
|
|
fprintf(Outfile,"%s\n"," argv[i+1]= 0;");
|
|
fprintf(Outfile,"%s\n"," execvp(argv[0],argv);");
|
|
fprintf(Outfile,"%s%s%s\n"," printf(",enc("Failed to run%s\\n"),",argv[0]);");
|
|
fprintf(Outfile,"%s\n"," exit(-1);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," else if(processId!=-1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(WaitState) waitpid(processId,NULL,0);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," waitpid(-1,NULL,WNOHANG);");
|
|
fprintf(Outfile,"%s\n"," free(cmd_line), cmd_line=NULL;");
|
|
fprintf(Outfile,"%s\n"," return processId;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Download)
|
|
{
|
|
fprintf(Outfile,"%s\n","int Download (char *URL,char *Localname)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int RetVal;");
|
|
fprintf(Outfile,"%s\n"," return RetVal=!RetVal;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_PeekStr)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *peekstr (LPVOID Src, int Count)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *Des=BCX_TmpStr(Count);");
|
|
fprintf(Outfile,"%s\n"," memmove(Des,Src,Count);");
|
|
fprintf(Outfile,"%s\n"," return Des;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_QBColor)
|
|
{
|
|
fprintf(Outfile,"%s\n","int qbcolor (int N)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," switch (N)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," case 0 : return RGB(0,0,0);");
|
|
fprintf(Outfile,"%s\n"," case 1 : return RGB(0,0,128);");
|
|
fprintf(Outfile,"%s\n"," case 2 : return RGB(0,128,0);");
|
|
fprintf(Outfile,"%s\n"," case 3 : return RGB(0,128,128);");
|
|
fprintf(Outfile,"%s\n"," case 4 : return RGB(196,0,0);");
|
|
fprintf(Outfile,"%s\n"," case 5 : return RGB(128,0,128);");
|
|
fprintf(Outfile,"%s\n"," case 6 : return RGB(128,64,0);");
|
|
fprintf(Outfile,"%s\n"," case 7 : return RGB(196,196,196);");
|
|
fprintf(Outfile,"%s\n"," case 8 : return RGB(128,128,128);");
|
|
fprintf(Outfile,"%s\n"," case 9 : return RGB(0,0, 255);");
|
|
fprintf(Outfile,"%s\n"," case 10 : return RGB(0,255,0);");
|
|
fprintf(Outfile,"%s\n"," case 11 : return RGB(0,255,255);");
|
|
fprintf(Outfile,"%s\n"," case 12 : return RGB(255,0,0);");
|
|
fprintf(Outfile,"%s\n"," case 13 : return RGB(255,0,255);");
|
|
fprintf(Outfile,"%s\n"," case 14 : return RGB(255,255,0);");
|
|
fprintf(Outfile,"%s\n"," case 15 : return RGB(255,255,255);");
|
|
fprintf(Outfile,"%s\n"," case 16 : return RGB(164,164,164);");
|
|
fprintf(Outfile,"%s\n"," case 17 : return RGB(128,160,255);");
|
|
fprintf(Outfile,"%s\n"," case 18 : return RGB(160,255,160);");
|
|
fprintf(Outfile,"%s\n"," case 19 : return RGB(160,255,255);");
|
|
fprintf(Outfile,"%s\n"," case 20 : return RGB(255,160,160);");
|
|
fprintf(Outfile,"%s\n"," case 21 : return RGB(255,160,255);");
|
|
fprintf(Outfile,"%s\n"," case 22 : return RGB(255,255,160);");
|
|
fprintf(Outfile,"%s\n"," case 23 : return RGB(212,212,212);");
|
|
fprintf(Outfile,"%s\n"," case 24 : return RGB(180,180,180);");
|
|
fprintf(Outfile,"%s\n"," case 25 : return RGB(188,220,255);");
|
|
fprintf(Outfile,"%s\n"," case 26 : return RGB(220,255,220);");
|
|
fprintf(Outfile,"%s\n"," case 27 : return RGB(220,255,255);");
|
|
fprintf(Outfile,"%s\n"," case 28 : return RGB(255,220,220);");
|
|
fprintf(Outfile,"%s\n"," case 29 : return RGB(255,220,255);");
|
|
fprintf(Outfile,"%s\n"," case 30 : return RGB(255,255,220);");
|
|
fprintf(Outfile,"%s\n"," case 31 : return RGB(228,228,228);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","return 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Cvi)
|
|
{
|
|
fprintf(Outfile,"%s\n","short CVI (char *s)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return ((short*)s)[0];");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Mki)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *MKI (short cvt)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static char temp[3];");
|
|
fprintf(Outfile,"%s\n"," return (char *)memmove(temp,&cvt,2);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Cvl)
|
|
{
|
|
fprintf(Outfile,"%s\n","long CVL (char *s)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return ((long*)s)[0];");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Mkl)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *MKL (int cvt)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static char temp[5];");
|
|
fprintf(Outfile,"%s\n"," return (char *) memmove(temp,&cvt,4);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Cvs)
|
|
{
|
|
fprintf(Outfile,"%s\n","float CVS (char *s)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return ((float*)s)[0];");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Mks)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *MKS (float cvt)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static char temp[5];");
|
|
fprintf(Outfile,"%s\n"," return (char *) memmove(temp,&cvt,4);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Cvd)
|
|
{
|
|
fprintf(Outfile,"%s\n","double CVD (char *s)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return ((double*)s)[0];");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Cvld)
|
|
{
|
|
fprintf(Outfile,"%s\n","long double CVLD (char *s)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return ((long double*)s)[0];");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Mkd)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *MKD (double cvt)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static char temp[9];");
|
|
fprintf(Outfile,"%s\n"," return (char *) memmove(temp,&cvt,8);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Mkld)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *MKLD (long double cvt)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static char temp[11];");
|
|
fprintf(Outfile,"%s\n"," return (char *) memmove(temp,&cvt,10);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_BcxSplitPath)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *BcxSplitPath (char *FPath, int mask)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," if(!FPath) return BCX_TmpStr(1);");
|
|
fprintf(Outfile,"%s\n"," char *BCX_RetStr=BCX_TmpStr(strlen(FPath));");
|
|
fprintf(Outfile,"%s\n"," char tmp[MAX_PATH*4];");
|
|
fprintf(Outfile,"%s\n"," _splitpath_(FPath,tmp,&tmp[MAX_PATH],&tmp[MAX_PATH*2],&tmp[MAX_PATH*3]);");
|
|
fprintf(Outfile,"%s\n"," if(mask & FDRV) strcat(BCX_RetStr,tmp);");
|
|
fprintf(Outfile,"%s\n"," if(mask & FPATH)strcat(BCX_RetStr,&tmp[MAX_PATH]);");
|
|
fprintf(Outfile,"%s\n"," if(mask & FNAME)strcat(BCX_RetStr,&tmp[MAX_PATH*2]);");
|
|
fprintf(Outfile,"%s\n"," if(mask & FEXT) strcat(BCX_RetStr,&tmp[MAX_PATH*3]);");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
fprintf(Outfile,"%s\n"," void _splitpath_(const char* path, char* drv, char* dir, char* name, char* ext)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," const char* pend; /* end of processed string */");
|
|
fprintf(Outfile,"%s\n"," const char* p; /* search pointer */");
|
|
fprintf(Outfile,"%s\n"," const char* s; /* copy pointer */");
|
|
fprintf(Outfile,"%s\n"," ");
|
|
fprintf(Outfile,"%s\n"," /* extract drive name */");
|
|
fprintf(Outfile,"%s\n"," if (path[0] && path[1]==':') {");
|
|
fprintf(Outfile,"%s\n"," if (drv) {");
|
|
fprintf(Outfile,"%s\n"," *drv++ = *path++;");
|
|
fprintf(Outfile,"%s\n"," *drv++ = *path++;");
|
|
fprintf(Outfile,"%s\n"," *drv = 0;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," } else if (drv)");
|
|
fprintf(Outfile,"%s\n"," *drv = 0;");
|
|
fprintf(Outfile,"%s\n"," ");
|
|
fprintf(Outfile,"%s\n"," /* search for end of string or stream separator */");
|
|
fprintf(Outfile,"%s\n"," for(pend=path; *pend && *pend!=':'; )");
|
|
fprintf(Outfile,"%s\n"," pend++;");
|
|
fprintf(Outfile,"%s\n"," ");
|
|
fprintf(Outfile,"%s\n"," /* search for begin of file extension */");
|
|
fprintf(Outfile,"%s\n"," for(p=pend; p > path && *--p != '\\\\' && *p!='/'; )");
|
|
fprintf(Outfile,"%s\n"," if (*p == '.') {");
|
|
fprintf(Outfile,"%s\n"," pend = p;");
|
|
fprintf(Outfile,"%s\n"," break;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," ");
|
|
fprintf(Outfile,"%s\n"," if (ext)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," s=pend;");
|
|
fprintf(Outfile,"%s\n"," do{ *ext++ = *s; } while(*s++);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," /* search for end of directory name */");
|
|
fprintf(Outfile,"%s\n"," for(p=pend; p > path; )");
|
|
fprintf(Outfile,"%s\n"," if (*--p == '\\\\' || *p == '/') {");
|
|
fprintf(Outfile,"%s\n"," p++;");
|
|
fprintf(Outfile,"%s\n"," break;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," ");
|
|
fprintf(Outfile,"%s\n"," if (name) {");
|
|
fprintf(Outfile,"%s\n"," for(s=p; s<pend; )");
|
|
fprintf(Outfile,"%s\n"," *name++ = *s++;");
|
|
fprintf(Outfile,"%s\n"," ");
|
|
fprintf(Outfile,"%s\n"," *name = 0;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," ");
|
|
fprintf(Outfile,"%s\n"," if (dir) {");
|
|
fprintf(Outfile,"%s\n"," for(s=path; s<p; )");
|
|
fprintf(Outfile,"%s\n"," *dir++ = *s++;");
|
|
fprintf(Outfile,"%s\n"," ");
|
|
fprintf(Outfile,"%s\n"," *dir = 0;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }\n");
|
|
}
|
|
if(Use_StrUpLow)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *_strupr_(char *string)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *s;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (string)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," for(s = string; *s; ++s)");
|
|
fprintf(Outfile,"%s\n"," *s = toupper(*s);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return string;");
|
|
fprintf(Outfile,"%s\n","}\n");
|
|
fprintf(Outfile,"%s\n","char *_strlwr_(char *string)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *s;");
|
|
fprintf(Outfile,"%s\n","");
|
|
fprintf(Outfile,"%s\n"," if (string)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," for (s = string; *s; ++s)");
|
|
fprintf(Outfile,"%s\n"," *s = tolower(*s);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return string;");
|
|
fprintf(Outfile,"%s\n","}\n");
|
|
}
|
|
if(Use_Strtoken)
|
|
{
|
|
fprintf(Outfile,"%s\n","char * StrToken (char *Source, char *TokenChar, int n)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *BCX_RetStr={0};");
|
|
fprintf(Outfile,"%s\n"," char *RetVal;");
|
|
fprintf(Outfile,"%s\n"," char *Copy;");
|
|
fprintf(Outfile,"%s\n"," int Posn=0;");
|
|
fprintf(Outfile,"%s\n"," int Find=0;");
|
|
fprintf(Outfile,"%s\n"," int LenSrc=strlen(Source);");
|
|
fprintf(Outfile,"%s\n"," RetVal=(char*)calloc(LenSrc+1,1);");
|
|
fprintf(Outfile,"%s\n"," Copy=Source;");
|
|
fprintf(Outfile,"%s\n"," if(tally(Source,TokenChar)==0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," BCX_RetStr=BCX_TmpStr(1);");
|
|
fprintf(Outfile,"%s\n"," if(RetVal)free(RetVal);");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(n==1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," BCX_RetStr=BCX_TmpStr(LenSrc);");
|
|
fprintf(Outfile,"%s\n"," strcpy(BCX_RetStr,(char*)extract(Source,TokenChar));");
|
|
fprintf(Outfile,"%s\n"," if(RetVal)free(RetVal);");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(n>tally(Source,TokenChar)+1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," BCX_RetStr=BCX_TmpStr(1);");
|
|
fprintf(Outfile,"%s\n"," if(RetVal)free(RetVal);");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," while(*Copy)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(*Copy==TokenChar[0]) Find++;");
|
|
fprintf(Outfile,"%s\n"," if(Find==n) break;");
|
|
fprintf(Outfile,"%s\n"," Copy++;");
|
|
fprintf(Outfile,"%s\n"," Posn++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(n==tally(Source,TokenChar)+1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," Posn=LenSrc;");
|
|
fprintf(Outfile,"%s\n"," Copy=Source+Posn;");
|
|
fprintf(Outfile,"%s\n"," while(*Copy&&Source[Posn]!=TokenChar[0])");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," Posn--;");
|
|
fprintf(Outfile,"%s\n"," Copy--;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," strcpy(RetVal,(char*)mid(Source,1,Posn));");
|
|
fprintf(Outfile,"%s\n"," strcpy(RetVal,(char*)mid(RetVal,InstrRev(RetVal,TokenChar)));");
|
|
fprintf(Outfile,"%s\n"," BCX_RetStr=BCX_TmpStr(LenSrc);");
|
|
fprintf(Outfile,"%s\n"," strcpy(BCX_RetStr,(char*)RemoveStr(RetVal,TokenChar));");
|
|
fprintf(Outfile,"%s\n"," if(RetVal)free(RetVal);");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_iReplace)
|
|
{
|
|
fprintf(Outfile,"%s\n","char *iReplace (char *src, char *pat, char *rep)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," size_t patsz, repsz, tmpsz, delta;");
|
|
fprintf(Outfile,"%s\n"," char *strtmp, *p, *q, *r;");
|
|
fprintf(Outfile,"%s\n"," if (!pat || !*pat)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," strtmp = BCX_TmpStr(strlen(src));");
|
|
fprintf(Outfile,"%s\n"," if (!strtmp) return NULL;");
|
|
fprintf(Outfile,"%s\n"," return strcpy(strtmp, src);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," repsz = strlen(rep);");
|
|
fprintf(Outfile,"%s\n"," patsz = strlen(pat);");
|
|
fprintf(Outfile,"%s\n"," for (tmpsz=0, p=src;(q=_stristr_(p,pat))!=0; p=q+patsz)");
|
|
fprintf(Outfile,"%s\n"," tmpsz += (size_t) (q - p) + repsz;");
|
|
fprintf(Outfile,"%s\n"," tmpsz += strlen(p);");
|
|
fprintf(Outfile,"%s\n"," strtmp = BCX_TmpStr(tmpsz);");
|
|
fprintf(Outfile,"%s\n"," if (!strtmp) return NULL;");
|
|
fprintf(Outfile,"%s\n"," for (r=strtmp,p=src;(q=_stristr_(p,pat))!=0;p=q+patsz)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," delta = (size_t) (q-p);");
|
|
fprintf(Outfile,"%s\n"," memcpy(r,p,delta); r += delta;");
|
|
fprintf(Outfile,"%s\n"," strcpy(r,rep); r += repsz;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," strcpy(r,p);");
|
|
fprintf(Outfile,"%s\n"," return strtmp;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_WideToAnsi)
|
|
{
|
|
fprintf(Outfile,"%s\n","char* WideToAnsi (wchar_t *WideStr, UINT CodePage,DWORD dwFlags)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," char *BCX_RetStr={0};");
|
|
fprintf(Outfile,"%s\n"," UINT uLen;");
|
|
fprintf(Outfile,"%s\n"," uLen=wcstombs(NULL, WideStr, 0); //WideCharToMultiByte(CodePage,dwFlags,WideStr,-1,0,0,0,0);");
|
|
fprintf(Outfile,"%s\n"," BCX_RetStr=(char*)BCX_TmpStr(uLen);");
|
|
fprintf(Outfile,"%s\n"," wcstombs(BCX_RetStr, WideStr, uLen); //WideCharToMultiByte(CodePage,dwFlags,WideStr,-1,BCX_RetStr,uLen,0,0);");
|
|
fprintf(Outfile,"%s\n"," return BCX_RetStr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_SysStr)
|
|
{
|
|
fprintf(Outfile,"%s\n","BSTR SysStr (char * szIn, int widstr, int bfree)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static BSTR bStr[32];");
|
|
fprintf(Outfile,"%s\n"," static int index;");
|
|
fprintf(Outfile,"%s\n"," if(bfree)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," for(index=0; index<32; index+=1) ");
|
|
fprintf(Outfile,"%s\n"," SysFreeString(bStr[index]);");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," index=(++index & 31);");
|
|
fprintf(Outfile,"%s\n"," SysFreeString(bStr[index]);");
|
|
fprintf(Outfile,"%s\n"," int length=strlen(szIn);");
|
|
fprintf(Outfile,"%s\n"," if(widstr)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," bStr[index]=SysAllocStringLen(NULL, (2*length));");
|
|
fprintf(Outfile,"%s\n"," MultiByteToWideChar(CP_ACP,0,szIn,-1,bStr[index],(2*length+1));");
|
|
fprintf(Outfile,"%s\n"," }else{");
|
|
fprintf(Outfile,"%s\n"," bStr[index]=SysAllocStringByteLen(szIn, length);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return bStr[index];");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_AnsiToWide)
|
|
{
|
|
fprintf(Outfile,"%s\n","wchar_t *AnsiToWide (char *AnsiStr, UINT CodePage,DWORD dwFlags)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," UINT uLen;");
|
|
fprintf(Outfile,"%s\n"," wchar_t *WideStr;");
|
|
fprintf(Outfile,"%s\n"," uLen=mbstowcs(NULL, AnsiStr, 0); //MultiByteToWideChar(CodePage,dwFlags,AnsiStr,-1,0,0);");
|
|
fprintf(Outfile,"%s\n"," if(uLen<=1) return (wchar_t*)BCX_TmpStr(2);");
|
|
fprintf(Outfile,"%s\n"," WideStr = (wchar_t*)BCX_TmpStr(2*uLen);");
|
|
fprintf(Outfile,"%s\n"," mbstowcs(WideStr, AnsiStr, uLen); //MultiByteToWideChar(CodePage,dwFlags,AnsiStr,uLen,WideStr,uLen);");
|
|
fprintf(Outfile,"%s\n"," return WideStr;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_FileLocked)
|
|
{
|
|
fprintf(Outfile,"%s\n","int FileLocked (char *Filename)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s%s%s\n"," FILE *FP=fopen(Filename,",enc("rb+"),");");
|
|
fprintf(Outfile,"%s\n"," if(FP==0) return 1;");
|
|
fprintf(Outfile,"%s\n"," fclose(FP);");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_ContainedIn)
|
|
{
|
|
fprintf(Outfile,"%s\n","int containedin(char * Token,char **Contain ,int c)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," int i=0;");
|
|
fprintf(Outfile,"%s\n"," while(Contain[i][0])");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if(0 == ((c == 0 || c == 2) ? strcmp(Contain[i],Token) : strcasecmp(Contain[i],Token)))");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," return ((c < 2) ? 0 : i);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," i++;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return -1;");
|
|
fprintf(Outfile,"%s\n"," }\n\n");
|
|
}
|
|
if(Use_FindInType)
|
|
{
|
|
fprintf(Outfile,"%s\n","int FindInType(char *Token,char *StOffset,int StSize,int start,int finish,int c,int *idx)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," int j;");
|
|
fprintf(Outfile,"%s\n"," char *Srch;");
|
|
fprintf(Outfile,"%s\n"," int (*cmp)(const char*,const char*);");
|
|
fprintf(Outfile,"%s\n"," cmp = ((c == 0 || c == 2) ? strcmp : strcasecmp);");
|
|
fprintf(Outfile,"%s\n"," for(j=start; j<=finish; j++)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," Srch = StOffset + ((idx==0) ? j*StSize : idx[j]*StSize);");
|
|
fprintf(Outfile,"%s\n"," if(cmp(Srch,Token)==0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," return ((c < 2) ? 0 : j);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return -1;");
|
|
fprintf(Outfile,"%s\n"," }\n\n");
|
|
}
|
|
if(Use_StartupCode)
|
|
{
|
|
fprintf(Outfile,"%s\n","int BCX_StartupCode_(void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
{int i;
|
|
for(i=1; i<=StartNdx; i+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n"," ",StartSub[i],"();");
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n"," return 1;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_ExitCode)
|
|
{
|
|
fprintf(Outfile,"%s\n","int BCX_ExitCode_(void)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
{int i;
|
|
for(i=1; i<=ExitNdx; i+=1)
|
|
{
|
|
fprintf(Outfile,"%s%s%s\n"," atexit(",ExitSub[i],");");
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s\n"," return 1;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_Socket)
|
|
{
|
|
fprintf(Outfile,"%s\n","sockaddr_in sock_addr (char *ServerName,int port)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," in_addr iaHost;");
|
|
fprintf(Outfile,"%s\n"," hostent* lpHostEntry;");
|
|
fprintf(Outfile,"%s\n"," sockaddr_in saServer;");
|
|
fprintf(Outfile,"%s\n"," iaHost.s_addr=inet_addr(ServerName);");
|
|
fprintf(Outfile,"%s\n"," if(iaHost.s_addr==INADDR_NONE)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," lpHostEntry=gethostbyname(ServerName);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," lpHostEntry=gethostbyaddr((char*)&iaHost,sizeof(in_addr),AF_INET);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," if(lpHostEntry==NULL)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s%s%s\n"," printf(",enc("Error! HOST NOT FOUND: %s\\n"),", ServerName);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," saServer.sin_port=htons(port);");
|
|
fprintf(Outfile,"%s\n"," saServer.sin_family=AF_INET;");
|
|
fprintf(Outfile,"%s\n"," saServer.sin_addr=*(in_addr*)lpHostEntry->h_addr;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return saServer;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
fprintf(Outfile,"%s\n","int connect_socket (sockaddr_in saServer)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," int Socket, nRet;");
|
|
fprintf(Outfile,"%s\n"," Socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);");
|
|
fprintf(Outfile,"%s\n"," if(Socket==-1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," return Socket;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," nRet=connect(Socket,(sockaddr*)&saServer,sizeof(sockaddr_in));");
|
|
fprintf(Outfile,"%s\n"," if(nRet==-1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," close(Socket);");
|
|
fprintf(Outfile,"%s\n"," return nRet;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return Socket;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
fprintf(Outfile,"%s\n","int BcxSocket (char *ServerName,int port)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," sockaddr_in saServer;");
|
|
fprintf(Outfile,"%s\n"," saServer=sock_addr(ServerName,port);");
|
|
fprintf(Outfile,"%s\n"," return connect_socket(saServer);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
fprintf(Outfile,"%s\n","int BcxSocketSend (int Socket, char *szBuffer)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static int nRet;");
|
|
fprintf(Outfile,"%s\n"," nRet=send(Socket,szBuffer,strlen(szBuffer),0);");
|
|
fprintf(Outfile,"%s\n"," if(nRet==-1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," close(Socket);");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," return nRet;");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
fprintf(Outfile,"%s\n","int BcxSocketRead (int Socket, char *szBuffer)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," return read(Socket,szBuffer,strlen(szBuffer));");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
fprintf(Outfile,"%s\n","void BcxSocketClose(int Socket) {");
|
|
fprintf(Outfile,"%s\n"," close(Socket);");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
if(Use_RegEx)
|
|
{
|
|
fprintf(Outfile,"%s\n","bool regmatch (char *buffer, char *pattern, REGEX* retval)");
|
|
fprintf(Outfile,"%s\n","{");
|
|
fprintf(Outfile,"%s\n"," static int t;");
|
|
fprintf(Outfile,"%s\n"," static int i;");
|
|
fprintf(Outfile,"%s\n"," static regex_t re;");
|
|
fprintf(Outfile,"%s\n"," t=regcomp( &re,pattern,REG_ICASE|REG_EXTENDED);");
|
|
fprintf(Outfile,"%s\n"," if(t)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," regerror(t, &re,buffer,sizeof(buffer));");
|
|
fprintf(Outfile,"%s%s%s\n"," printf(",enc("regex error: %s %s"),",buffer,pattern);");
|
|
fprintf(Outfile,"%s\n"," return 0;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," t=regexec( &re,buffer,1023,(*retval).matches,0);");
|
|
fprintf(Outfile,"%s\n"," (*retval).count=re.re_nsub;");
|
|
fprintf(Outfile,"%s\n"," if(!t)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," for(i=1; i<=(*retval).count; i+=1)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," if((*retval).matches[i].rm_so>=0)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," (*retval).results[i]=peekstr( &buffer[(*retval).matches[i].rm_so],((*retval).matches[i].rm_eo-(*retval).matches[i].rm_so));");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," regfree( &re);");
|
|
fprintf(Outfile,"%s\n"," if(!t)");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," return TRUE;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n"," else");
|
|
fprintf(Outfile,"%s\n"," {");
|
|
fprintf(Outfile,"%s\n"," return FALSE;");
|
|
fprintf(Outfile,"%s\n"," }");
|
|
fprintf(Outfile,"%s\n","}\n\n");
|
|
}
|
|
}
|
|
|
|
|
|
int JoinLines (char *Arg)
|
|
{
|
|
if(iMatchRgt(Arg," _"))
|
|
{
|
|
Arg[strlen(Arg)-1]=0;
|
|
strcat(CurLine,Arg);
|
|
return 1;
|
|
}
|
|
if(*CurLine!=0)
|
|
{
|
|
strcpy(Arg, join(2,CurLine,Arg));
|
|
*CurLine=0;
|
|
}
|
|
UmQt=FALSE;
|
|
return 0;
|
|
}
|
|
|
|
|
|
void StripCode (char *Arg)
|
|
{
|
|
PCHAR p;
|
|
PCHAR p2=Arg;
|
|
int asmFlag=0;
|
|
int eStr=0;
|
|
char sub_[2048];
|
|
while((*p2>8&&*p2<14)||*p2==32)
|
|
{
|
|
p2++;
|
|
}
|
|
if(*p2==33)
|
|
{
|
|
asmFlag=!UmQt;
|
|
}
|
|
p=p2;
|
|
while(*p)
|
|
{
|
|
if(*p==9)
|
|
{
|
|
*p=32;
|
|
}
|
|
if(*p==34)
|
|
{
|
|
if(*(p-1)==69)
|
|
{
|
|
*(p-1)=1;
|
|
eStr=TRUE;
|
|
}
|
|
while(*(++p)!=34)
|
|
{
|
|
if(*p==92&&eStr)
|
|
{
|
|
*p=2;
|
|
for(;;)
|
|
{
|
|
if(*(p+1)==48)
|
|
{
|
|
*(p+1)=3;
|
|
break;
|
|
}
|
|
if(*(p+1)==116)
|
|
{
|
|
*(p+1)=4;
|
|
break;
|
|
}
|
|
if(*(p+1)==110)
|
|
{
|
|
*(p+1)=5;
|
|
break;
|
|
}
|
|
if(*(p+1)==114)
|
|
{
|
|
*(p+1)=6;
|
|
break;
|
|
}
|
|
if(*(p+1)==113)
|
|
{
|
|
*(p+1)=7;
|
|
break;
|
|
}
|
|
if(*(p+1)==92)
|
|
{
|
|
*(p+1)=8;
|
|
}
|
|
break;
|
|
}
|
|
p++;
|
|
}
|
|
if(*p==0)
|
|
{
|
|
UmQt=!UmQt;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(!UmQt&&!asmFlag)
|
|
{
|
|
if((*p BOR 32)==114)
|
|
{
|
|
if((*(p+1) BOR 32)==101&&(*(p+2) BOR 32)==109&&(*(p+3)==32||*(p+3)==0))
|
|
{
|
|
if(p==p2||*(p-1)==58||*(p-1)==32)
|
|
{
|
|
*p=0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(*p==39||(*p==47&&*(p+1)==47))
|
|
{
|
|
*p=0;
|
|
break;
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
while(p2<p)
|
|
{
|
|
while((*(p-1)>8&&*(p-1)<14)||*(p-1)==32)
|
|
{
|
|
*(--p)=0;
|
|
}
|
|
if(UmQt||asmFlag)
|
|
{
|
|
break;
|
|
}
|
|
if(*(p-1)==58&&*(p-2)==32)
|
|
{
|
|
p--;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if(eStr)
|
|
{
|
|
strcpy(p2,replace(p2,chr(1),""));
|
|
strcpy(p2,replace(p2,chr(2),""));
|
|
strcpy(sub_, join(3,DQ,"+CHR$(0)+",DQ));
|
|
strcpy(p2,replace(p2,chr(3),sub_));
|
|
strcpy(sub_, join(3,DQ,"+CHR$(9)+",DQ));
|
|
strcpy(p2,replace(p2,chr(4),sub_));
|
|
strcpy(sub_, join(3,DQ,"+CHR$(10)+",DQ));
|
|
strcpy(p2,replace(p2,chr(5),sub_));
|
|
strcpy(sub_, join(3,DQ,"+CHR$(13)+",DQ));
|
|
strcpy(p2,replace(p2,chr(6),sub_));
|
|
strcpy(sub_, join(3,DQ,"+CHR$(34)+",DQ));
|
|
strcpy(p2,replace(p2,chr(7),sub_));
|
|
strcpy(sub_, join(3,DQ,"+CHR$(92)+",DQ));
|
|
strcpy(p2,replace(p2,chr(8),sub_));
|
|
strcpy(p2,replace(p2,(join(3,chr(34),chr(34),chr(43))),""));
|
|
strcpy(p2,replace(p2,(join(3,chr(43),chr(34),chr(34))),""));
|
|
}
|
|
memcpy(Arg,p2,strlen(p2)+1);
|
|
}
|
|
|
|
|
|
void ProcSingleLineIf (int* ifFlag)
|
|
{
|
|
char Tmp[2048];
|
|
int ifp;
|
|
int NdIfs;
|
|
static int EFlag;
|
|
if((*ifFlag)==0)
|
|
{
|
|
EFlag=0;
|
|
}
|
|
|
|
REDO:;
|
|
if(SplitCnt>120)
|
|
{
|
|
Abort("Stack Overflow - Too many statements on one line");
|
|
}
|
|
strcpy(Tmp, join(2,SplitStk[SplitCnt],SPC));
|
|
if(iMatchLft(Tmp,"if "))
|
|
{
|
|
ifp=iMatchNQ(Tmp," then ");
|
|
if(ifp)
|
|
{
|
|
strcpy(SplitStk[SplitCnt++],left(Tmp,ifp+4));
|
|
strcpy(SplitStk[SplitCnt],ltrim(Tmp+ifp+4));
|
|
EFlag=_MAX_(0,EFlag-1);
|
|
(*ifFlag)++;
|
|
goto REDO;
|
|
}
|
|
}
|
|
else if((*ifFlag))
|
|
{
|
|
if(iMatchLft(Tmp,"else "))
|
|
{
|
|
|
|
LFTLSE:;
|
|
if(++EFlag>1)
|
|
{
|
|
NdIfs=_MAX_(1,(*ifFlag)-1);
|
|
(*ifFlag)=1;
|
|
EFlag=0;
|
|
if(iMatchWrd(SplitStk[SplitCnt-1],"else"))
|
|
{
|
|
SplitCnt--;
|
|
}
|
|
{int BCX_REPEAT;
|
|
for(BCX_REPEAT=1;BCX_REPEAT<=NdIfs;BCX_REPEAT++)
|
|
{
|
|
strcpy(SplitStk[SplitCnt++],"END IF");
|
|
}
|
|
}
|
|
}
|
|
strcpy(SplitStk[SplitCnt++],"ELSE");
|
|
strcpy(SplitStk[SplitCnt],trim(Tmp+4));
|
|
goto REDO;
|
|
}
|
|
else
|
|
{
|
|
ifp=iMatchNQ(Tmp," else ");
|
|
if(ifp)
|
|
{
|
|
strcpy(SplitStk[SplitCnt++],rtrim(left(Tmp,ifp-1)));
|
|
strcpy(Tmp,mid(Tmp,ifp+1));
|
|
goto LFTLSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int SplitLines (char *Arg)
|
|
{
|
|
PCHAR p=Arg;
|
|
PCHAR st=Arg;
|
|
int i=0;
|
|
int IfFlag=0;
|
|
int SpcolonFlag=0;
|
|
int ParaCnt=0;
|
|
if(*p==33||*p==36)
|
|
{
|
|
return 0;
|
|
}
|
|
while(*p)
|
|
{
|
|
if(*p==32)
|
|
{
|
|
SpcolonFlag=1;
|
|
}
|
|
if(*p==34)
|
|
{
|
|
while(*(++p)!=34)
|
|
{
|
|
if(*p==0)
|
|
{
|
|
return SplitCnt;
|
|
}
|
|
}
|
|
}
|
|
if(*p==40)
|
|
{
|
|
ParaCnt++;
|
|
}
|
|
if(*p==41)
|
|
{
|
|
ParaCnt--;
|
|
}
|
|
if(*p==58&&*(p+1)!=61)
|
|
{
|
|
if(*(p+1)==58)
|
|
{
|
|
*p=-15;
|
|
*(p+1)=-15;
|
|
}
|
|
else
|
|
{
|
|
if(*(p+1)!=0||SpcolonFlag)
|
|
{
|
|
while(*st==32)
|
|
{
|
|
st++;
|
|
}
|
|
SplitCnt++;
|
|
while(st<p)
|
|
{
|
|
SplitStk[SplitCnt][i++]=*(st++);
|
|
}
|
|
while(SplitStk[SplitCnt][i-1]==32)
|
|
{
|
|
i--;
|
|
}
|
|
SplitStk[SplitCnt][i]=0;
|
|
if(ParaCnt==0)
|
|
{
|
|
i=0;
|
|
st++;
|
|
ProcSingleLineIf( &IfFlag);
|
|
}
|
|
else
|
|
{
|
|
SplitCnt--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
if(SplitCnt>0)
|
|
{
|
|
while(*st==32)
|
|
{
|
|
st++;
|
|
}
|
|
SplitCnt++;
|
|
while(*st)
|
|
{
|
|
SplitStk[SplitCnt][i++]=*(st++);
|
|
}
|
|
SplitStk[SplitCnt][i]=0;
|
|
ProcSingleLineIf( &IfFlag);
|
|
}
|
|
else if(iMatchLft(Arg,"if ")&&!iMatchRgt(Arg," then"))
|
|
{
|
|
strcpy(SplitStk[++SplitCnt],Arg);
|
|
ProcSingleLineIf( &IfFlag);
|
|
}
|
|
if(IfFlag)
|
|
{
|
|
while(IfFlag)
|
|
{
|
|
strcpy(SplitStk[++SplitCnt],"END IF");
|
|
IfFlag--;
|
|
}
|
|
}
|
|
return SplitCnt;
|
|
}
|
|
|
|
|
|
int iMatch (char *Arg, char *MatchStr, int mt)
|
|
{
|
|
if(mt==2)
|
|
{
|
|
int L1;
|
|
int L2;
|
|
L1=strlen(Arg);
|
|
L2=strlen(MatchStr);
|
|
if(L1<L2)
|
|
{
|
|
return 0;
|
|
}
|
|
Arg=(Arg+L1)-L2;
|
|
}
|
|
while(*MatchStr)
|
|
{
|
|
if(*Arg==0)
|
|
{
|
|
return 0;
|
|
}
|
|
if((*Arg BOR 32)!=(*MatchStr BOR 32))
|
|
{
|
|
return 0;
|
|
}
|
|
Arg++;
|
|
MatchStr++;
|
|
}
|
|
if(mt&&*Arg!=0)
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
int iMatchNQ (char *Arg, char *MatchStr)
|
|
{
|
|
int mi=0;
|
|
PCHAR a=Arg;
|
|
while(MatchStr[mi])
|
|
{
|
|
if(*a==34)
|
|
{
|
|
mi=0;
|
|
while(*(++a)!=34)
|
|
{
|
|
if(*a==0)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
if(a[mi]==0)
|
|
{
|
|
return 0;
|
|
}
|
|
if((a[mi] BOR 32)!=(MatchStr[mi] BOR 32))
|
|
{
|
|
a++;
|
|
mi=-1;
|
|
}
|
|
mi++;
|
|
}
|
|
return (a-Arg)+1;
|
|
}
|
|
|
|
|
|
int SpecialCaseHandler (char *Arg)
|
|
{
|
|
int i;
|
|
int j;
|
|
char lsz[2048];
|
|
if(iMatchNQ(Arg," sub ")||iMatchNQ(Arg," function "))
|
|
{
|
|
return 0;
|
|
}
|
|
if(iMatchNQ(Arg,"function main("))
|
|
{
|
|
strcpy(SrcStk[++SrcCnt],Arg);
|
|
strcpy(SrcStk[++SrcCnt],"G_argc = argc");
|
|
strcpy(SrcStk[++SrcCnt],"G_argv = argv");
|
|
goto PROCESSNEW;
|
|
}
|
|
strcpy(lsz, join(3,SPC,extract(Arg," "),SPC));
|
|
if(iMatchNQ(" dim , local , global , raw , static , shared , dynamic , auto , register , extern ",lsz))
|
|
{
|
|
FastLexer(Arg," ",",(){}");
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"as"))
|
|
{
|
|
strcpy(Stk[i-1],Clean(Stk[i-1]));
|
|
}
|
|
}
|
|
strcpy(Stk[2], join(3,SPC,Stk[2],SPC));
|
|
if(iMatchNQ(" raw local dynamic register static shared auto ",Stk[2]))
|
|
{
|
|
strcpy(Stk[1], join(2,Stk[1],Stk[2]));
|
|
*Stk[2]=0;
|
|
}
|
|
SrcCnt++;
|
|
j=0;
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(Stk[i][0]==40)
|
|
{
|
|
j++;
|
|
}
|
|
if(Stk[i][0]==123)
|
|
{
|
|
j++;
|
|
}
|
|
if(Stk[i][0]==41)
|
|
{
|
|
j--;
|
|
}
|
|
if(Stk[i][0]==125)
|
|
{
|
|
j--;
|
|
}
|
|
if(Stk[i][0]==44&&!j)
|
|
{
|
|
strcpy(Stk[i],Stk[1]);
|
|
SrcCnt++;
|
|
}
|
|
strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt],Stk[i]," "));
|
|
}
|
|
goto PROCESSNEW;
|
|
}
|
|
for(;;)
|
|
{
|
|
if(TRUE==iMatchLft(Arg,"on "))
|
|
{
|
|
int Target;
|
|
j=0;
|
|
FastLexer(Arg," ",",");
|
|
for(i=1; i<=Ndx; i+=1)
|
|
{
|
|
if(iMatchLft(Stk[i],"gosub")||iMatchLft(Stk[i],"goto")||iMatchLft(Stk[i],"call"))
|
|
{
|
|
Target=i+1;
|
|
break;
|
|
}
|
|
}
|
|
strcpy(SrcStk[++SrcCnt],"select case ");
|
|
for(i=2; i<=Target-2; i+=1)
|
|
{
|
|
strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt]," ",Stk[i]));
|
|
}
|
|
for(i=Target; i<=Ndx; i+=1)
|
|
{
|
|
if(str_cmp(Stk[i],",")==0)
|
|
{
|
|
continue;
|
|
}
|
|
j++;
|
|
strcpy(SrcStk[++SrcCnt], join(2,"case",str(j)));
|
|
strcpy(SrcStk[++SrcCnt], join(3,Stk[Target-1]," ",Stk[i]));
|
|
}
|
|
strcpy(SrcStk[++SrcCnt],"end select");
|
|
goto PROCESSNEW;
|
|
}
|
|
if(TRUE==iMatchLft(Arg,"loop "))
|
|
{
|
|
FastLexer(Arg," ",",()");
|
|
if(iMatchLft(Stk[2],"until"))
|
|
{
|
|
strcpy(SrcStk[++SrcCnt],"if ");
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt],Stk[i]," "));
|
|
}
|
|
strcpy(SrcStk[SrcCnt], join(2,SrcStk[SrcCnt]," then"));
|
|
strcpy(SrcStk[++SrcCnt],"exit loop");
|
|
strcpy(SrcStk[++SrcCnt],"end if");
|
|
strcpy(SrcStk[++SrcCnt],"loop");
|
|
goto PROCESSNEW;
|
|
}
|
|
else if(iMatchLft(Stk[2],"while"))
|
|
{
|
|
strcpy(SrcStk[++SrcCnt],"if NOT (");
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt],Stk[i]," "));
|
|
}
|
|
strcpy(SrcStk[SrcCnt], join(2,SrcStk[SrcCnt],") then"));
|
|
strcpy(SrcStk[++SrcCnt],"exit loop");
|
|
strcpy(SrcStk[++SrcCnt],"end if");
|
|
strcpy(SrcStk[++SrcCnt],"loop");
|
|
goto PROCESSNEW;
|
|
}
|
|
else
|
|
{
|
|
if(Ndx>1)
|
|
{
|
|
Abort(join(3,"UNKNOWN Word ",Stk[2]," After LOOP"));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if(TRUE==iMatchLft(Arg,"do "))
|
|
{
|
|
FastLexer(Arg," ",",()");
|
|
if(iMatchLft(Stk[2],"until"))
|
|
{
|
|
strcpy(SrcStk[++SrcCnt],"do");
|
|
strcpy(SrcStk[++SrcCnt],"if ");
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt],Stk[i]," "));
|
|
}
|
|
strcpy(SrcStk[SrcCnt], join(2,SrcStk[SrcCnt],"then"));
|
|
strcpy(SrcStk[++SrcCnt],"exit loop");
|
|
strcpy(SrcStk[++SrcCnt],"end if");
|
|
goto PROCESSNEW;
|
|
}
|
|
else if(iMatchLft(Stk[2],"while"))
|
|
{
|
|
strcpy(SrcStk[++SrcCnt],"while ");
|
|
for(i=3; i<=Ndx; i+=1)
|
|
{
|
|
strcpy(SrcStk[SrcCnt], join(3,SrcStk[SrcCnt],Stk[i]," "));
|
|
}
|
|
goto PROCESSNEW;
|
|
}
|
|
else
|
|
{
|
|
if(Ndx>1)
|
|
{
|
|
Abort(join(3,"UNKNOWN Word ",Stk[2]," After DO"));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return 0;
|
|
|
|
PROCESSNEW:;
|
|
Ndx=i=0;
|
|
while(SrcCnt)
|
|
{
|
|
strcpy(Arg,SrcStk[++i]);
|
|
*SrcStk[i]=0;
|
|
SrcCnt--;
|
|
Parse(Arg);
|
|
if(Ndx)
|
|
{
|
|
Emit();
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void FastLexer (char * Arg,char * delim1,char * delim2,int TokQuote)
|
|
{
|
|
int cnt1=0;
|
|
int cnt2=0;
|
|
PCHAR pd1;
|
|
PCHAR pd2;
|
|
Ndx=1;
|
|
while(Arg[cnt1])
|
|
{
|
|
if(Arg[cnt1]==34)
|
|
{
|
|
if(cnt2&&TokQuote)
|
|
{
|
|
Stk[Ndx++][cnt2]=0;
|
|
cnt2=0;
|
|
}
|
|
Stk[Ndx][cnt2]=34;
|
|
while(Arg[++cnt1]!=34)
|
|
{
|
|
Stk[Ndx][++cnt2]=Arg[cnt1];
|
|
if(Arg[cnt1]==0)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
Stk[Ndx][++cnt2]=Arg[cnt1];
|
|
if(TokQuote)
|
|
{
|
|
Stk[Ndx++][++cnt2]=0;
|
|
cnt2=0;
|
|
goto AGAIN;
|
|
}
|
|
}
|
|
pd1=delim1;
|
|
while(*pd1)
|
|
{
|
|
if(*(pd1++)==Arg[cnt1])
|
|
{
|
|
if(cnt2)
|
|
{
|
|
Stk[Ndx++][cnt2]=0;
|
|
cnt2=0;
|
|
}
|
|
goto AGAIN;
|
|
}
|
|
}
|
|
pd2=delim2;
|
|
while(*pd2)
|
|
{
|
|
if(*(pd2++)==Arg[cnt1])
|
|
{
|
|
if(cnt2)
|
|
{
|
|
Stk[Ndx++][cnt2]=0;
|
|
}
|
|
Stk[Ndx][0]=Arg[cnt1];
|
|
Stk[Ndx++][1]=0;
|
|
cnt2=0;
|
|
goto AGAIN;
|
|
}
|
|
}
|
|
Stk[Ndx][cnt2++]=Arg[cnt1];
|
|
|
|
AGAIN:;
|
|
cnt1++;
|
|
}
|
|
Stk[Ndx][cnt2]=0;
|
|
if(cnt2==0)
|
|
{
|
|
Ndx--;
|
|
}
|
|
}
|
|
|
|
|
|
void InsertTokens (int PosAfter, int NumTokens, ...)
|
|
{
|
|
va_list ap;
|
|
int i;
|
|
for(i=Ndx; i>=PosAfter+1; i+=-1)
|
|
{
|
|
strcpy(Stk[i+NumTokens],Stk[i]);
|
|
}
|
|
va_start(ap,NumTokens);
|
|
for(i=PosAfter+1; i<=PosAfter+NumTokens; i+=1)
|
|
{
|
|
strcpy(Stk[i],va_arg(ap,char*));
|
|
}
|
|
va_end(ap);
|
|
Ndx+=(NumTokens);
|
|
}
|
|
|
|
|
|
void EmitExportDef (char *fs)
|
|
{
|
|
static int beenhere;
|
|
char fname[2048];
|
|
char funcname[2048];
|
|
int i;
|
|
int st=1;
|
|
int sz=0;
|
|
strcpy(fname, join(2,extract(FileIn,"."),".def"));
|
|
if(!beenhere)
|
|
{
|
|
if((fpdef=fopen(fname,"w"))==0)
|
|
{
|
|
fprintf(stderr,"Can't open file %s\n",fname);
|
|
exit(1);
|
|
}
|
|
_splitpath_(FileIn,NULL,NULL,fname,NULL);
|
|
fprintf(fpdef,"%s%s\n","LIBRARY ",enc(fname));
|
|
fprintf(fpdef,"%s\n","EXPORTS");
|
|
beenhere=TRUE;
|
|
}
|
|
FastLexer(fs,"","(,)");
|
|
while(*Stk[st]!=40)
|
|
{
|
|
st++;
|
|
}
|
|
for(i=st+1; i<=Ndx; i+=1)
|
|
{
|
|
if(*Stk[i]==41)
|
|
{
|
|
break;
|
|
}
|
|
if(*Stk[i]!=44)
|
|
{
|
|
if(inchr(Stk[i],"*"))
|
|
{
|
|
sz+=(4);
|
|
continue;
|
|
}
|
|
if(instr_b(Stk[i],"longlong",1,1)||instr_b(Stk[i],"double",1,1)||instr_b(Stk[i],"long long"))
|
|
{
|
|
sz+=(8);
|
|
continue;
|
|
}
|
|
if(!inchr(Stk[i],"void"))
|
|
{
|
|
sz+=(4);
|
|
}
|
|
}
|
|
}
|
|
strcpy(Stk[1],trim(Stk[1]));
|
|
strcpy(funcname,mid(Stk[1],InstrRev(Stk[1]," ")+1));
|
|
fprintf(fpdef,"%s%s%s%s%s\n",funcname," = _",funcname,"@",ltrim(str(sz)));
|
|
}
|
|
|
|
|
|
char * GetArg (int ArgNum, functionParse* fp)
|
|
{
|
|
char *BCX_RetStr={0};
|
|
char RetArg[2048];
|
|
int ArgEnd=fp->CommaPos[ArgNum]-1;
|
|
int ArgStart=fp->CommaPos[ArgNum-1]+1;
|
|
*RetArg=0;
|
|
if(ArgNum>=fp->NumArgs)
|
|
{
|
|
ArgEnd=Ndx;
|
|
}
|
|
for(ArgStart=ArgStart; ArgStart<=ArgEnd; ArgStart+=1)
|
|
{
|
|
strcat(RetArg,Stk[ArgStart]);
|
|
}
|
|
BCX_RetStr=BCX_TmpStr(strlen(RetArg));
|
|
strcpy(BCX_RetStr,RetArg);
|
|
return BCX_RetStr;
|
|
}
|
|
|
|
|
|
int SepFuncArgs (int Strt, functionParse* fp, int functionflag)
|
|
{
|
|
int CountR=0;
|
|
int i=Strt;
|
|
if(functionflag)
|
|
{
|
|
while(i<=Ndx)
|
|
{
|
|
if(Stk[i][0]==40)
|
|
{
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
Strt=i+1;
|
|
fp->NumArgs=0;
|
|
fp->CommaPos[0]=i;
|
|
if(Strt>Ndx)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Strt=2;
|
|
fp->CommaPos[0]=1;
|
|
}
|
|
if(*Stk[Strt]==41)
|
|
{
|
|
fp->CommaPos[1]=Strt;
|
|
return 0;
|
|
}
|
|
fp->NumArgs=1;
|
|
for(i=Strt; i<=Ndx; i+=1)
|
|
{
|
|
if(*Stk[i]==40||*Stk[i]==91)
|
|
{
|
|
CountR++;
|
|
}
|
|
else if(*Stk[i]==41||*Stk[i]==93)
|
|
{
|
|
if(CountR==0)
|
|
{
|
|
fp->CommaPos[fp->NumArgs]=i;
|
|
break;
|
|
}
|
|
CountR--;
|
|
}
|
|
else if(*Stk[i]==44&&CountR==0)
|
|
{
|
|
fp->CommaPos[fp->NumArgs]=i;
|
|
fp->NumArgs++;
|
|
}
|
|
}
|
|
if(functionflag==0)
|
|
{
|
|
fp->CommaPos[fp->NumArgs]=Ndx;
|
|
}
|
|
return fp->NumArgs;
|
|
}
|
|
|
|
|
|
PCHAR MakeDecProto (functionParse* fp)
|
|
{
|
|
functionParse fpp;
|
|
char FunType[2048];
|
|
char AsType[2048];
|
|
char AsArrys[2048];
|
|
int FoundAs;
|
|
int pointer=0;
|
|
int i;
|
|
int ii;
|
|
char OptValue[2048];
|
|
int OptFlag=0;
|
|
static char Proto[2048];
|
|
static int SubFunPtr;
|
|
if(SubFunPtr)
|
|
{
|
|
goto ARGPARSE;
|
|
}
|
|
*Proto=0;
|
|
*FunType=0;
|
|
if(iMatchWrd(Stk[2],"sub")||iMatchWrd(Stk[2],"constructor")||iMatchWrd(Stk[2],"destructor"))
|
|
{
|
|
strcpy(FunType,"void");
|
|
}
|
|
else if(*Stk[Ndx]==41)
|
|
{
|
|
strcpy(FunType,VarTypeLookup[inchr(VarTypes,right(Stk[3],1))]);
|
|
}
|
|
else
|
|
{
|
|
for(i=Ndx; i>=fp->CommaPos[fp->NumArgs]+1; i+=-1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"ptr"))
|
|
{
|
|
pointer++;
|
|
}
|
|
else if(iMatchWrd(Stk[i],"as"))
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
strcpy(FunType, join(3,Stk[i],SPC,FunType));
|
|
}
|
|
}
|
|
}
|
|
if(InTypeDef)
|
|
{
|
|
if(iMatchWrd(Stk[2],"constructor"))
|
|
{
|
|
strcpy(Proto, join(2,Clean(Stk[3]),"("));
|
|
}
|
|
else if(iMatchWrd(Stk[2],"destructor"))
|
|
{
|
|
strcpy(Proto, join(3,"~",Clean(Stk[3]),"("));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Proto, join(4,FunType," ",Clean(Stk[3]),"("));
|
|
}
|
|
char Var[2048];
|
|
int w;
|
|
int id;
|
|
int vt;
|
|
strcpy(Var, join(2,FunType,stringx(pointer,42)));
|
|
GetTypeInfo(Var, &w, &id, &vt);
|
|
AddTypedefElement(BaseTypeDefsCnt[InTypeDef],vt,Clean(Stk[3]),FunType,0);
|
|
}
|
|
else if(SFPOINTER)
|
|
{
|
|
strcpy(Proto, join(7,"typedef ",FunType," (",CallType,"*",Clean(Stk[3]),"_TYPE)("));
|
|
}
|
|
else if(!NoTypeDeclare)
|
|
{
|
|
strcpy(Proto, join(7,"typedef ",FunType," (",CallType,"*BCXFPROT",ltrim(str(DllCnt)),")("));
|
|
}
|
|
else
|
|
{
|
|
if(UseCProto)
|
|
{
|
|
UseCProto=FALSE;
|
|
strcpy(Proto, join(7,FunType," ",stringx(pointer,42),SPC,CallType,Clean(Stk[3]),"("));
|
|
}
|
|
else
|
|
{
|
|
strcpy(Proto, join(8,"C_IMPORT ",FunType," ",stringx(pointer,42),SPC,CallType,Clean(Stk[3]),"("));
|
|
}
|
|
}
|
|
|
|
ARGPARSE:;
|
|
if(fp->NumArgs==0)
|
|
{
|
|
if(iMatchWrd(Stk[2],"destructor")||iMatchWrd(Stk[2],"constructor")||Use_Virtual)
|
|
{
|
|
strcat(Proto,")");
|
|
}
|
|
else
|
|
{
|
|
strcat(Proto,"void)");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(ii=0; ii<=fp->NumArgs-1; ii+=1)
|
|
{
|
|
*OptValue=0;
|
|
*AsType=0;
|
|
*AsArrys=0;
|
|
pointer=0;
|
|
FoundAs=0;
|
|
int FirstToken=fp->CommaPos[ii]+1;
|
|
int LastToken=fp->CommaPos[ii+1]-1;
|
|
int NumOfTokens=(LastToken-FirstToken)+1;
|
|
i=inchr(Stk[FirstToken],"[");
|
|
if(i)
|
|
{
|
|
strcpy(AsArrys,mid(Stk[FirstToken],i));
|
|
Stk[FirstToken][i-1]=0;
|
|
}
|
|
if(NumOfTokens==1)
|
|
{
|
|
strcpy(AsType,VarTypeLookup[inchr(VarTypes,right(Stk[FirstToken],1))]);
|
|
if(*AsArrys)
|
|
{
|
|
strcpy(AsType,RemoveStr(AsType,"*"));
|
|
}
|
|
else
|
|
{
|
|
pointer=tally(Stk[FirstToken],"*");
|
|
}
|
|
FoundAs=TRUE;
|
|
}
|
|
else
|
|
{
|
|
for(i=LastToken; i>=FirstToken; i+=-1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"ptr")||*Stk[i]==42)
|
|
{
|
|
pointer++;
|
|
}
|
|
else if(iMatchWrd(Stk[i],"sub"))
|
|
{
|
|
SepFuncArgs(fp->CommaPos[ii]+2, &fpp,TRUE);
|
|
strcat(Proto,"void (*)(");
|
|
SubFunPtr=FoundAs=TRUE;
|
|
MakeDecProto( &fpp);
|
|
SubFunPtr=FALSE;
|
|
break;
|
|
}
|
|
else if(iMatchWrd(Stk[i],"function"))
|
|
{
|
|
SepFuncArgs(fp->CommaPos[ii]+2, &fpp,TRUE);
|
|
if(AsType[0]==0)
|
|
{
|
|
strcpy(AsType,VarTypeLookup[inchr(VarTypes,right(Stk[FirstToken],1))]);
|
|
}
|
|
strcpy(Proto, join(4,Proto,rtrim(AsType),stringx(pointer,42)," (*)("));
|
|
pointer=0;
|
|
*AsType=0;
|
|
SubFunPtr=FoundAs=TRUE;
|
|
MakeDecProto( &fpp);
|
|
SubFunPtr=FALSE;
|
|
break;
|
|
}
|
|
else if(iMatchWrd(Stk[i],"as"))
|
|
{
|
|
if(AsType[0]==0)
|
|
{
|
|
Abort(join(2,"No type specified for argument",str(ii+1)));
|
|
}
|
|
FoundAs=TRUE;
|
|
break;
|
|
}
|
|
else if(*Stk[i]==61)
|
|
{
|
|
OptFlag=FoundAs=TRUE;
|
|
strcpy(OptValue, join(2," =",AsType));
|
|
*AsType=0;
|
|
if(i==FirstToken+1)
|
|
{
|
|
strcpy(AsType,VarTypeLookup[inchr(VarTypes,right(Stk[FirstToken],1))]);
|
|
if(*AsArrys)
|
|
{
|
|
strcpy(AsType,RemoveStr(AsType,"*"));
|
|
}
|
|
else
|
|
{
|
|
pointer=tally(Stk[FirstToken],"*");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(*Stk[i]!=46)
|
|
{
|
|
strcpy(AsType, join(3,Stk[i],SPC,AsType));
|
|
}
|
|
else
|
|
{
|
|
if(*Stk[i-1]==46)
|
|
{
|
|
if(OptFlag)
|
|
{
|
|
Abort("Default value not allowed when using variable arguments");
|
|
}
|
|
if(ii!=(fp->NumArgs-1))
|
|
{
|
|
Abort("Variable argument must be the last parameter");
|
|
}
|
|
if(fp->NumArgs==1)
|
|
{
|
|
Abort("Variable argument must be preceded by at least one other parameter");
|
|
}
|
|
FoundAs=TRUE;
|
|
}
|
|
strcpy(AsType, join(2,Stk[i],AsType));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(!FoundAs)
|
|
{
|
|
Abort(join(2,"Malformed argument type in parameter",str(ii+1)));
|
|
}
|
|
if(ii!=fp->NumArgs&&OptFlag&&str_cmp(OptValue,"")==0)
|
|
{
|
|
Warning(join(2,"No default value specified for parameter",str(ii+1)),1);
|
|
}
|
|
strcpy(Proto, join(6,Proto,rtrim(AsType),AsArrys,stringx(pointer,42),OptValue,Stk[fp->CommaPos[ii+1]]));
|
|
}
|
|
}
|
|
return Proto;
|
|
}
|
|
|
|
|
|
void AsmUnknownStructs (int CompArrays)
|
|
{
|
|
int InBrace=0;
|
|
int InStruct=0;
|
|
int i;
|
|
char sztemp[2048];
|
|
for(i=2; i<=Ndx; i+=1)
|
|
{
|
|
if(CompArrays)
|
|
{
|
|
if(str_cmp(Stk[i],"[")==0)
|
|
{
|
|
strcpy(sztemp,Stk[i-1]);
|
|
*Stk[i-1]=0;
|
|
for(;;)
|
|
{
|
|
strcat(sztemp,Stk[i]);
|
|
if(str_cmp(Stk[i],"]")==0)
|
|
{
|
|
InBrace--;
|
|
}
|
|
if(str_cmp(Stk[i],"[")==0)
|
|
{
|
|
InBrace++;
|
|
}
|
|
*Stk[i]=0;
|
|
i++;
|
|
if(!(InBrace&&i<=Ndx))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
strcpy(Stk[--i],sztemp);
|
|
}
|
|
}
|
|
if(strlen(Stk[i])>1&&!IsNumber(Stk[i]+1))
|
|
{
|
|
if(*Stk[i]==46||iMatchLft(Stk[i],"->"))
|
|
{
|
|
if(InStruct==0)
|
|
{
|
|
strcpy(Stk[i], join(2,Stk[i-1],Stk[i]));
|
|
*Stk[i-1]=0;
|
|
InStruct=i;
|
|
}
|
|
else
|
|
{
|
|
strcat(Stk[InStruct],Stk[i]);
|
|
*Stk[i]=0;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
if(*Stk[i]&&InStruct>0)
|
|
{
|
|
InStruct=0;
|
|
}
|
|
}
|
|
RemEmptyTokens();
|
|
}
|
|
|
|
|
|
void EmitIfCond (char *CondType)
|
|
{
|
|
int TestString;
|
|
int A;
|
|
int B;
|
|
int ParCnt;
|
|
int Tmp;
|
|
int IsWhile=FALSE;
|
|
char szTest[2048];
|
|
TestString=DataType(Stk[2]);
|
|
if(TestString==vt_STRVAR)
|
|
{
|
|
if(str_cmp(Stk[4],DDQ)==0)
|
|
{
|
|
strcpy(Stk[2], join(2,Clean(Stk[2]),"[0]"));
|
|
strcpy(Stk[4],"0");
|
|
}
|
|
else if(str_cmp(Stk[3],"[")==0 && str_cmp(Stk[7],DDQ)==0)
|
|
{
|
|
strcpy(Stk[2],Clean(Stk[2]));
|
|
strcat(Stk[5],"[0]");
|
|
strcpy(Stk[7],"0");
|
|
}
|
|
}
|
|
if(str_cmp(CondType,"while")==0)
|
|
{
|
|
IsWhile=TRUE;
|
|
}
|
|
fprintf(Outfile,"%s%s%s",Scoot,CondType,"(");
|
|
Tmp=2;
|
|
while(str_cmp(Stk[Tmp],"(")==0 || str_cmp(Stk[Tmp],"!")==0)
|
|
{
|
|
fprintf(Outfile,"%s",Stk[Tmp]);
|
|
Tmp++;
|
|
}
|
|
TestString=FALSE;
|
|
A=DataType(Stk[Tmp]);
|
|
if(A==vt_STRLIT||A==vt_STRVAR)
|
|
{
|
|
if(str_cmp(Stk[Tmp+1],")")!=0 && !iMatchWrd(Stk[Tmp+1],"then"))
|
|
{
|
|
TestString=TRUE;
|
|
Use_Str_Cmp=TRUE;
|
|
fprintf(Outfile,"%s","str_cmp(");
|
|
}
|
|
}
|
|
*szTest=0;
|
|
ParCnt=0;
|
|
for(;;)
|
|
{
|
|
if(TestString)
|
|
{
|
|
if(str_cmp(Stk[Tmp],"=")==0)
|
|
{
|
|
strcpy(Stk[Tmp],",");
|
|
strcpy(szTest,")==0");
|
|
ParCnt=0;
|
|
}
|
|
else if(str_cmp(Stk[Tmp],"!=")==0)
|
|
{
|
|
strcpy(Stk[Tmp],",");
|
|
strcpy(szTest,")!=0");
|
|
ParCnt=0;
|
|
}
|
|
else if(str_cmp(Stk[Tmp],">")==0)
|
|
{
|
|
if(str_cmp(Stk[Tmp+1],"=")==0)
|
|
{
|
|
strcpy(Stk[Tmp],",");
|
|
strcpy(szTest,")>=0");
|
|
*Stk[Tmp+1]=0;
|
|
}
|
|
else
|
|
{
|
|
strcpy(Stk[Tmp],",");
|
|
strcpy(szTest,")==1");
|
|
}
|
|
ParCnt=0;
|
|
}
|
|
else if(str_cmp(Stk[Tmp],"<")==0)
|
|
{
|
|
if(str_cmp(Stk[Tmp+1],"=")==0)
|
|
{
|
|
strcpy(Stk[Tmp],",");
|
|
strcpy(szTest,")<=0");
|
|
*Stk[Tmp+1]=0;
|
|
}
|
|
else
|
|
{
|
|
strcpy(Stk[Tmp],",");
|
|
strcpy(szTest,")==-1");
|
|
}
|
|
ParCnt=0;
|
|
}
|
|
else if(str_cmp(Stk[Tmp],"(")==0)
|
|
{
|
|
ParCnt++;
|
|
}
|
|
else if(str_cmp(Stk[Tmp],")")==0)
|
|
{
|
|
ParCnt--;
|
|
}
|
|
if(str_cmp(Stk[Tmp],")")==0 && str_cmp(szTest,"")!=0 && ParCnt<0)
|
|
{
|
|
fprintf(Outfile,"%s%s",szTest,Stk[Tmp]);
|
|
*szTest=0;
|
|
}
|
|
else
|
|
{
|
|
if(str_cmp(Stk[Tmp],"||")==0 || str_cmp(Stk[Tmp],"&&")==0)
|
|
{
|
|
strcpy(Stk[Tmp], join(4,szTest," ",Stk[Tmp]," "));
|
|
*szTest=0;
|
|
B=1;
|
|
while(str_cmp(Stk[Tmp+B],"(")==0)
|
|
{
|
|
strcat(Stk[Tmp],"(");
|
|
*Stk[Tmp+B]=0;
|
|
B++;
|
|
}
|
|
A=DataType(Stk[Tmp+B]);
|
|
if((A==vt_STRLIT||A==vt_STRVAR)&&str_cmp(Stk[Tmp+B+1],")")!=0)
|
|
{
|
|
strcat(Stk[Tmp]," str_cmp(");
|
|
Use_Str_Cmp=TRUE;
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[Tmp]));
|
|
TestString=FALSE;
|
|
goto NXTTOKEN;
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s",Clean(Stk[Tmp]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(str_cmp(Stk[Tmp],"||")==0 || str_cmp(Stk[Tmp],"&&")==0)
|
|
{
|
|
B=1;
|
|
while(str_cmp(Stk[Tmp+B],"(")==0)
|
|
{
|
|
strcat(Stk[Tmp],"(");
|
|
*Stk[Tmp+B]=0;
|
|
B++;
|
|
}
|
|
A=DataType(Stk[Tmp+B]);
|
|
if((A==vt_STRLIT||A==vt_STRVAR)&&str_cmp(Stk[Tmp+B+1],")")!=0)
|
|
{
|
|
strcat(Stk[Tmp],"str_cmp(");
|
|
TestString=TRUE;
|
|
Use_Str_Cmp=TRUE;
|
|
*szTest=0;
|
|
ParCnt=0;
|
|
fprintf(Outfile,"%s",Clean(Stk[Tmp]));
|
|
goto NXTTOKEN;
|
|
}
|
|
}
|
|
if(str_cmp(Stk[Tmp],"!")==0)
|
|
{
|
|
fprintf(Outfile,"%s",Stk[Tmp]);
|
|
}
|
|
else
|
|
{
|
|
fprintf(Outfile,"%s",Clean(Stk[Tmp]));
|
|
}
|
|
if(str_cmp(Stk[Tmp],"=")==0)
|
|
{
|
|
if(str_cmp(Stk[Tmp-1],"<")!=0 && str_cmp(Stk[Tmp-1],">")!=0)
|
|
{
|
|
if(str_cmp(Stk[Tmp+1],">")!=0 && str_cmp(Stk[Tmp+1],"<")!=0)
|
|
{
|
|
fprintf(Outfile,"%s","=");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
NXTTOKEN:;
|
|
Tmp++;
|
|
if(!IsWhile)
|
|
{
|
|
if(iMatchWrd(Stk[Tmp],"then"))
|
|
{
|
|
break;
|
|
}
|
|
else if(Tmp>Ndx)
|
|
{
|
|
Abort("If Without THEN");
|
|
}
|
|
}
|
|
if(Tmp>Ndx)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
fprintf(Outfile,"%s%s\n",szTest,")");
|
|
BumpUp();
|
|
fprintf(Outfile,"%s%s\n",Scoot,"{");
|
|
BumpUp();
|
|
}
|
|
|
|
|
|
void PrintGlobal (int A, int idx, char *Storage, char *P, char *VarName, char *VarDim)
|
|
{
|
|
char VAR[2048];
|
|
for(;;)
|
|
{
|
|
if(A==vt_FILEPTR)
|
|
{
|
|
strcpy(VarName,RemoveStr(VarName,"@"));
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Storage,"FILE *",P,VarName,VarDim,";");
|
|
break;
|
|
}
|
|
if(A==vt_UDT||A==vt_STRUCT||A==vt_UNION)
|
|
{
|
|
strcpy(VAR,TypeDefs[GlobalVars[idx].VarDef].VarName);
|
|
strcpy(VAR,rpad(VAR,7));
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
|
|
break;
|
|
}
|
|
if(A==vt_BOOL)
|
|
{
|
|
fprintf(Outfile,"%s%s%s%s%s\n",Storage,"bool ",VarName,VarDim,";");
|
|
break;
|
|
}
|
|
if(A==vt_STRVAR)
|
|
{
|
|
if(VarDim[0]==0)
|
|
{
|
|
strcpy(VarDim,"[65535]");
|
|
}
|
|
fprintf(Outfile,"%s%s%s%s%s%s\n",Storage,"char ",P,VarName,VarDim,";");
|
|
break;
|
|
}
|
|
if(A>=vt_VarMin&&A<=vt_VarMax)
|
|
{
|
|
strcpy(VAR,GetVarTypeName(GlobalVars[idx].VarType));
|
|
strcpy(VAR,rpad(VAR,7));
|
|
fprintf(Outfile,"%s%s%s%s%s%s%s\n",Storage,VAR," ",P,VarName,VarDim,";");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void ReDirectFPrint (FILE* TgtFile, char *pat, ...)
|
|
{
|
|
va_list ap;
|
|
if(DoCountLines&&TgtFile==FP3)
|
|
{
|
|
gLinesWritten++;
|
|
}
|
|
va_start(ap,pat);
|
|
vfprintf(TgtFile,pat,ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
|
|
int IsReservedWord (char *match)
|
|
{
|
|
char mat[2048];
|
|
strcpy(mat,ucase(match));
|
|
if(containedin(mat,ReservedWord)==0)
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int GetAsPos (void)
|
|
{
|
|
int i;
|
|
for(i=Ndx; i>=2; i+=-1)
|
|
{
|
|
if(iMatchWrd(Stk[i],"as"))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
void FreeGlobals (void)
|
|
{
|
|
if(RmLibs)free(RmLibs);
|
|
if(WarnMsg)free(WarnMsg);
|
|
if(AbortSrc)free(AbortSrc);
|
|
if(Src)free(Src);
|
|
if(szTmp)free(szTmp);
|
|
}
|
|
|
|
|
|
|