mirror of
https://github.com/clockworkpi/PicoCalc.git
synced 2025-12-12 10:18:54 +01:00
3738 lines
160 KiB
C
3738 lines
160 KiB
C
/*
|
|
* @cond
|
|
* The following section will be excluded from the documentation.
|
|
*/
|
|
/***********************************************************************************************************************
|
|
PicoMite MMBasic
|
|
|
|
MMBasic.c
|
|
|
|
<COPYRIGHT HOLDERS> Geoff Graham, Peter Mather
|
|
Copyright (c) 2021, <COPYRIGHT HOLDERS> All rights reserved.
|
|
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
|
|
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer
|
|
in the documentation and/or other materials provided with the distribution.
|
|
3. The name MMBasic be used when referring to the interpreter in any documentation and promotional material and the original copyright message be displayed
|
|
on the console at startup (additional copyright messages may be added).
|
|
4. All advertising materials mentioning features or use of this software must display the following acknowledgement: This product includes software developed
|
|
by the <copyright holder>.
|
|
5. Neither the name of the <copyright holder> nor the names of its contributors may be used to endorse or promote products derived from this software
|
|
without specific prior written permission.
|
|
THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDERS> AS IS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDERS> BE LIABLE FOR ANY DIRECT,
|
|
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
************************************************************************************************************************/
|
|
|
|
#include <stdio.h>
|
|
#include <limits.h>
|
|
#include <stdarg.h>
|
|
#include "MMBasic.h"
|
|
#include "pico/stdlib.h"
|
|
#include "Functions.h"
|
|
#include "Commands.h"
|
|
#include "Operators.h"
|
|
#include "Custom.h"
|
|
#include "Hardware_Includes.h"
|
|
#include "hardware/flash.h"
|
|
#ifndef PICOMITEWEB
|
|
#include "pico/multicore.h"
|
|
#endif
|
|
|
|
// this is the command table that defines the various tokens for commands in the source code
|
|
// most of them are listed in the .h files so you should not add your own here but instead add
|
|
// them to the appropiate .h file
|
|
#define INCLUDE_COMMAND_TABLE
|
|
const struct s_tokentbl commandtbl[] = {
|
|
#include "Functions.h"
|
|
#include "Commands.h"
|
|
#include "Operators.h"
|
|
#include "Custom.h"
|
|
#include "Hardware_Includes.h"
|
|
};
|
|
#undef INCLUDE_COMMAND_TABLE
|
|
|
|
|
|
|
|
// this is the token table that defines the other tokens in the source code
|
|
// most of them are listed in the .h files so you should not add your own here
|
|
// but instead add them to the appropiate .h file
|
|
#define INCLUDE_TOKEN_TABLE
|
|
const struct s_tokentbl tokentbl[] = {
|
|
#include "Functions.h"
|
|
#include "Commands.h"
|
|
#include "Operators.h"
|
|
#include "Custom.h"
|
|
#include "Hardware_Includes.h"
|
|
};
|
|
#undef INCLUDE_TOKEN_TABLE
|
|
|
|
|
|
static inline CommandToken commandtbl_decode(const unsigned char *p){
|
|
return ((CommandToken)(p[0] & 0x7f)) | ((CommandToken)(p[1] & 0x7f)<<7);
|
|
}
|
|
// these are initialised at startup
|
|
int CommandTableSize, TokenTableSize;
|
|
#ifdef rp2350
|
|
struct s_funtbl funtbl[MAXSUBFUN];
|
|
//void hashlabels(int errabort);
|
|
void hashlabels(unsigned char *p,int ErrAbort);
|
|
#endif
|
|
struct s_vartbl __attribute__ ((aligned (64))) g_vartbl[MAXVARS]={0}; // this table stores all variables
|
|
int g_varcnt=0; // number of variables
|
|
int g_VarIndex; // Global set by findvar after a variable has been created or found
|
|
int g_Localvarcnt; // number of LOCAL variables
|
|
int g_Globalvarcnt; // number of GLOBAL variables
|
|
int g_LocalIndex; // used to track the level of local variables
|
|
unsigned char OptionExplicit, OptionEscape, OptionConsole; // used to force the declaration of variables before their use
|
|
bool OptionNoCheck=false;
|
|
unsigned char DefaultType; // the default type if a variable is not specifically typed
|
|
int emptyarray=0;
|
|
int TempStringClearStart; // used to prevent clearing of space in an expression that called a FUNCTION
|
|
unsigned char *subfun[MAXSUBFUN]; // table used to locate all subroutines and functions
|
|
char CurrentSubFunName[MAXVARLEN + 1]; // the name of the current sub or fun
|
|
char CurrentInterruptName[MAXVARLEN + 1]; // the name of the current interrupt function
|
|
jmp_buf jmprun;
|
|
jmp_buf mark; // longjump to recover from an error and abort
|
|
jmp_buf ErrNext; // longjump to recover from an error and continue
|
|
unsigned char inpbuf[STRINGSIZE]; // used to store user keystrokes until we have a line
|
|
unsigned char tknbuf[STRINGSIZE]; // used to store the tokenised representation of the users input line
|
|
//unsigned char lastcmd[STRINGSIZE]; // used to store the last command in case it is needed by the EDIT command
|
|
unsigned char PromptString[MAXPROMPTLEN]; // the prompt for input, an empty string means use the default
|
|
int ProgramChanged; // true if the program in memory has been changed and not saved
|
|
struct s_hash g_hashlist[MAXVARS/2]={0};
|
|
int g_hashlistpointer=0;
|
|
unsigned char *LibMemory; //This is where the library is stored. At the last flash slot (4)
|
|
int multi=false;
|
|
unsigned char *ProgMemory; // program memory, this is where the program is stored
|
|
int PSize; // the size of the program stored in ProgMemory[]
|
|
|
|
int NextData; // used to track the next item to read in DATA & READ stmts
|
|
unsigned char *NextDataLine; // used to track the next line to read in DATA & READ stmts
|
|
int g_OptionBase; // track the state of OPTION BASE
|
|
int PrepareProgramExt(unsigned char *, int, unsigned char **, int);
|
|
extern uint32_t core1stack[];;
|
|
|
|
#if defined(MMFAMILY)
|
|
unsigned char FunKey[NBRPROGKEYS][MAXKEYLEN + 1]; // data storage for the programmable function keys
|
|
#endif
|
|
|
|
char digit[256]={
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0x10
|
|
0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0, //0x20
|
|
1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0, //0x30
|
|
0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0, //0x40
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0x50
|
|
0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0, //0x60
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0x70
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0x80
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0x90
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0xA0
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0xB0
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0xC0
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0xD0
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, //0xE0
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 //0xF0
|
|
};
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Global information used by operators and functions
|
|
//
|
|
int targ; // the type of the returned value
|
|
MMFLOAT farg1, farg2, fret; // the two float arguments and returned value
|
|
long long int iarg1, iarg2, iret; // the two integer arguments and returned value
|
|
unsigned char *sarg1, *sarg2, *sret; // the two string arguments and returned value
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Global information used by functions
|
|
// functions use targ, fret and sret as defined for operators (above)
|
|
unsigned char *ep; // pointer to the argument to the function terminated with a zero byte.
|
|
// it is NOT trimmed of spaces
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Global information used by commands
|
|
//
|
|
int cmdtoken; // Token number of the command
|
|
unsigned char *cmdline; // Command line terminated with a zero unsigned char and trimmed of spaces
|
|
unsigned char *nextstmt; // Pointer to the next statement to be executed.
|
|
unsigned char *CurrentLinePtr, *SaveCurrentLinePtr; // Pointer to the current line (used in error reporting)
|
|
unsigned char *ContinuePoint; // Where to continue from if using the continue statement
|
|
|
|
extern int TraceOn;
|
|
extern unsigned char *TraceBuff[TRACE_BUFF_SIZE];
|
|
extern int TraceBuffIndex; // used for listing the contents of the trace buffer
|
|
extern long long int CallCFunction(unsigned char *CmdPtr, unsigned char *ArgList, unsigned char *DefP, unsigned char *CallersLinePtr);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Functions only used within MMBasic.c
|
|
//
|
|
//void getexpr(unsigned char *);
|
|
//void checktype(int *, int);
|
|
unsigned char __not_in_flash_func(*getvalue)(unsigned char *p, MMFLOAT *fa, long long int *ia, unsigned char **sa, int *oo, int *ta);
|
|
unsigned char tokenTHEN, tokenELSE, tokenGOTO, tokenEQUAL, tokenTO, tokenSTEP, tokenWHILE, tokenUNTIL, tokenGOSUB, tokenAS, tokenFOR;
|
|
unsigned short cmdIF, cmdENDIF, cmdEND_IF, cmdELSEIF, cmdELSE_IF, cmdELSE, cmdSELECT_CASE, cmdFOR, cmdNEXT, cmdWHILE, cmdENDSUB, cmdENDFUNCTION, cmdLOCAL, cmdSTATIC, cmdCASE, cmdDO, cmdLOOP, cmdCASE_ELSE, cmdEND_SELECT;
|
|
unsigned short cmdSUB, cmdFUN, cmdCFUN, cmdCSUB, cmdIRET, cmdComment, cmdEndComment;
|
|
|
|
/********************************************************************************************************************************************
|
|
Program management
|
|
Includes the routines to initialise MMBasic, start running the interpreter, and to run a program in memory
|
|
*********************************************************************************************************************************************/
|
|
|
|
|
|
// Initialise MMBasic
|
|
void MIPS16 InitBasic(void) {
|
|
DefaultType = T_NBR;
|
|
CommandTableSize = (sizeof(commandtbl)/sizeof(struct s_tokentbl));
|
|
TokenTableSize = (sizeof(tokentbl)/sizeof(struct s_tokentbl));
|
|
|
|
ClearProgram(true);
|
|
|
|
// load the commonly used tokens
|
|
// by looking them up once here performance is improved considerably
|
|
tokenTHEN = GetTokenValue( (unsigned char *)"Then");
|
|
tokenELSE = GetTokenValue( (unsigned char *)"Else");
|
|
tokenGOTO = GetTokenValue( (unsigned char *)"GoTo");
|
|
tokenEQUAL = GetTokenValue( (unsigned char *)"=");
|
|
tokenTO = GetTokenValue( (unsigned char *)"To");
|
|
tokenSTEP = GetTokenValue( (unsigned char *)"Step");
|
|
tokenWHILE = GetTokenValue( (unsigned char *)"While");
|
|
tokenUNTIL = GetTokenValue( (unsigned char *)"Until");
|
|
tokenGOSUB = GetTokenValue( (unsigned char *)"GoSub");
|
|
tokenAS = GetTokenValue( (unsigned char *)"As");
|
|
tokenFOR = GetTokenValue( (unsigned char *)"For");
|
|
cmdLOOP = GetCommandValue( (unsigned char *)"Loop");
|
|
cmdIF = GetCommandValue( (unsigned char *)"If");
|
|
cmdENDIF = GetCommandValue( (unsigned char *)"EndIf");
|
|
cmdEND_IF = GetCommandValue( (unsigned char *)"End If");
|
|
cmdELSEIF = GetCommandValue( (unsigned char *)"ElseIf");
|
|
cmdELSE_IF = GetCommandValue( (unsigned char *)"Else If");
|
|
cmdELSE = GetCommandValue( (unsigned char *)"Else");
|
|
cmdSELECT_CASE = GetCommandValue( (unsigned char *)"Select Case");
|
|
cmdCASE = GetCommandValue( (unsigned char *)"Case");
|
|
cmdCASE_ELSE = GetCommandValue( (unsigned char *)"Case Else");
|
|
cmdEND_SELECT = GetCommandValue( (unsigned char *)"End Select");
|
|
cmdSUB = GetCommandValue( (unsigned char *)"Sub");
|
|
cmdFUN = GetCommandValue( (unsigned char *)"Function");
|
|
cmdLOCAL = GetCommandValue( (unsigned char *)"Local");
|
|
cmdSTATIC = GetCommandValue( (unsigned char *)"Static");
|
|
cmdENDSUB= GetCommandValue( (unsigned char *)"End Sub");
|
|
cmdENDFUNCTION = GetCommandValue( (unsigned char *)"End Function");
|
|
cmdDO= GetCommandValue( (unsigned char *)"Do");
|
|
cmdFOR= GetCommandValue( (unsigned char *)"For");
|
|
cmdNEXT= GetCommandValue( (unsigned char *)"Next");
|
|
cmdIRET = GetCommandValue( (unsigned char *)"IReturn");
|
|
cmdCSUB = GetCommandValue( (unsigned char *)"CSub");
|
|
cmdComment = GetCommandValue( (unsigned char *)"/*");
|
|
cmdEndComment = GetCommandValue( (unsigned char *)"*/");
|
|
// SInt(CommandTableSize);
|
|
// SIntComma(TokenTableSize);
|
|
// SSPrintString("\r\n");
|
|
|
|
}
|
|
|
|
int CheckEmpty(char *p){
|
|
int emptyarray=0;
|
|
char *pp = strchr((char *)p, '(');
|
|
if(pp){
|
|
pp++;
|
|
skipspace(pp);
|
|
if(*pp == ')')emptyarray=1;
|
|
}
|
|
while(*(++pp)){
|
|
if(*pp=='(')return 1; // can't be a function call with an implied opening
|
|
if(*pp==')')return 0; // closing bracket without open so much be implied in a function call e.g. PEEK(
|
|
}
|
|
return emptyarray;
|
|
}
|
|
|
|
|
|
// run a program
|
|
// this will continuously execute a program until the end (marked by TWO zero chars)
|
|
// the argument p must point to the first line to be executed
|
|
void MIPS16 __not_in_flash_func(ExecuteProgram)(unsigned char *p) {
|
|
int i, SaveLocalIndex = 0;
|
|
jmp_buf SaveErrNext;
|
|
memcpy(SaveErrNext, ErrNext, sizeof(jmp_buf)); // we call ExecuteProgram() recursively so we need to store/restore old jump buffer between calls
|
|
skipspace(p); // just in case, skip any whitespace
|
|
|
|
while(1) {
|
|
if(*p == 0) p++; // step over the zero byte marking the beginning of a new element
|
|
if(*p == T_NEWLINE) {
|
|
CurrentLinePtr = p; // and pointer to the line for error reporting
|
|
TraceBuff[TraceBuffIndex] = p; // used by TRACE LIST
|
|
if(++TraceBuffIndex >= TRACE_BUFF_SIZE) TraceBuffIndex = 0;
|
|
if(TraceOn && p > ProgMemory && p < ProgMemory + MAX_PROG_SIZE) {
|
|
inpbuf[0] = '[';
|
|
IntToStr((char *)inpbuf + 1, CountLines(p), 10);
|
|
strcat((char *)inpbuf, "]");
|
|
MMPrintString((char *)inpbuf);
|
|
uSec(1000);
|
|
}
|
|
p++; // and step over the token
|
|
}
|
|
if(*p == T_LINENBR) p += 3; // and step over the number
|
|
skipspace(p); // and skip any trailing white space
|
|
if(p[0] == T_LABEL) { // got a label
|
|
p += p[1] + 2; // skip over the label
|
|
skipspace(p); // and any following spaces
|
|
}
|
|
|
|
if(*p) { // if p is pointing to a command
|
|
if(*p=='\'')nextstmt = cmdline = p + 1;
|
|
else nextstmt = cmdline = p + sizeof(CommandToken);
|
|
skipspace(cmdline);
|
|
skipelement(nextstmt);
|
|
if(*p && *p != '\'') { // ignore a comment line
|
|
SaveLocalIndex = g_LocalIndex; // save this if we need to cleanup after an error
|
|
if(setjmp(ErrNext) == 0) { // return to the else leg of this if error and OPTION ERROR SKIP/IGNORE is in effect
|
|
if(p[0]>= C_BASETOKEN && p[1]>=C_BASETOKEN){
|
|
cmdtoken=commandtbl_decode(p);
|
|
targ = T_CMD;
|
|
commandtbl[cmdtoken].fptr(); // execute the command
|
|
} else {
|
|
if(!isnamestart(*p) && *p=='~') error("Unknown command");
|
|
else if(!isnamestart(*p)) error("Invalid character: @", (int)(*p));
|
|
i = FindSubFun(p, false); // it could be a defined command
|
|
if(i >= 0) { // >= 0 means it is a user defined command
|
|
DefinedSubFun(false, p, i, NULL, NULL, NULL, NULL);
|
|
}
|
|
else
|
|
error("Unknown command");
|
|
}
|
|
} else {
|
|
g_LocalIndex = SaveLocalIndex; // restore so that we can clean up any memory leaks
|
|
ClearTempMemory();
|
|
}
|
|
if(OptionErrorSkip > 0) OptionErrorSkip--; // if OPTION ERROR SKIP decrement the count - we do not error if it is greater than zero
|
|
if(g_TempMemoryIsChanged) ClearTempMemory(); // at the end of each command we need to clear any temporary string vars
|
|
#ifndef PICOMITEWEB
|
|
if(core1stack[0]!=0x12345678)error("CPU2 Stack overflow");
|
|
#endif
|
|
if(!OptionNoCheck){
|
|
CheckAbort();
|
|
check_interrupt(); // check for an MMBasic interrupt or touch event and handle it
|
|
}
|
|
}
|
|
p = nextstmt;
|
|
}
|
|
if((p[0] == 0 && p[1] == 0) || (p[0] == 0xff && p[1] == 0xff)) break; // the end of the program is marked by TWO zero chars, empty flash by two 0xff
|
|
}
|
|
memcpy(ErrNext, SaveErrNext, sizeof(jmp_buf)); // restore old jump buffer
|
|
}
|
|
|
|
|
|
/********************************************************************************************************************************************
|
|
Code associated with processing user defined subroutines and functions
|
|
********************************************************************************************************************************************/
|
|
|
|
// Scan through the program loaded in flash and build a table pointing to the definition of all user defined subroutines and functions.
|
|
// This pre processing speeds up the program when using defined subroutines and functions
|
|
// this routine also looks for embedded fonts and adds them to the font table
|
|
void MIPS16 PrepareProgram(int ErrAbort) {
|
|
int i, j, NbrFuncts;
|
|
#ifdef rp2350
|
|
int u, namelen;
|
|
uint32_t hash=FNV_offset_basis;
|
|
char printvar[MAXVARLEN+1];
|
|
#endif
|
|
unsigned char *p1, *p2;
|
|
for(i = FONT_BUILTIN_NBR; i < FONT_TABLE_SIZE-1; i++)
|
|
FontTable[i] = NULL; // clear the font table
|
|
|
|
|
|
NbrFuncts = 0;
|
|
CFunctionFlash = CFunctionLibrary = NULL;
|
|
if(Option.LIBRARY_FLASH_SIZE == MAX_PROG_SIZE)
|
|
NbrFuncts = PrepareProgramExt(LibMemory , 0, &CFunctionLibrary, ErrAbort);
|
|
PrepareProgramExt(ProgMemory, NbrFuncts,&CFunctionFlash, ErrAbort);
|
|
|
|
// check the sub/fun table for duplicates
|
|
#ifdef rp2350
|
|
memset(funtbl,0,sizeof(struct s_funtbl)*MAXSUBFUN);
|
|
for(i = 0; i < MAXSUBFUN && subfun[i] != NULL; i++) {
|
|
// First we will hash the function name and add it to the function table
|
|
// This allows for a fast check of a variable name being the same as a function name
|
|
// It also allows a hash look up for function name matching
|
|
p1 = subfun[i];
|
|
p1+=sizeof(CommandToken);
|
|
skipspace(p1);
|
|
p2 = (unsigned char *)printvar; namelen = 0;
|
|
hash=FNV_offset_basis;
|
|
do {
|
|
u=mytoupper(*p1);
|
|
hash ^= u;
|
|
hash*=FNV_prime;
|
|
*p2++ = u;
|
|
p1++;
|
|
if(++namelen > MAXVARLEN){
|
|
if(ErrAbort) error("Function name too long");
|
|
}
|
|
|
|
} while(isnamechar(*p1));
|
|
if(namelen!=MAXVARLEN)*p2=0;
|
|
hash %= MAXSUBHASH; //scale to size of table
|
|
while(funtbl[hash].name[0]!=0){
|
|
hash++;
|
|
if(hash==MAXSUBFUN)hash=0;
|
|
}
|
|
funtbl[hash].index=i;
|
|
memcpy(funtbl[hash].name,printvar,(namelen == MAXVARLEN ? namelen :namelen+1));
|
|
}
|
|
if(Option.LIBRARY_FLASH_SIZE == MAX_PROG_SIZE){
|
|
hashlabels(LibMemory,ErrAbort);
|
|
// if(!ErrAbort) return;
|
|
}
|
|
hashlabels(ProgMemory,ErrAbort);
|
|
//if(!ErrAbort) return;
|
|
|
|
#endif
|
|
if(!ErrAbort) return;
|
|
|
|
for(i = 0; i < MAXSUBFUN && subfun[i] != NULL; i++) {
|
|
for(j = i + 1; j < MAXSUBFUN && subfun[j] != NULL; j++) {
|
|
CurrentLinePtr = p1 = subfun[i];
|
|
p1+=sizeof(CommandToken);
|
|
skipspace(p1);
|
|
p2 = subfun[j];
|
|
p2+=sizeof(CommandToken);
|
|
skipspace(p2);
|
|
while(1) {
|
|
if(!isnamechar(*p1) && !isnamechar(*p2)) {
|
|
if(ErrAbort) error("Duplicate name");
|
|
return;
|
|
}
|
|
if(mytoupper(*p1) != mytoupper(*p2)) break;
|
|
p1++; p2++;
|
|
}
|
|
}
|
|
}
|
|
// for(i=0;i<MAXSUBFUN;i++){
|
|
// if(funtbl[i].name[0]!=0){
|
|
// MMPrintString(funtbl[i].name);PIntHC(funtbl[i].index);PIntComma(i);PRet();
|
|
// }
|
|
// }
|
|
}
|
|
|
|
|
|
// This scans one area (main program or the library area) for user defined subroutines and functions.
|
|
// It is only used by PrepareProgram() above.
|
|
int MIPS16 PrepareProgramExt(unsigned char *p, int i, unsigned char **CFunPtr, int ErrAbort) {
|
|
unsigned int *cfp;
|
|
while(*p != 0xff) {
|
|
p = GetNextCommand(p, &CurrentLinePtr, NULL);
|
|
if(*p == 0) break; // end of the program or module
|
|
CommandToken tkn=commandtbl_decode(p);
|
|
if(tkn == cmdSUB || tkn == cmdFUN /*|| tkn == cmdCFUN*/ || tkn == cmdCSUB) { // found a SUB, FUN, CFUNCTION or CSUB token
|
|
if(i >= MAXSUBFUN) {
|
|
FlashWriteInit(PROGRAM_FLASH);
|
|
flash_range_erase(realflashpointer, MAX_PROG_SIZE);
|
|
int j=MAX_PROG_SIZE/4;
|
|
int *pp=(int *)(flash_progmemory);
|
|
while(j--)if(*pp++ != 0xFFFFFFFF){
|
|
enable_interrupts_pico();
|
|
error("Flash erase problem");
|
|
}
|
|
enable_interrupts_pico();
|
|
MMPrintString("Error: Too many subroutines and functions - erasing program\r\n");
|
|
uSec(100000);
|
|
ClearProgram(true);
|
|
cmdline=NULL;
|
|
do_end(false);
|
|
longjmp(mark, 1); // jump back to the input prompt
|
|
}
|
|
subfun[i++] = p++; // save the address and step over the token
|
|
p++; //step past rest of command token
|
|
skipspace(p);
|
|
if(!isnamestart(*p)) {
|
|
if(ErrAbort) error("Invalid identifier");
|
|
i--;
|
|
continue;
|
|
}
|
|
}
|
|
while(*p) p++; // look for the zero marking the start of the next element
|
|
}
|
|
while(*p == 0) p++; // the end of the program can have multiple zeros
|
|
p++; // step over the terminating 0xff
|
|
*CFunPtr = (unsigned char *)(((unsigned int)p + 0b11) & ~0b11); // CFunction flash (if it exists) starts on the next word address after the program in flash
|
|
if(i < MAXSUBFUN) subfun[i] = NULL;
|
|
CurrentLinePtr = NULL;
|
|
// now, step through the CFunction area looking for fonts to add to the font table
|
|
//Bit 7 on the last address byte is used to identify a font.
|
|
cfp = *(unsigned int **)CFunPtr;
|
|
while(*cfp != 0xffffffff) {
|
|
if(*cfp & 0x80000000)
|
|
FontTable[*cfp & (FONT_TABLE_SIZE-1)] = (unsigned char *)(cfp + 2);
|
|
cfp++;
|
|
cfp += (*cfp + 4) / sizeof(unsigned int);
|
|
}
|
|
return i;
|
|
}
|
|
|
|
// searches the subfun[] table to locate a defined sub or fun
|
|
// returns with the index of the sub/function in the table or -1 if not found
|
|
// if type = 0 then look for a sub otherwise a function
|
|
#ifdef rp2350
|
|
int __not_in_flash_func(FindSubFun)(unsigned char *p, int type) {
|
|
unsigned char *s;
|
|
unsigned char name[MAXVARLEN + 1];
|
|
int j, u, namelen;
|
|
unsigned int hash=FNV_offset_basis;
|
|
unsigned char *tp, *ip;
|
|
|
|
// copy the variable name into name
|
|
s = name; namelen = 0;
|
|
do {
|
|
u=mytoupper(*p);
|
|
hash ^= u;
|
|
// PIntComma(u);
|
|
hash*=FNV_prime;
|
|
*s++ = u;
|
|
p++;
|
|
if(++namelen > MAXVARLEN) error("Variable name too long");
|
|
} while(isnamechar(*p));
|
|
// PRet();
|
|
*s=0;
|
|
hash %= MAXSUBHASH; //scale 0-512
|
|
// MMPrintString("Searching for function: ");MMPrintString((char *)name);PIntComma(hash);PRet();
|
|
while(funtbl[hash].name[0]!=0){
|
|
ip=name;
|
|
tp=(unsigned char *)funtbl[hash].name;
|
|
// MMPrintString("Testing : ");MMPrintString((char *)tp);PRet();
|
|
if(*ip++ == *tp++) { // preliminary quick check
|
|
j = namelen-1;
|
|
while(j > 0 && *ip == *tp) { // compare each letter
|
|
j--; ip++; tp++;
|
|
}
|
|
if(j == 0 && (*(char *)tp == 0 || namelen == MAXVARLEN) && funtbl[hash].index<MAXSUBFUN) { // found a matching name
|
|
// MMPrintString("Found : ");MMPrintString((char *)name);MMPrintString(", hash key : ");PInt(hash);PRet();
|
|
return funtbl[hash].index;
|
|
break;
|
|
}
|
|
}
|
|
hash++;
|
|
if(hash==MAXSUBFUN)hash=0;
|
|
}
|
|
return -1;
|
|
}
|
|
#else
|
|
int __not_in_flash_func(FindSubFun)(unsigned char *p, int type) {
|
|
unsigned char *p1, *p2;
|
|
int i;
|
|
|
|
for(i = 0; i < MAXSUBFUN && subfun[i] != NULL; i++) {
|
|
p2 = subfun[i]; // point to the command token
|
|
CommandToken tkn=commandtbl_decode(p2);
|
|
if(type == 0) { // if it is a sub and we want a fun or vice versa skip this one
|
|
if(!(tkn == cmdSUB || tkn == cmdCSUB)) continue;
|
|
} else {
|
|
if(!(tkn == cmdFUN /*|| tkn == cmdCFUN*/)) continue;
|
|
}
|
|
p2+=sizeof(CommandToken); skipspace(p2); // point to the identifier
|
|
if(toupper(*p) != toupper(*p2)) continue; // quick first test
|
|
p1 = p + 1; p2++;
|
|
while(isnamechar(*p1) && toupper(*p1) == toupper(*p2)) { p1++; p2++; };
|
|
if((*p1 == '$' && *p2 == '$') || (*p1 == '%' && *p2 == '%') || (*p1 == '!' && *p2 == '!') || (!isnamechar(*p1) && !isnamechar(*p2))) return i; // found it !
|
|
}
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
// This function is responsible for executing a defined subroutine or function.
|
|
// As these two are similar they are processed in the one lump of code.
|
|
//
|
|
// The arguments when called are:
|
|
// isfun = true if we are executing a function
|
|
// cmd = pointer to the command name used by the caller (in program memory)
|
|
// index = index into subfun[i] which points to the definition of the sub or funct
|
|
// fa, i64a, sa and typ are pointers to where the return value is to be stored (used by functions only)
|
|
#if defined(PICOMITEWEB) || defined(PICOMITEVGA)
|
|
#ifdef rp2350
|
|
void MIPS16 __not_in_flash_func(DefinedSubFun)(int isfun, unsigned char *cmd, int index, MMFLOAT *fa, long long int *i64a, unsigned char **sa, int *typ) {
|
|
#else
|
|
void MIPS16 DefinedSubFun(int isfun, unsigned char *cmd, int index, MMFLOAT *fa, long long int *i64a, unsigned char **sa, int *typ) {
|
|
#endif
|
|
#else
|
|
void MIPS16 __not_in_flash_func(DefinedSubFun)(int isfun, unsigned char *cmd, int index, MMFLOAT *fa, long long int *i64a, unsigned char **sa, int *typ) {
|
|
#endif
|
|
|
|
unsigned char *p, *s, *tp, *ttp, tcmdtoken;
|
|
unsigned char *CallersLinePtr, *SubLinePtr = NULL;
|
|
unsigned char *argbuf1; unsigned char **argv1; int argc1;
|
|
unsigned char *argbuf2; unsigned char **argv2; int argc2;
|
|
unsigned char fun_name[MAXVARLEN + 1];
|
|
unsigned char *argbyref;
|
|
int i;
|
|
int ArgType, FunType;
|
|
int *argtype;
|
|
union u_argval {
|
|
MMFLOAT f; // the value if it is a float
|
|
long long int i; // the value if it is an integer
|
|
MMFLOAT *fa; // pointer to the allocated memory if it is an array of floats
|
|
long long int *ia; // pointer to the allocated memory if it is an array of integers
|
|
unsigned char *s; // pointer to the allocated memory if it is a string
|
|
} *argval;
|
|
int *argVarIndex;
|
|
|
|
CallersLinePtr = CurrentLinePtr;
|
|
SubLinePtr = subfun[index]; // used for error reporting
|
|
p = SubLinePtr + sizeof(CommandToken); // point to the sub or function definition
|
|
skipspace(p);
|
|
ttp = p;
|
|
|
|
// copy the sub/fun name from the definition into temp storage and terminate
|
|
// p is left pointing to the end of the name (ie, start of the argument list in the definition)
|
|
CurrentLinePtr = SubLinePtr; // report errors at the definition
|
|
tp = fun_name;
|
|
*tp++ = *p++; while(isnamechar(*p)) *tp++ = *p++;
|
|
if(*p == '$' || *p == '%' || *p == '!') {
|
|
if(!isfun) {
|
|
error("Type specification is invalid: @", (int)(*p));
|
|
}
|
|
*tp++ = *p++;
|
|
}
|
|
*tp = 0;
|
|
|
|
if(isfun && *p != '(' /*&& (*SubLinePtr != cmdCFUN)*/) error("Function definition");
|
|
|
|
// find the end of the caller's identifier, tp is left pointing to the start of the caller's argument list
|
|
CurrentLinePtr = CallersLinePtr; // report errors at the caller
|
|
tp = cmd + 1;
|
|
while(isnamechar(*tp)) tp++;
|
|
if(*tp == '$' || *tp == '%' || *tp == '!') {
|
|
if(!isfun) error("Type specification");
|
|
tp++;
|
|
}
|
|
if(mytoupper(*(p-1)) != mytoupper(*(tp-1))) error("Inconsistent type suffix");
|
|
|
|
// if this is a function we check to find if the function's type has been specified with AS <type> and save it
|
|
CurrentLinePtr = SubLinePtr; // report errors at the definition
|
|
FunType = T_NOTYPE;
|
|
if(isfun) {
|
|
ttp = skipvar(ttp, false); // point to after the function name and bracketed arguments
|
|
skipspace(ttp);
|
|
if(*ttp == tokenAS) { // are we using Microsoft syntax (eg, AS INTEGER)?
|
|
ttp++; // step over the AS token
|
|
ttp = CheckIfTypeSpecified(ttp, &FunType, true); // get the type
|
|
if(!(FunType & T_IMPLIED)) error("Variable type");
|
|
}
|
|
FunType |= (V_FIND | V_DIM_VAR | V_LOCAL | V_EMPTY_OK);
|
|
}
|
|
|
|
// from now on
|
|
// tp = the caller's argument list
|
|
// p = the argument list for the definition
|
|
skipspace(tp); skipspace(p);
|
|
|
|
// similar if this is a CSUB
|
|
CommandToken tkn=commandtbl_decode(SubLinePtr);
|
|
if(tkn == cmdCSUB) {
|
|
CallCFunction(SubLinePtr, tp, p, CallersLinePtr); // run the CSUB
|
|
g_TempMemoryIsChanged = true; // signal that temporary memory should be checked
|
|
return;
|
|
}
|
|
// from now on we have a user defined sub or function (not a C routine)
|
|
|
|
if(gosubindex >= MAXGOSUB) error("Too many nested SUB/FUN");
|
|
errorstack[gosubindex] = CallersLinePtr;
|
|
gosubstack[gosubindex++] = isfun ? NULL : nextstmt; // NULL signifies that this is returned to by ending ExecuteProgram()
|
|
#define buffneeded MAX_ARG_COUNT*(sizeof(union u_argval)+ 2*sizeof(int)+3*sizeof(unsigned char *)+sizeof(unsigned char))+ 2*STRINGSIZE
|
|
// allocate memory for processing the arguments
|
|
argval=GetSystemMemory(buffneeded);
|
|
argtype=(void *)argval+MAX_ARG_COUNT * sizeof(union u_argval);
|
|
argVarIndex = (void *)argtype+MAX_ARG_COUNT * sizeof(int);
|
|
argbuf1 = (void *)argVarIndex+MAX_ARG_COUNT * sizeof(int);
|
|
argv1 = (void *)argbuf1+STRINGSIZE;
|
|
argbuf2 = (void *)argv1+MAX_ARG_COUNT * sizeof(unsigned char *);
|
|
argv2 = (void *)argbuf2+STRINGSIZE;
|
|
argbyref=(void *)argv2+MAX_ARG_COUNT * sizeof(unsigned char *);
|
|
|
|
// now split up the arguments in the caller
|
|
CurrentLinePtr = CallersLinePtr; // report errors at the caller
|
|
argc1 = 0;
|
|
if(*tp) makeargs(&tp, MAX_ARG_COUNT, argbuf1, argv1, &argc1, (*tp == '(') ? (unsigned char *)"(," : (unsigned char *)",");
|
|
|
|
// split up the arguments in the definition
|
|
CurrentLinePtr = SubLinePtr; // any errors must be at the definition
|
|
argc2 = 0;
|
|
if(*p) makeargs(&p, MAX_ARG_COUNT, argbuf2, argv2, &argc2, (*p == '(') ? (unsigned char *)"(," : (unsigned char *)",");
|
|
|
|
// error checking
|
|
if(argc2 && (argc2 & 1) == 0) error("Argument list");
|
|
CurrentLinePtr = CallersLinePtr; // report errors at the caller
|
|
if(argc1 > argc2 || (argc1 && (argc1 & 1) == 0)) error("Argument list");
|
|
|
|
// step through the arguments supplied by the caller and get the value supplied
|
|
// these can be:
|
|
// - missing (ie, caller did not supply that parameter)
|
|
// - a variable, in which case we need to get a pointer to that variable's data and save its index so later we can get its type
|
|
// - an expression, in which case we evaluate the expression and get its value and type
|
|
for(i = 0; i < argc2; i += 2) { // count through the arguments in the definition of the sub/fun
|
|
if(i < argc1 && *argv1[i]) {
|
|
// check if the argument is a valid variable
|
|
if(i < argc1 && isnamestart(*argv1[i]) && *skipvar(argv1[i], false) == 0) {
|
|
// yes, it is a variable (or perhaps a user defined function which looks the same)?
|
|
if(!(FindSubFun(argv1[i], 1) >= 0 && strchr((char *)argv1[i], '(') != NULL)) {
|
|
// yes, this is a valid variable. set argvalue to point to the variable's data and argtype to its type
|
|
argval[i].s = findvar(argv1[i], V_FIND | V_EMPTY_OK); // get a pointer to the variable's data
|
|
argtype[i] = g_vartbl[g_VarIndex].type; // and the variable's type
|
|
argVarIndex[i] = g_VarIndex;
|
|
if(argtype[i] & T_CONST) {
|
|
argtype[i] = 0; // we don't want to point to a constant
|
|
} else {
|
|
argtype[i] |= T_PTR; // flag this as a pointer
|
|
}
|
|
}
|
|
}
|
|
|
|
// check for BYVAL or BYREF in sub/fun definition
|
|
argbyref[i]=0;
|
|
skipspace(argv2[i]);
|
|
if(toupper(*argv2[i]) == 'B' && toupper(*(argv2[i]+1)) == 'Y') {
|
|
if((checkstring(argv2[i] + 2, (unsigned char *)"VAL")) != NULL) { // if BYVAL
|
|
//Only if not an array remove any pointer flag in the caller
|
|
if(g_vartbl[argVarIndex[i]].dims[0] == 0){
|
|
argtype[i] = 0;
|
|
}else{
|
|
error("Array as BYVAL not allowed $",argv1[i]);
|
|
}
|
|
argv2[i] += 5; // skip to the variable start
|
|
argbyref[i]=2;
|
|
} else {
|
|
if((checkstring(argv2[i] + 2, (unsigned char *)"REF")) != NULL) { // if BYREF
|
|
//if((argtype[i] & T_PTR) == 0) error("Variable required for BYREF $", argv1[i]);
|
|
argv2[i] += 5; // skip to the variable start
|
|
argbyref[i]=1;
|
|
if((argtype[i] & T_PTR) == 0)error("Variable required for BYREF $", argv1[i]);
|
|
}
|
|
}
|
|
skipspace(argv2[i]);
|
|
}
|
|
|
|
// if argument is present and is not a pointer to a variable then evaluate it as an expression
|
|
if(argtype[i] == 0) {
|
|
long long int ia;
|
|
evaluate(argv1[i], &argval[i].f, &ia, &s, &argtype[i], false); // get the value and type of the argument
|
|
if(argtype[i] & T_INT)
|
|
argval[i].i = ia;
|
|
else if(argtype[i] & T_STR) {
|
|
argval[i].s = GetMemory(STRINGSIZE);
|
|
Mstrcpy(argval[i].s, s);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// now we step through the parameters in the definition of the sub/fun
|
|
// for each one we create the local variable and compare its type to that supplied in the callers list
|
|
CurrentLinePtr = SubLinePtr; // any errors must be at the definition
|
|
g_LocalIndex++;
|
|
for(i = 0; i < argc2; i += 2) { // count through the arguments in the definition of the sub/fun
|
|
ArgType = T_NOTYPE;
|
|
//skip BYVAL/BYREF keywords
|
|
if(toupper(*argv2[i]) == 'B' && toupper(*(argv2[i]+1)) == 'Y') {
|
|
if((checkstring(argv2[i] + 2,(unsigned char *) "VAL")) != NULL) {
|
|
argv2[i] += 5;
|
|
}else if((checkstring(argv2[i] + 2, (unsigned char *)"REF")) != NULL) { // if BYREF
|
|
argv2[i] += 5; // skip to the variable start
|
|
}
|
|
}
|
|
|
|
// if (argbyref[i] )argv2[i] += 5;
|
|
tp = skipvar(argv2[i], false); // point to after the variable
|
|
skipspace(tp);
|
|
if(*tp == tokenAS) { // are we using Microsoft syntax (eg, AS INTEGER)?
|
|
*tp++ = 0; // terminate the string and step over the AS token
|
|
tp = CheckIfTypeSpecified(tp, &ArgType, true); // and get the type
|
|
if(!(ArgType & T_IMPLIED)) error("Variable type");
|
|
}
|
|
ArgType |= (V_FIND | V_DIM_VAR | V_LOCAL | V_EMPTY_OK);
|
|
tp = findvar(argv2[i], ArgType); // declare the local variable
|
|
if(g_vartbl[g_VarIndex].dims[0] > 0) error("Argument list"); // if it is an array it must be an empty array
|
|
|
|
CurrentLinePtr = CallersLinePtr; // report errors at the caller
|
|
|
|
// if the definition called for an array, special processing and checking will be required
|
|
if(g_vartbl[g_VarIndex].dims[0] == -1) {
|
|
//if( (argbyref[i]==2)) error("Array must be passed as BYREF $",argv1[i]);
|
|
int j;
|
|
if(g_vartbl[argVarIndex[i]].dims[0] == 0) error("Expected an array");
|
|
if(TypeMask(g_vartbl[g_VarIndex].type) != TypeMask(argtype[i])) error("Incompatible type: $", argv1[i]);
|
|
g_vartbl[g_VarIndex].val.s = NULL;
|
|
for(j = 0; j < MAXDIM; j++) // copy the dimensions of the supplied variable into our local variable
|
|
g_vartbl[g_VarIndex].dims[j] = g_vartbl[argVarIndex[i]].dims[j];
|
|
}
|
|
|
|
// if this is a pointer check and the type is NOT the same as that requested in the sub/fun definition
|
|
if((argtype[i] & T_PTR) && TypeMask(g_vartbl[g_VarIndex].type) != TypeMask(argtype[i])) {
|
|
if(argbyref[i]==1){ error("BYREF requires same types: $", argv1[i]);}
|
|
if((TypeMask(g_vartbl[g_VarIndex].type) & T_STR) || (TypeMask(argtype[i]) & T_STR))
|
|
error("Incompatible type: $", argv1[i]);
|
|
// make this into an ordinary argument
|
|
if(g_vartbl[argVarIndex[i]].type & T_PTR) {
|
|
argval[i].i = *g_vartbl[argVarIndex[i]].val.ia; // get the value if the supplied argument is a pointer
|
|
} else {
|
|
argval[i].i = *(long long int *)argval[i].s; // get the value if the supplied argument is an ordinary variable
|
|
}
|
|
argtype[i] &= ~T_PTR; // and remove the pointer flag
|
|
}
|
|
|
|
// if this is a pointer (note: at this point the caller type and the required type must be the same)
|
|
if(argtype[i] & T_PTR) {
|
|
// the argument supplied was a variable so we must setup the local variable as a pointer
|
|
if((g_vartbl[g_VarIndex].type & T_STR) && g_vartbl[g_VarIndex].val.s != NULL) {
|
|
FreeMemorySafe((void **)&g_vartbl[g_VarIndex].val.s); // free up the local variable's memory if it is a pointer to a string
|
|
}
|
|
g_vartbl[g_VarIndex].val.s = argval[i].s; // point to the data of the variable supplied as an argument
|
|
g_vartbl[g_VarIndex].type |= T_PTR; // set the type to a pointer
|
|
g_vartbl[g_VarIndex].size = g_vartbl[argVarIndex[i]].size; // just in case it is a string copy the size
|
|
// this is not a pointer
|
|
} else if(argtype[i] != 0) { // in getting the memory argtype[] is initialised to zero
|
|
// the parameter was an expression or a just straight variables with different types (therefore not a pointer))
|
|
if((g_vartbl[g_VarIndex].type & T_STR) && (argtype[i] & T_STR)) { // both are a string
|
|
Mstrcpy(g_vartbl[g_VarIndex].val.s, argval[i].s);
|
|
FreeMemorySafe((void **)&argval[i].s);
|
|
} else if((g_vartbl[g_VarIndex].type & T_NBR) && (argtype[i] & T_NBR)) // both are a float
|
|
g_vartbl[g_VarIndex].val.f = argval[i].f;
|
|
else if((g_vartbl[g_VarIndex].type & T_NBR) && (argtype[i] & T_INT)) // need a float but supplied an integer
|
|
g_vartbl[g_VarIndex].val.f = argval[i].i;
|
|
else if((g_vartbl[g_VarIndex].type & T_INT) && (argtype[i] & T_INT)) // both are integers
|
|
g_vartbl[g_VarIndex].val.i = argval[i].i;
|
|
else if((g_vartbl[g_VarIndex].type & T_INT) && (argtype[i] & T_NBR)) // need an integer but was supplied with a float
|
|
g_vartbl[g_VarIndex].val.i = FloatToInt64(argval[i].f);
|
|
else
|
|
error("Incompatible type: $", argv1[i]);
|
|
}
|
|
}
|
|
|
|
// temp memory used in setting up the arguments can be deleted now
|
|
/* FreeMemory((unsigned char *)argval);
|
|
FreeMemory((unsigned char *)argtype); FreeMemory((unsigned char *)argVarIndex);
|
|
FreeMemory(argbuf1); FreeMemory((unsigned char *)argv1);
|
|
FreeMemory(argbuf2); FreeMemory((unsigned char *)argv2);
|
|
FreeMemory((unsigned char *)argbyref);*/
|
|
FreeMemory((void*)argval);
|
|
strcpy((char *)CurrentSubFunName, (char *)fun_name);
|
|
// if it is a defined command we simply point to the first statement in our command and allow ExecuteProgram() to carry on as before
|
|
// exit from the sub is via cmd_return which will decrement g_LocalIndex
|
|
if(!isfun) {
|
|
skipelement(p);
|
|
nextstmt = p; // point to the body of the subroutine
|
|
return;
|
|
}
|
|
|
|
// if it is a defined function we have a lot more work to do. We must:
|
|
// - Create a local variable for the function's name
|
|
// - Save the globals being used by the current command that caused the function to be called
|
|
// - Invoke another instance of ExecuteProgram() to execute the body of the function
|
|
// - When that returns we need to restore the global variables
|
|
// - Get the variable's value and save that in the return value globals (fret or sret)
|
|
// - Return to the expression parser
|
|
tp = findvar(fun_name, FunType | V_FUNCT); // declare the local variable
|
|
FunType = g_vartbl[g_VarIndex].type;
|
|
if(FunType & T_STR) {
|
|
FreeMemorySafe((void **)&g_vartbl[g_VarIndex].val.s); // free the memory if it is a string
|
|
g_vartbl[g_VarIndex].type |= T_PTR;
|
|
g_LocalIndex--; // allocate the memory at the previous level
|
|
g_vartbl[g_VarIndex].val.s = tp = GetTempMemory(STRINGSIZE); // and use our own memory
|
|
g_LocalIndex++;
|
|
}
|
|
skipelement(p); // point to the body of the function
|
|
|
|
ttp = nextstmt; // save the globals used by commands
|
|
tcmdtoken = cmdtoken;
|
|
s = cmdline;
|
|
|
|
ExecuteProgram(p); // execute the function's code
|
|
CurrentLinePtr = CallersLinePtr; // report errors at the caller
|
|
|
|
cmdline = s; // restore the globals
|
|
cmdtoken = tcmdtoken;
|
|
nextstmt = ttp;
|
|
|
|
// return the value of the function's variable to the caller
|
|
if(FunType & T_NBR)
|
|
*fa = *(MMFLOAT *)tp;
|
|
else if(FunType & T_INT)
|
|
*i64a = *(long long int *)tp;
|
|
else
|
|
*sa = tp; // for a string we just need to return the local memory
|
|
*typ = FunType; // save the function type for the caller
|
|
ClearVars(g_LocalIndex--, true); // delete any local variables
|
|
g_TempMemoryIsChanged = true; // signal that temporary memory should be checked
|
|
gosubindex--;
|
|
}
|
|
|
|
char MIPS16 *strcasechr(const char *p, int ch)
|
|
{
|
|
char c;
|
|
|
|
c = mytoupper(ch);
|
|
for (;; ++p) {
|
|
if (mytoupper(*p) == c)
|
|
return ((char *)p);
|
|
if (*p == '\0')
|
|
return (NULL);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
char MIPS16 *fstrstr (const char *s1, const char *s2)
|
|
{
|
|
const char *p = s1;
|
|
const size_t len = strlen (s2);
|
|
|
|
for (; (p = strcasechr (p, *s2)) != 0; p++)
|
|
{
|
|
if (strncasecmp (p, s2, len) == 0)
|
|
return (char *)p;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
void MIPS16 str_replace(char *target, const char *needle, const char *replacement, uint8_t ignoresurround)
|
|
{
|
|
char buffer[288] = { 0 };
|
|
char *insert_point = &buffer[0];
|
|
const char *tmp = target;
|
|
size_t needle_len = strlen(needle);
|
|
size_t repl_len = strlen(replacement);
|
|
|
|
while (1) {
|
|
const char *p = fstrstr(tmp, needle);
|
|
|
|
// walked past last occurrence of needle; copy remaining part
|
|
if (p == NULL) {
|
|
strcpy(insert_point, tmp);
|
|
break;
|
|
}
|
|
char *q;
|
|
if(p==target){
|
|
ignoresurround|=1;
|
|
q=(char *)p;
|
|
} else q=(char *)p-1;
|
|
if( (isnamechar(*q) && !(ignoresurround & 1)) || (isnameend(p[strlen(needle)]) && !(ignoresurround & 2))){
|
|
// copy part before needle
|
|
memcpy(insert_point, tmp, p - tmp);
|
|
insert_point += p - tmp;
|
|
|
|
// copy replacement string
|
|
memcpy(insert_point, needle, needle_len);
|
|
insert_point += needle_len;
|
|
|
|
// adjust pointers, move on
|
|
tmp = p + needle_len;
|
|
} else {
|
|
// copy part before needle
|
|
memcpy(insert_point, tmp, p - tmp);
|
|
insert_point += p - tmp;
|
|
|
|
// copy replacement string
|
|
memcpy(insert_point, replacement, repl_len);
|
|
insert_point += repl_len;
|
|
|
|
// adjust pointers, move on
|
|
tmp = p + needle_len;
|
|
}
|
|
}
|
|
|
|
// write altered string back to target
|
|
strcpy(target, buffer);
|
|
}
|
|
|
|
void MIPS16 STR_REPLACE(char *target, const char *needle, const char *replacement, uint8_t ignoresurround){
|
|
char *ip=target;
|
|
int toggle=0;
|
|
char comment[STRINGSIZE]={0};
|
|
skipspace(ip);
|
|
if(!(toupper(*ip)=='R' && toupper(ip[1])=='E' && toupper(ip[2])=='M' )){
|
|
while(*ip){
|
|
if(*ip==34){
|
|
if(toggle==0)toggle=1;
|
|
else toggle=0;
|
|
}
|
|
if(toggle && *ip==' '){
|
|
*ip=0xFF;
|
|
}
|
|
if(toggle && *ip=='.'){
|
|
*ip=0xFE;
|
|
}
|
|
if(toggle && *ip=='='){
|
|
*ip=0xFD;
|
|
}
|
|
if(toggle && *ip=='\\'){
|
|
*ip=0xFC;
|
|
}
|
|
if(toggle==0 && *ip=='\''){
|
|
strcpy(comment,ip);
|
|
*ip=0;
|
|
break;
|
|
}
|
|
ip++;
|
|
}
|
|
str_replace(target, needle, replacement, ignoresurround);
|
|
ip=target;
|
|
if(comment[0]=='\''){
|
|
strcat(target,comment);
|
|
}
|
|
while(*ip){
|
|
if(*ip==0xFF)*ip=' ';
|
|
if(*ip==0xFE)*ip='.';
|
|
if(*ip==0xFD)*ip='=';
|
|
if(*ip==0xFC)*ip='\\';
|
|
ip++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************************************************************
|
|
take an input line and turn it into a line with tokens suitable saving into memory
|
|
********************************************************************************************************************************************/
|
|
|
|
//take an input string in inpbuf[] and copy it to tknbuf[] and:
|
|
// - convert the line number to a binary number
|
|
// - convert a label to the token format
|
|
// - convert keywords to tokens
|
|
// - convert the colon to a zero char
|
|
//the result in tknbuf[] is terminated with MMFLOAT zero chars
|
|
// if the arg console is true then do not add a line number
|
|
|
|
void MIPS16 tokenise(int console) {
|
|
unsigned char *p, *op, *tp;
|
|
int i=0;
|
|
int firstnonwhite;
|
|
int labelvalid;
|
|
|
|
// first, make sure that only printable characters are in the line
|
|
p = inpbuf;
|
|
while(*p) {
|
|
*p = *p & 0x7f;
|
|
if(*p < ' ' || *p == 0x7f) *p = ' ';
|
|
p++;
|
|
}
|
|
tp = inpbuf;
|
|
skipspace(tp);
|
|
if(toupper(tp[0])=='H' && toupper(tp[1])=='E' && toupper(tp[2])=='L' && toupper(tp[3])=='P' && tp[4]==' '){
|
|
unsigned char *q=&tp[5];
|
|
skipspace(q);
|
|
if(*q!='"'){
|
|
int end=strlen((char *)q);
|
|
memmove(&q[1],q,strlen((char *)q));
|
|
*q='"';
|
|
q[end+1]=0;
|
|
}
|
|
}
|
|
if(toupper(tp[0])=='R' && toupper(tp[1])=='E' && toupper(tp[2])=='M' && tp[3]==' ')i=1;
|
|
if(multi==false && i==false){
|
|
int i=0;
|
|
while(i<MMEND){
|
|
char buff[]="~( )";
|
|
buff[2]=i+'A';
|
|
STR_REPLACE((char *)inpbuf,overlaid_functions[i],buff, false);
|
|
i++;
|
|
}
|
|
STR_REPLACE((char *)inpbuf,"MM.INFO$","MM.INFO",0);
|
|
STR_REPLACE((char *)inpbuf,"=>",">=", 3);
|
|
STR_REPLACE((char *)inpbuf,"=<","<=", 3);
|
|
STR_REPLACE((char *)inpbuf,"SPRITE MEMORY","BLIT MEMORY",0);
|
|
STR_REPLACE((char *)inpbuf,"PEEK(BYTE","PEEK(INT8",0);
|
|
}
|
|
// setup the input and output buffers
|
|
p = inpbuf;
|
|
op = tknbuf;
|
|
if(!console) *op++ = T_NEWLINE;
|
|
|
|
// get the line number if it exists
|
|
tp = p;
|
|
skipspace(tp);
|
|
for(i = 0; i < 8; i++) if(!isxdigit(tp[i])) break; // test if this is eight hex digits
|
|
if(IsDigitinline(*tp) && i < 8) { // if it a digit and not an 8 digit hex number (ie, it is CFUNCTION data) then try for a line number
|
|
i = strtol((char *)tp, (char **)&tp, 10);
|
|
if(!console && i > 0 && i <= MAXLINENBR) {
|
|
*op++ = T_LINENBR;
|
|
*op++ = (i>>8);
|
|
*op++ = (i & 0xff);
|
|
}
|
|
p = tp;
|
|
}
|
|
|
|
// process the rest of the line
|
|
firstnonwhite = true;
|
|
labelvalid = true;
|
|
tp=p;
|
|
skipspace(tp);
|
|
if(*tp=='.'){
|
|
if(!strncasecmp((char *)tp,".SIDE SET ",10) ||
|
|
!strncasecmp((char *)tp,".END PROGRAM",12) ||
|
|
!strncasecmp((char *)tp,".WRAP",4) ||
|
|
!strncasecmp((char *)tp,".LINE ",5) ||
|
|
!strncasecmp((char *)tp,".PROGRAM ",9) ||
|
|
!strncasecmp((char *)tp,".LABEL ",6)
|
|
) *tp='_';
|
|
}
|
|
|
|
while(*p) {
|
|
if(*p=='*' && p[1]=='/'){
|
|
multi=false;
|
|
}
|
|
// just copy a space
|
|
if(*p == ' ') {
|
|
*op++ = *p++;
|
|
continue;
|
|
}
|
|
|
|
// first look for quoted text and copy it across
|
|
// this will also accept a string without the closing quote and it will add the quote in
|
|
if(*p == '"') {
|
|
do {
|
|
*op++ = *p++;
|
|
} while(*p != '"' && *p);
|
|
*op++ = '"';
|
|
if(*p == '"') p++;
|
|
continue;
|
|
}
|
|
|
|
// copy anything after a comment (')
|
|
if(*p == '\'' || multi==true) {
|
|
do {
|
|
*op++=*p++;
|
|
} while(*p);
|
|
continue;
|
|
}
|
|
|
|
// check for multiline separator (colon) and replace with a zero char
|
|
if(*p == ':') {
|
|
*op++ = 0;
|
|
p++;
|
|
while(*p == ':') { // insert a space between consecutive colons
|
|
*op++ = ' ';
|
|
*op++ = 0;
|
|
p++;
|
|
}
|
|
firstnonwhite = true;
|
|
continue;
|
|
}
|
|
|
|
// not whitespace or string or comment - try a number
|
|
if(IsDigitinline(*p) || *p == '.') { // valid chars at the start of a number
|
|
while(IsDigitinline(*p) || *p == '.' || *p == 'E' || *p == 'e')
|
|
if (*p == 'E' || *p == 'e') { // check for '+' or '-' as part of the exponent
|
|
*op++ = *p++; // copy the number
|
|
if (*p == '+' || *p == '-') { // BUGFIX by Gerard Sexton
|
|
*op++ = *p++; // copy the '+' or '-'
|
|
}
|
|
} else {
|
|
*op++ = *p++; // copy the number
|
|
}
|
|
firstnonwhite = false;
|
|
continue;
|
|
}
|
|
|
|
// not whitespace or string or comment or number - see if we can find a label or a token identifier
|
|
if(firstnonwhite) { // first entry on the line must be a command
|
|
// these variables are only used in the search for a command code
|
|
unsigned char *tp2, *match_p = NULL;
|
|
int match_i = -1, match_l = 0;
|
|
// first test if it is a print shortcut char (?) - this needs special treatment
|
|
if(*p == '?') {
|
|
match_i = GetCommandValue((unsigned char *)"Print");
|
|
if(*++p == ' ') p++; // eat a trailing space
|
|
match_p = p;
|
|
} else if((tp2 = checkstring(p, (unsigned char *)"BITBANG")) != NULL) {
|
|
match_i = GetCommandValue((unsigned char *)"Device");
|
|
match_p = p = tp2;
|
|
} else {
|
|
// now try for a command in the command table
|
|
// this works by scanning the entire table looking for the match with the longest command name
|
|
// this is needed because we need to differentiate between END and END SUB for example.
|
|
// without looking for the longest match we might think that we have a match when we found just END.
|
|
for(i = 0 ; i < CommandTableSize - 1; i++) {
|
|
tp2 = p;
|
|
tp = commandtbl[i].name;
|
|
while(mytoupper(*tp2) == mytoupper(*tp) && *tp != 0) {
|
|
if(*tp == ' ')
|
|
skipspace(tp2); // eat up any extra spaces between keywords
|
|
else
|
|
tp2++;
|
|
tp++;
|
|
if(*tp == '(') skipspace(tp2); // eat up space between a keyword and bracket
|
|
}
|
|
// we have a match
|
|
if(*tp == 0 && (!isnamechar(*tp2) || (commandtbl[i].type & T_FUN))) {
|
|
if(*(tp - 1) != '(' && isnamechar(*tp2)) continue; // skip if not the function
|
|
// save the details if it is the longest command found so far
|
|
if(strlen((char *)commandtbl[i].name) > match_l) {
|
|
match_p = tp2;
|
|
match_l = strlen((char *)commandtbl[i].name);
|
|
match_i = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(match_i > -1) {
|
|
// we have found a command
|
|
// *op++ = match_i + C_BASETOKEN; // insert the token found
|
|
*op++ = (match_i & 0x7f ) + C_BASETOKEN;
|
|
*op++ = (match_i >> 7) + C_BASETOKEN; //tokens can be 14-bit
|
|
p = match_p; // step over the command in the source
|
|
if(isalpha(*(p-1)) && *p == ' ') p++; // if the command is followed by a space skip over it
|
|
if(match_i == GetCommandValue((unsigned char *)"Rem")) // check if it is a REM command
|
|
while(*p) *op++ = *p++; // and in that case just copy everything
|
|
firstnonwhite = false;
|
|
labelvalid = false; // we do not want any labels after this
|
|
if(match_i == GetCommandValue((unsigned char *)"/*")){
|
|
multi= true;
|
|
}
|
|
if(match_i == GetCommandValue((unsigned char *)"*/"))multi= false;
|
|
if(match_i == GetCommandValue((unsigned char *)"OPTION") || match_i == GetCommandValue((unsigned char *)"CONFIGURE" )){
|
|
STR_REPLACE((char *)inpbuf,"GAME*MITE","GAMEMITE", false);
|
|
STR_REPLACE((char *)inpbuf,"PICO-RESTOUCH-LCD-3.5","PICORESTOUCHLCD3.5",false);
|
|
STR_REPLACE((char *)inpbuf,"PICO-RESTOUCH-LCD-2.8","PICORESTOUCHLCD2.8",false);
|
|
STR_REPLACE((char *)inpbuf,"RP2040-LCD-1.28","RP2040LCD1.28",false);
|
|
STR_REPLACE((char *)inpbuf,"RP2040-LCD-0.96","RP2040LCD0.96",false);
|
|
STR_REPLACE((char *)inpbuf,"RP2040-GEEK","RP2040GEEK",false);
|
|
STR_REPLACE((char *)inpbuf,"PICOGAME 4-PWM","PICOGAME 4PWM",false);
|
|
STR_REPLACE((char *)inpbuf,"OLIMEX USB","OLIMEXUSB",false);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// next test if it is a label
|
|
if(labelvalid && isnamestart(*p)) {
|
|
for(i = 0, tp = p + 1; i < MAXVARLEN - 1; i++, tp++)
|
|
if(!isnamechar(*tp)) break; // search for the first invalid char
|
|
if(*tp == ':') { // Yes !! It is a label
|
|
labelvalid = false; // we do not want any more labels
|
|
*op++ = T_LABEL; // insert the token
|
|
*op++ = tp - p; // insert the length of the label
|
|
for(i = tp - p; i > 0; i--) *op++ = *p++; // copy the label
|
|
p++; // step over the terminating colon
|
|
continue;
|
|
}
|
|
}
|
|
} else {
|
|
// check to see if it is a function or keyword
|
|
unsigned char *tp2 = NULL;
|
|
for(i = 0 ; i < TokenTableSize - 1; i++) {
|
|
tp2 = p;
|
|
tp = tokentbl[i].name;
|
|
// check this entry
|
|
while(mytoupper(*tp2) == mytoupper(*tp) && *tp != 0) {
|
|
tp++; tp2++;
|
|
if(*tp == '(') skipspace(tp2);
|
|
}
|
|
if(*tp == 0 && (!isnameend(*(tp - 1)) || !isnamechar(*tp2))) break;
|
|
}
|
|
if(i != TokenTableSize - 1) {
|
|
// we have a match
|
|
i += C_BASETOKEN;
|
|
*op++ = i; // insert the token found
|
|
p = tp2; // and step over it in the source text
|
|
if(i == tokenTHEN || i == tokenELSE)
|
|
firstnonwhite = true; // a command is valid after a THEN or ELSE
|
|
else
|
|
firstnonwhite = false;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// not whitespace or string or comment or token identifier or number
|
|
// try for a variable name which could be a user defined subroutine or an implied let
|
|
if(isnamestart(*p)) { // valid chars at the start of a variable name
|
|
if(firstnonwhite) { // first entry on the line?
|
|
tp = skipvar(p, true); // find the char after the variable
|
|
skipspace(tp);
|
|
if(*tp == '=') {
|
|
unsigned short tkn = GetCommandValue((unsigned char *)"Let"); // is it an implied let?
|
|
*op++ = (tkn & 0x7f ) + C_BASETOKEN;
|
|
*op++ = (tkn >> 7) + C_BASETOKEN; //tokens can be 14-bit
|
|
}
|
|
}
|
|
while(isnamechar(*p)) *op++ = *p++; // copy the variable name
|
|
firstnonwhite = false;
|
|
labelvalid = false; // we do not want any labels after this
|
|
continue;
|
|
}
|
|
|
|
// special case where the character to copy is an opening parenthesis
|
|
// we search back to see if the previous non space char was the end of an identifier and, if it is, we remove any spaces following the identifier
|
|
// this enables the programmer to put spaces after a function name or array identifier without causing a confusing error
|
|
if(*p == '(') {
|
|
tp = op - 1;
|
|
if(*tp == ' ') {
|
|
while(*tp == ' ') tp--;
|
|
if(isnameend(*tp)) op = tp + 1;
|
|
}
|
|
}
|
|
|
|
// something else, so just copy the one character
|
|
*op++ = *p++;
|
|
labelvalid = false; // we do not want any labels after this
|
|
firstnonwhite = false;
|
|
|
|
}
|
|
// end of loop, trim any trailing blanks (but not part of a line number)
|
|
while(*(op - 1) == ' ' && op > tknbuf + 3) *--op = 0;
|
|
// make sure that it is terminated properly
|
|
*op++ = 0; *op++ = 0; *op++ = 0; // terminate with zero chars
|
|
}
|
|
|
|
|
|
|
|
|
|
/********************************************************************************************************************************************
|
|
routines for evaluating expressions
|
|
the main functions are getnumber(), getinteger() and getstring()
|
|
********************************************************************************************************************************************/
|
|
|
|
|
|
|
|
// A convenient way of evaluating an expression
|
|
// it takes two arguments:
|
|
// p = pointer to the expression in memory (leading spaces will be skipped)
|
|
// t = pointer to the type
|
|
// if *t = T_STR or T_NBR or T_INT will throw an error if the result is not the correct type
|
|
// if *t = T_NOTYPE it will not throw an error and will return the type found in *t
|
|
// it returns with a void pointer to a float, integer or string depending on the value returned in *t
|
|
// this will check that the expression is terminated correctly and throw an error if not
|
|
void __not_in_flash_func(*DoExpression)(unsigned char *p, int *t) {
|
|
static MMFLOAT f;
|
|
static long long int i64;
|
|
static unsigned char *s;
|
|
|
|
evaluate(p, &f, &i64, &s, t, false);
|
|
if(*t & T_INT) return &i64;
|
|
if(*t & T_NBR) return &f;
|
|
if(*t & T_STR) return s;
|
|
|
|
error("Internal fault 1(sorry)");
|
|
return NULL; // to keep the compiler happy
|
|
}
|
|
|
|
|
|
|
|
// evaluate an expression. p points to the start of the expression in memory
|
|
// returns either the float or string in the pointer arguments
|
|
// *t points to an integer which holds the type of variable we are looking for
|
|
// if *t = T_STR or T_NBR or T_INT will throw an error if the result is not the correct type
|
|
// if *t = T_NOTYPE it will not throw an error and will return the type found in *t
|
|
// this will check that the expression is terminated correctly and throw an error if not. flags & E_NOERROR will suppress that check
|
|
unsigned char MIPS16 __not_in_flash_func(*evaluate)(unsigned char *p, MMFLOAT *fa, long long int *ia, unsigned char **sa, int *ta, int flags) {
|
|
int o;
|
|
int t = *ta;
|
|
unsigned char *s;
|
|
p = getvalue(p, fa, ia, &s, &o, &t); // get the left hand side of the expression, the operator is returned in o
|
|
while(o != E_END) p = doexpr(p, fa, ia, &s, &o, &t); // get the right hand side of the expression and evaluate the operator in o
|
|
|
|
// check that the types match and convert them if we can
|
|
if((*ta & (T_NBR |T_INT)) && t & T_STR) error("Expected a number");
|
|
if(*ta & T_STR && (t & (T_NBR | T_INT))) error("Expected a string");
|
|
if(o != E_END) error("Argument count");
|
|
if((*ta & T_NBR) && (t & T_INT)) *fa = *ia;
|
|
if((*ta & T_INT) && (t & T_NBR)) *ia = FloatToInt64(*fa);
|
|
*ta = t;
|
|
*sa = s;
|
|
|
|
// check that the expression is terminated correctly
|
|
if(!(flags & E_NOERROR)) {
|
|
skipspace(p);
|
|
if(!(*p == 0 || *p == ',' || *p == ')' || *p == '\'')) error("Expression syntax");
|
|
}
|
|
return p;
|
|
}
|
|
|
|
|
|
// evaluate an expression to get a number
|
|
MMFLOAT __not_in_flash_func(getnumber)(unsigned char *p) {
|
|
int t = T_NBR;
|
|
MMFLOAT f;
|
|
long long int i64;
|
|
unsigned char *s;
|
|
evaluate(p, &f, &i64, &s, &t, false);
|
|
if(t & T_INT) return (MMFLOAT)i64;
|
|
return f;
|
|
}
|
|
|
|
|
|
// evaluate an expression and return a 64 bit integer
|
|
long long int __not_in_flash_func(getinteger)(unsigned char *p) {
|
|
int t = T_INT;
|
|
MMFLOAT f;
|
|
long long int i64;
|
|
unsigned char *s;
|
|
|
|
evaluate(p, &f, &i64, &s, &t, false);
|
|
if(t & T_NBR) return FloatToInt64(f);
|
|
return i64;
|
|
}
|
|
|
|
|
|
|
|
// evaluate an expression and return an integer
|
|
// this will throw an error is the integer is outside a specified range
|
|
// this will correctly round the number if it is a fraction of an integer
|
|
long long int __not_in_flash_func(getint)(unsigned char *p, long long int min, long long int max) {
|
|
long long int i;
|
|
int t = T_INT;
|
|
MMFLOAT f;
|
|
long long int i64;
|
|
unsigned char *s;
|
|
evaluate(p, &f, &i64, &s, &t, false);
|
|
if(t & T_NBR) i= FloatToInt64(f);
|
|
else i=i64;
|
|
if(i < min || i > max) error("~ is invalid (valid is ~ to ~)", i, min, max);
|
|
return i;
|
|
}
|
|
|
|
|
|
|
|
// evaluate an expression to get a string
|
|
unsigned char __not_in_flash_func(*getstring)(unsigned char *p) {
|
|
int t = T_STR;
|
|
MMFLOAT f;
|
|
long long int i64;
|
|
unsigned char *s;
|
|
|
|
evaluate(p, &f, &i64, &s, &t, false);
|
|
return s;
|
|
}
|
|
|
|
|
|
|
|
// evaluate an expression to get a string using the C style for a string
|
|
// as against the MMBasic style returned by getstring()
|
|
unsigned char __not_in_flash_func(*getCstring)(unsigned char *p) {
|
|
unsigned char *tp;
|
|
tp = GetTempMemory(STRINGSIZE); // this will last for the life of the command
|
|
Mstrcpy(tp, getstring(p)); // get the string and save in a temp place
|
|
MtoC(tp); // convert to a C style string
|
|
return tp;
|
|
}
|
|
unsigned char *getFstring(unsigned char *p) {
|
|
unsigned char *tp;
|
|
tp = GetTempMemory(STRINGSIZE); // this will last for the life of the command
|
|
Mstrcpy(tp, getstring(p)); // get the string and save in a temp place
|
|
for(int i=1;i<=*tp;i++)if(tp[i]=='\\')tp[i]='/';
|
|
if((toupper(tp[1])=='A' || toupper(tp[1])=='B') && tp[2]==':' && !(tp[3]=='/')){
|
|
memmove(&tp[4],&tp[3],tp[0]-2);
|
|
tp[3]='/';
|
|
tp[0]++;
|
|
}
|
|
MtoC(tp);
|
|
return tp;
|
|
}
|
|
|
|
|
|
|
|
// recursively evaluate an expression observing the rules of operator precedence
|
|
unsigned char MIPS16 __not_in_flash_func(*doexpr)(unsigned char *p, MMFLOAT *fa, long long int *ia, unsigned char **sa, int *oo, int *ta) {
|
|
MMFLOAT fa1, fa2;
|
|
long long int ia1, ia2;
|
|
int o1, o2;
|
|
int t1, t2;
|
|
unsigned char *sa1, *sa2;
|
|
|
|
TestStackOverflow(); // throw an error if we have overflowed the PIC32's stack
|
|
|
|
fa1 = *fa;
|
|
ia1 = *ia;
|
|
sa1 = *sa;
|
|
t1 = TypeMask(*ta);
|
|
o1 = *oo;
|
|
p = getvalue(p, &fa2, &ia2, &sa2, &o2, &t2);
|
|
while(1) {
|
|
if(o2 == E_END || tokentbl[o1].precedence <= tokentbl[o2].precedence) {
|
|
if((t1 & T_STR) != (t2 & T_STR)) error("Incompatible types in expression");
|
|
targ = tokentbl[o1].type & (T_NBR | T_INT);
|
|
if(targ == T_NBR) { // if the operator does not work with ints convert the args to floats
|
|
if(t1 & T_INT) { fa1 = ia1; t1 = T_NBR; } // at this time the only example of this is op_div (/)
|
|
if(t2 & T_INT) { fa2 = ia2; t2 = T_NBR; }
|
|
}
|
|
if(targ == T_INT) { // if the operator does not work with floats convert the args to ints
|
|
if(t1 & T_NBR) { ia1 = FloatToInt64(fa1); t1 = T_INT; }
|
|
if(t2 & T_NBR) { ia2 = FloatToInt64(fa2); t2 = T_INT; }
|
|
}
|
|
if(targ == (T_NBR | T_INT)) { // if the operator will work with both floats and ints
|
|
if(t1 & T_NBR && t2 & T_INT) { fa2 = ia2; t2 = T_NBR; } // if one arg is float convert the other to a float
|
|
if(t1 & T_INT && t2 & T_NBR) { fa1 = ia1; t1 = T_NBR; }
|
|
}
|
|
if(!(tokentbl[o1].type & T_OPER) || !(tokentbl[o1].type & t1)) {
|
|
error("Invalid operator");
|
|
}
|
|
farg1 = fa1; farg2 = fa2; // setup the float args (incase it is a float)
|
|
sarg1 = sa1; sarg2 = sa2; // ditto string args
|
|
iarg1 = ia1; iarg2 = ia2; // ditto integer args
|
|
targ = t1; // this is what both args are
|
|
tokentbl[o1].fptr(); // call the operator function
|
|
*fa = fret;
|
|
*ia = iret;
|
|
*sa = sret;
|
|
*oo = o2;
|
|
*ta = targ;
|
|
return p;
|
|
}
|
|
// the next operator has a higher precedence, recursive call to evaluate it
|
|
else
|
|
p = doexpr(p, &fa2, &ia2, &sa2, &o2, &t2);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// get a value, either from a constant, function or variable
|
|
// also returns the next operator to the right of the value or E_END if no operator
|
|
unsigned char MIPS16 __not_in_flash_func(*getvalue)(unsigned char *p, MMFLOAT *fa, long long int *ia, unsigned char **sa, int *oo, int *ta) {
|
|
MMFLOAT f = 0;
|
|
long long int i64 = 0;
|
|
unsigned char *s = NULL;
|
|
int t = T_NOTYPE;
|
|
unsigned char *tp, *p1, *p2;
|
|
int i;
|
|
|
|
TestStackOverflow(); // throw an error if we have overflowed the PIC32's stack
|
|
|
|
skipspace(p);
|
|
if(*p>=C_BASETOKEN){ //don't waste time if not a built-in function
|
|
// special processing for the NOT operator
|
|
// just get the next value and invert its logical value
|
|
if(*p<=131){
|
|
// special processing for the unary operators
|
|
if(tokenfunction(*p) == op_not) {
|
|
int ro;
|
|
p++; t = T_NOTYPE;
|
|
p = getvalue(p, &f, &i64, &s, &ro, &t); // get the next value
|
|
if(t &T_NBR)
|
|
f = (MMFLOAT)((f != 0)?0:1); // invert the value returned
|
|
else if(t & T_INT)
|
|
i64 = ((i64 != 0)?0:1);
|
|
else
|
|
error("Expected a number");
|
|
skipspace(p);
|
|
*fa = f; // save what we have
|
|
*ia = i64;
|
|
*sa = s;
|
|
*ta = t;
|
|
*oo = ro;
|
|
return p; // return straight away as we already have the next operator
|
|
} else if(tokenfunction(*p) == op_inv) {
|
|
int ro;
|
|
p++; t = T_NOTYPE;
|
|
p = getvalue(p, &f, &i64, &s, &ro, &t); // get the next value
|
|
if(t & T_NBR)
|
|
i64 = FloatToInt64(f);
|
|
else if(!(t & T_INT))
|
|
error("Expected a number");
|
|
i64 = ~i64;
|
|
t = T_INT;
|
|
skipspace(p);
|
|
*fa = f; // save what we have
|
|
*ia = i64;
|
|
*sa = s;
|
|
*ta = t;
|
|
*oo = ro;
|
|
return p; // return straight away as we already have the next operator
|
|
} else if(tokenfunction(*p) == op_subtract) {
|
|
int ro;
|
|
p++; t = T_NOTYPE;
|
|
p = getvalue(p, &f, &i64, &s, &ro, &t); // get the next value
|
|
if(t & T_NBR)
|
|
f = -f; // negate the MMFLOAT returned
|
|
else if(t & T_INT)
|
|
i64 = -i64; // negate the integer returned
|
|
else
|
|
error("Expected a number");
|
|
skipspace(p);
|
|
*fa = f; // save what we have
|
|
*ia = i64;
|
|
*sa = s;
|
|
*ta = t;
|
|
*oo = ro;
|
|
return p; // return straight away as we already have the next operator
|
|
} else if(tokenfunction(*p) == op_add) {
|
|
int ro;
|
|
p++; t = T_NOTYPE;
|
|
p = getvalue(p, &f, &i64, &s, &ro, &t); // get the next value
|
|
skipspace(p);
|
|
*fa = f; // save what we have
|
|
*ia = i64;
|
|
*sa = s;
|
|
*ta = t;
|
|
*oo = ro;
|
|
return p; // return straight away as we already have the next operator
|
|
}
|
|
}
|
|
if(tokentype(*p) & (T_FUN | T_FNA)) {
|
|
// if a function execute it and save the result
|
|
int tmp;
|
|
tp = p;
|
|
// if it is a function with arguments we need to locate the closing bracket and copy the argument to
|
|
// a temporary variable so that functions like getarg() will work.
|
|
if(tokentype(*p) & T_FUN) {
|
|
p1 = p + 1;
|
|
p = getclosebracket(p); // find the closing bracket
|
|
p2 = ep = GetTempMemory(STRINGSIZE); // this will last for the life of the command
|
|
while(p1 != p) *p2++ = *p1++;
|
|
}
|
|
p++; // point to after the function (without argument) or after the closing bracket
|
|
tmp = targ = TypeMask(tokentype(*tp)); // set the type of the function (which might need to know this)
|
|
tokenfunction(*tp)(); // execute the function
|
|
if((tmp & targ) == 0) error("Internal fault 2(sorry)"); // as a safety check the function must return a type the same as set in the header
|
|
t = targ; // save the type of the function
|
|
f = fret; i64 = iret; s = sret; // save the result
|
|
}
|
|
} else {
|
|
// if it is a variable or a defined function, find it and get its value
|
|
if(isnamestart(*p)) {
|
|
// first check if it is terminated with a bracket
|
|
tp = p + 1;
|
|
while(isnamechar(*tp)) tp++; // search for the end of the identifier
|
|
if(*tp == '$' || *tp == '%' || *tp == '!') tp++;
|
|
i = -1;
|
|
if(*tp == '(') i = FindSubFun(p, 1); // if terminated with a bracket it could be a function
|
|
if(i >= 0) { // >= 0 means it is a user defined function
|
|
unsigned char *SaveCurrentLinePtr = CurrentLinePtr; // in case the code in DefinedSubFun messes with this
|
|
DefinedSubFun(true, p, i, &f, &i64, &s, &t);
|
|
CurrentLinePtr = SaveCurrentLinePtr;
|
|
} else {
|
|
s = (unsigned char *)findvar(p, V_FIND); // if it is a string then the string pointer is automatically set
|
|
t = TypeMask(g_vartbl[g_VarIndex].type);
|
|
if(t & T_NBR) f = (*(MMFLOAT *)s);
|
|
if(t & T_INT) i64 = (*(long long int *)s);
|
|
}
|
|
p = skipvar(p, false);
|
|
}
|
|
// is it an ordinary numeric constant? get its value if yes
|
|
// a leading + or - might have been converted to a token so we need to check for them also
|
|
else if(IsDigitinline(*p) || *p == '.') {
|
|
char ts[31], *tsp;
|
|
int isi64 = true;
|
|
tsp = ts;
|
|
int isf=true;
|
|
long long int scale=0;
|
|
// copy the first digit of the string to a temporary place
|
|
if(*p == '.') {
|
|
isi64 = false;
|
|
scale=1;
|
|
} else if(IsDigitinline(*p)){
|
|
i64=(*p - '0');
|
|
}
|
|
*tsp++ = *p++;
|
|
|
|
// now concatenate the remaining digits
|
|
while((digit[(uint8_t)*p]) && (tsp - ts) < 30) {
|
|
if(*p >= '0' && *p <= '9'){
|
|
i64 = i64 * 10 + (*p - '0');
|
|
if(scale)scale*=10;
|
|
} else {
|
|
if((*p) == '.'){
|
|
isi64 = false;
|
|
scale =1;
|
|
} else {
|
|
if(mytoupper(*p) == 'E' || *p == '-' || *p == '+' ){
|
|
isi64 = false;
|
|
isf=false;
|
|
}
|
|
}
|
|
}
|
|
*tsp++ = *p++; // copy the string to a temporary place
|
|
}
|
|
*tsp = 0; // terminate it
|
|
if(isi64) {
|
|
t = T_INT;
|
|
} else if(isf && (tsp - ts) < 18) {
|
|
f=(MMFLOAT)i64/(MMFLOAT)scale;
|
|
t = T_NBR;
|
|
} else {
|
|
f = (MMFLOAT)strtod(ts, &tsp); // and convert to a MMFLOAT
|
|
t = T_NBR;
|
|
}
|
|
}
|
|
|
|
|
|
// if it is a numeric constant starting with the & character then get its base and convert to an integer
|
|
else if(*p == '&') {
|
|
p++; i64 = 0;
|
|
switch(mytoupper(*p++)) {
|
|
case 'H': while(isxdigit(*p)) {
|
|
i64 = (i64 << 4) | ((mytoupper(*p) >= 'A') ? mytoupper(*p) - 'A' + 10 : *p - '0');
|
|
p++;
|
|
} break;
|
|
case 'O': while(*p >= '0' && *p <= '7') {
|
|
i64 = (i64 << 3) | (*p++ - '0');
|
|
} break;
|
|
case 'B': while(*p == '0' || *p == '1') {
|
|
i64 = (i64 << 1) | (*p++ - '0');
|
|
} break;
|
|
default: error("Type prefix");
|
|
}
|
|
t = T_INT;
|
|
}
|
|
// if opening bracket then first evaluate the contents of the bracket
|
|
else if(*p == '(') {
|
|
p++; // step over the bracket
|
|
p = evaluate(p, &f, &i64, &s, &t, true); // recursively get the contents
|
|
if(*p != ')') error("No closing bracket");
|
|
++p; // step over the closing bracket
|
|
}
|
|
// if it is a string constant, return a pointer to that. Note: tokenise() guarantees that strings end with a quote
|
|
else if(*p == '"') {
|
|
p++; // step over the quote
|
|
p1 = s = GetTempMemory(STRINGSIZE); // this will last for the life of the command
|
|
tp = (unsigned char *)strchr((char *)p, '"');
|
|
int toggle=0;
|
|
while(p != tp){
|
|
if(*p=='\\' && tp>p+1 && OptionEscape)toggle^=1;
|
|
if(toggle){
|
|
if(*p=='\\' && isdigit(p[1]) && isdigit(p[2]) && isdigit(p[3])){
|
|
p++;
|
|
i=(*p++)-48;
|
|
i*=10;
|
|
i+=(*p++)-48;
|
|
i*=10;
|
|
i+=(*p++)-48;
|
|
if(i==0)error("Null character \\000 in escape sequence - use CHR$(0)","$");
|
|
*p1++=i;
|
|
} else {
|
|
p++;
|
|
switch(*p){
|
|
case '\\':
|
|
*p1++='\\';
|
|
p++;
|
|
break;
|
|
case 'a':
|
|
*p1++='\a';
|
|
p++;
|
|
break;
|
|
case 'b':
|
|
*p1++='\b';
|
|
p++;
|
|
break;
|
|
case 'e':
|
|
*p1++='\e';
|
|
p++;
|
|
break;
|
|
case 'f':
|
|
*p1++='\f';
|
|
p++;
|
|
break;
|
|
case 'n':
|
|
*p1++='\n';
|
|
p++;
|
|
break;
|
|
case 'q':
|
|
*p1++='\"';
|
|
p++;
|
|
break;
|
|
case 'r':
|
|
*p1++='\r';
|
|
p++;
|
|
break;
|
|
case 't':
|
|
*p1++='\t';
|
|
p++;
|
|
break;
|
|
case 'v':
|
|
*p1++='\v';
|
|
p++;
|
|
break;
|
|
case '&':
|
|
p++;
|
|
if(isxdigit(*p) && isxdigit(p[1])){
|
|
i=0;
|
|
i = (i << 4) | ((mytoupper(*p) >= 'A') ? mytoupper(*p) - 'A' + 10 : *p - '0');
|
|
p++;
|
|
i = (i << 4) | ((mytoupper(*p) >= 'A') ? mytoupper(*p) - 'A' + 10 : *p - '0');
|
|
p++;
|
|
if(i==0)error("Null character \\&00 in escape sequence - use CHR$(0)","$");
|
|
*p1++=i;
|
|
} else *p1++='x';
|
|
break;
|
|
default:
|
|
*p1++=*p++;
|
|
}
|
|
}
|
|
toggle=0;
|
|
} else *p1++ = *p++;
|
|
}
|
|
p++;
|
|
CtoM(s); // convert to a MMBasic string
|
|
t = T_STR;
|
|
}
|
|
else
|
|
error("Syntax");
|
|
}
|
|
skipspace(p);
|
|
*fa = f; // save what we have
|
|
*ia = i64;
|
|
*sa = s;
|
|
*ta = t;
|
|
|
|
// get the next operator, if there is not an operator set the operator to end of expression (E_END)
|
|
if(tokentype(*p) & T_OPER)
|
|
*oo = *p++ - C_BASETOKEN;
|
|
else
|
|
*oo = E_END;
|
|
|
|
return p;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// search through program memory looking for a line number. Stops when it has a matching or larger number
|
|
// returns a pointer to the T_NEWLINE token or a pointer to the two zero characters representing the end of the program
|
|
unsigned char MIPS16 *findline(int nbr, int mustfind) {
|
|
unsigned char *p;
|
|
unsigned char *next;
|
|
int i,j=0;
|
|
p = ProgMemory;
|
|
next=LibMemory;
|
|
if (Option.LIBRARY_FLASH_SIZE==MAX_PROG_SIZE){
|
|
if (CurrentLinePtr >= LibMemory && CurrentLinePtr <= LibMemory + MAX_PROG_SIZE){
|
|
p=LibMemory;
|
|
next=ProgMemory;
|
|
}
|
|
}
|
|
while(1) {
|
|
if(p[0] == 0 && p[1] == 0) {
|
|
|
|
if (Option.LIBRARY_FLASH_SIZE==MAX_PROG_SIZE){
|
|
if(j==0){
|
|
j=1;
|
|
p = next;
|
|
}else{
|
|
i = MAXLINENBR;
|
|
break;
|
|
}
|
|
} else{
|
|
i = MAXLINENBR;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(p[0] == T_NEWLINE) {
|
|
p++;
|
|
continue;
|
|
}
|
|
|
|
if(p[0] == T_LINENBR) {
|
|
i = (p[1] << 8) | p[2];
|
|
if(mustfind) {
|
|
if(i == nbr) break;
|
|
} else {
|
|
if(i >= nbr) break;
|
|
}
|
|
p += 3;
|
|
continue;
|
|
}
|
|
|
|
if(p[0] == T_LABEL) {
|
|
p += p[1] + 2;
|
|
continue;
|
|
}
|
|
|
|
p++;
|
|
}
|
|
if(mustfind && i != nbr)
|
|
error("Line number");
|
|
return p;
|
|
}
|
|
#ifdef rp2350
|
|
void hashlabels(unsigned char *p,int ErrAbort){
|
|
//unsigned char *p = (unsigned char *)ProgMemory;
|
|
int j, u, namelen;
|
|
uint32_t originalhash,hash=FNV_offset_basis;
|
|
// char *lastp = (char *)ProgMemory + 1;
|
|
char *lastp = (char *)p + 1;
|
|
// now do the search
|
|
while(1) {
|
|
if(p[0] == 0 && p[1] == 0) // end of the program
|
|
break;
|
|
|
|
if(p[0] == T_NEWLINE) {
|
|
lastp = (char *)p; // save in case this is the right line
|
|
p++; // and step over the line number
|
|
continue;
|
|
}
|
|
|
|
if(p[0] == T_LINENBR) {
|
|
p += 3; // and step over the line number
|
|
continue;
|
|
}
|
|
|
|
if(p[0] == T_LABEL) {
|
|
p++; // point to the length of the label
|
|
hash=FNV_offset_basis;
|
|
namelen=0;
|
|
for(j=1;j<=p[0];j++) {
|
|
u=mytoupper(p[j]);
|
|
hash ^= u;
|
|
hash*=FNV_prime;
|
|
namelen++;
|
|
}
|
|
hash %= MAXSUBHASH; //scale to size of table
|
|
originalhash=hash-1;
|
|
if(originalhash<0)originalhash+=MAXSUBFUN;
|
|
while(funtbl[hash].name[0]!=0 && hash!=originalhash){
|
|
hash++;
|
|
hash %= MAXSUBFUN;
|
|
}
|
|
if(hash==originalhash){
|
|
MMPrintString("Error: Too many labels - erasing program\r\n");
|
|
unsigned char dummy=0;
|
|
cmdline=&dummy;
|
|
cmd_new();
|
|
// jump back to the input prompt
|
|
}
|
|
funtbl[hash].index=(uint32_t)lastp;
|
|
for(j=0;j<p[0];j++)funtbl[hash].name[j]=mytoupper(p[j+1]);
|
|
p += p[0] + 1; // still looking! skip over the label
|
|
continue;
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
|
|
// search through program memory looking for a label.
|
|
// returns a pointer to the T_NEWLINE token or throws an error if not found
|
|
// non cached version
|
|
unsigned char *findlabel(unsigned char *labelptr) {
|
|
// char *p, *lastp = (char *)ProgMemory + 1;
|
|
unsigned char *tp, *ip;
|
|
int i;
|
|
uint32_t hash=FNV_offset_basis;
|
|
char label[MAXVARLEN + 1];
|
|
|
|
// first, just exit we have a NULL argument
|
|
if(labelptr == NULL) return NULL;
|
|
|
|
// convert the label to the token format and load into label[]
|
|
// this assumes that the first character has already been verified as a valid label character
|
|
label[1] = mytoupper(*labelptr++);
|
|
hash ^= label[1];
|
|
hash*=FNV_prime;
|
|
for(i = 2; ; i++) {
|
|
if(!isnamechar(*labelptr)) break; // the end of the label
|
|
if(i > MAXVARLEN ) error("Label too long"); // too long, not a correctly formed label
|
|
label[i]=mytoupper(*labelptr++);
|
|
hash ^= label[i];
|
|
hash*=FNV_prime;
|
|
}
|
|
label[0] = i - 1; // the length byte
|
|
hash %= MAXSUBHASH; //scale to size of table
|
|
if(funtbl[hash].name[0]==0)error("Cannot find label");
|
|
while(funtbl[hash].name[0]!=0){
|
|
//if(funtbl[hash].index>=(uint32_t)ProgMemory){ //Is there a need to test this? Without this we can find labels in the Library
|
|
tp=(unsigned char *)funtbl[hash].name;
|
|
ip=(unsigned char *)&label[1];
|
|
if(*ip++ == *tp++) { // preliminary quick check
|
|
i = label[0]-1;
|
|
while(i > 0 && *ip == *tp) { // compare each letter
|
|
i--; ip++; tp++;
|
|
}
|
|
if(i == 0 && (*(char *)tp == 0)) { // found a matching name
|
|
return (unsigned char *)funtbl[hash].index;
|
|
}
|
|
}
|
|
//}
|
|
hash++;
|
|
hash %= MAXSUBFUN;
|
|
}
|
|
if(funtbl[hash].name[0]==0)error("Cannot find label");
|
|
return 0;
|
|
|
|
}
|
|
#else
|
|
unsigned char MIPS16 *findlabel(unsigned char *labelptr) {
|
|
char *p, *lastp = (char *)ProgMemory + 1;
|
|
char *next;
|
|
int i,j=0;
|
|
char label[MAXVARLEN + 1];
|
|
|
|
// first, just exit we have a NULL argument
|
|
if(labelptr == NULL) return NULL;
|
|
|
|
// convert the label to the token format and load into label[]
|
|
// this assumes that the first character has already been verified as a valid label character
|
|
label[1] = *labelptr++;
|
|
for(i = 2; ; i++) {
|
|
if(!isnamechar(*labelptr)) break; // the end of the label
|
|
if(i > MAXVARLEN ) error("Label too long"); // too long, not a correctly formed label
|
|
label[i] = *labelptr++;
|
|
}
|
|
label[0] = i - 1; // the length byte
|
|
|
|
p = (char *)ProgMemory;
|
|
next=(char *)LibMemory;
|
|
if (Option.LIBRARY_FLASH_SIZE==MAX_PROG_SIZE){
|
|
if (CurrentLinePtr >= LibMemory && CurrentLinePtr <= LibMemory + MAX_PROG_SIZE){
|
|
p=(char *)LibMemory;
|
|
next=(char *)ProgMemory;
|
|
}
|
|
}
|
|
|
|
// now do the search
|
|
while(1) {
|
|
if(p[0] == 0 && p[1] == 0) { // end of the program
|
|
if (Option.LIBRARY_FLASH_SIZE==MAX_PROG_SIZE){
|
|
if(j==0){
|
|
j=1;
|
|
p = next;
|
|
}else{
|
|
error("Cannot find label");
|
|
}
|
|
} else{
|
|
error("Cannot find label");
|
|
}
|
|
|
|
}
|
|
if(p[0] == T_NEWLINE) {
|
|
lastp = p; // save in case this is the right line
|
|
p++; // and step over the line number
|
|
continue;
|
|
}
|
|
|
|
if(p[0] == T_LINENBR) {
|
|
p += 3; // and step over the line number
|
|
continue;
|
|
}
|
|
|
|
if(p[0] == T_LABEL) {
|
|
p++; // point to the length of the label
|
|
if(mem_equal((unsigned char *)p, (unsigned char *)label, label[0] + 1)) // compare the strings including the length byte
|
|
return (unsigned char *)lastp; // and if successful return pointing to the beginning of the line
|
|
p += p[0] + 1; // still looking! skip over the label
|
|
continue;
|
|
}
|
|
|
|
p++;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// returns true if 'line' is a valid line in the program
|
|
int IsValidLine(int nbr) {
|
|
unsigned char *p;
|
|
p = findline(nbr, false);
|
|
if(*p == T_NEWLINE) p++;
|
|
if(*p == T_LINENBR) {
|
|
if(((p[1] << 8) | p[2]) == nbr) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
// count the number of lines up to and including the line pointed to by the argument
|
|
// used for error reporting in programs that do not use line numbers
|
|
int MIPS16 CountLines(unsigned char *target) {
|
|
unsigned char *p;
|
|
int cnt;
|
|
|
|
p = ProgMemory;
|
|
if(ProgMemory[0]==1 && ProgMemory[1]==39 && ProgMemory[2]==35)cnt=-1;
|
|
else cnt = 0;
|
|
|
|
while(1) {
|
|
if(*p == 0xff || (p[0] == 0 && p[1] == 0)) // end of the program
|
|
return cnt;
|
|
|
|
if(*p == T_NEWLINE) {
|
|
p++; // and step over the line number
|
|
cnt++;
|
|
if(p >= target) return cnt;
|
|
continue;
|
|
}
|
|
|
|
if(*p == T_LINENBR) {
|
|
p += 3; // and step over the line number
|
|
continue;
|
|
}
|
|
|
|
if(*p == T_LABEL) {
|
|
p += p[0] + 2; // still looking! skip over the label
|
|
continue;
|
|
}
|
|
|
|
if(p++ > target) return cnt;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/********************************************************************************************************************************************
|
|
routines for storing and manipulating variables
|
|
********************************************************************************************************************************************/
|
|
|
|
|
|
// find or create a variable
|
|
// the action parameter can be the following (these can be ORed together)
|
|
// - V_FIND a straight forward find, if the variable is not found it is created and set to zero
|
|
// - V_NOFIND_ERR throw an error if not found
|
|
// - V_NOFIND_NULL return a null pointer if not found
|
|
// - V_DIM_VAR dimension an array
|
|
// - V_LOCAL create a local variable
|
|
//
|
|
// there are four types of variable:
|
|
// - T_NOTYPE a free slot that was used but is now free for reuse
|
|
// - T_STR string variable
|
|
// - T_NBR holds a float
|
|
// - T_INT integer variable
|
|
//
|
|
// A variable can have a number of characteristics
|
|
// - T_PTR the variable points to another variable's data
|
|
// - T_IMPLIED the variables type does not have to be specified with a suffix
|
|
// - T_CONST the contents of this variable cannot be changed
|
|
// - T_FUNCT this variable represents the return value from a function
|
|
//
|
|
// storage of the variable's data:
|
|
// if it is type T_NBR or T_INT the value is held in the variable slot
|
|
// for T_STR a block of memory of MAXSTRLEN size (or size determined by the LENGTH keyword) will be malloc'ed and the pointer stored in the variable slot.
|
|
#ifdef PICOMITEWEB
|
|
#ifdef rp2350
|
|
void MIPS16 __not_in_flash_func(*findvar)(unsigned char *p, int action) {
|
|
#else
|
|
void MIPS16 *findvar(unsigned char *p, int action) {
|
|
#endif
|
|
#else
|
|
void MIPS16 __not_in_flash_func(*findvar)(unsigned char *p, int action) {
|
|
#endif
|
|
unsigned char name[MAXVARLEN + 1];
|
|
int i=0, j, size, ifree, globalifree, localifree, nbr, vtype, vindex, namelen, tmp;
|
|
unsigned char *s, *x, u, suffix=0;
|
|
void *mptr;
|
|
// int hashIndex=0;
|
|
int GlobalhashIndex, OriginalGlobalHash;
|
|
int LocalhashIndex, OriginalLocalHash;
|
|
uint32_t hash=FNV_offset_basis;
|
|
#ifdef rp2350
|
|
uint32_t funhash;
|
|
#endif
|
|
char *tp, *ip;
|
|
int dim[MAXDIM]={0}, dnbr;
|
|
// if(__get_MSP() < (uint32_t)&stackcheck-0x5000){
|
|
// error("Expression is too complex at depth %",g_LocalIndex);
|
|
// }
|
|
vtype = dnbr = emptyarray = 0;
|
|
// first zero the array used for holding the dimension values
|
|
// for(i = 0; i < MAXDIM; i++) dim[i] = 0;
|
|
ifree = -1;
|
|
|
|
// check the first char for a legal variable name
|
|
skipspace(p);
|
|
if(!isnamestart(*p)) error("Variable name");
|
|
|
|
// copy the variable name into name
|
|
s = name; namelen = 0;
|
|
do {
|
|
u=mytoupper(*p++);
|
|
hash ^= u;
|
|
hash*=FNV_prime;
|
|
*s++ = u;
|
|
if(++namelen > MAXVARLEN) error("Variable name too long");
|
|
} while(isnamechar(*p));
|
|
#ifdef rp2350
|
|
funhash=hash % MAXSUBHASH;
|
|
#endif
|
|
hash %= MAXVARHASH; //scale 0-255
|
|
|
|
if(namelen!=MAXVARLEN)*s=0;
|
|
// check the terminating char and set the type
|
|
if(*p == '$') {
|
|
if((action & T_IMPLIED) && !(action & T_STR)) error("Conflicting variable type");
|
|
vtype = T_STR;
|
|
suffix=1;
|
|
p++;
|
|
} else if(*p == '%') {
|
|
if((action & T_IMPLIED) && !(action & T_INT)) error("Conflicting variable type");
|
|
vtype = T_INT;
|
|
suffix=1;
|
|
p++;
|
|
} else if(*p == '!') {
|
|
if((action & T_IMPLIED) && !(action & T_NBR)) error("Conflicting variable type");
|
|
vtype = T_NBR;
|
|
suffix=1;
|
|
p++;
|
|
} else if((action & V_DIM_VAR) && DefaultType == T_NOTYPE && !(action & T_IMPLIED))
|
|
error("Variable type not specified");
|
|
else
|
|
vtype = 0;
|
|
|
|
// check if this is an array
|
|
if(*p == '(') {
|
|
char *pp = (char *)p + 1;
|
|
skipspace(pp);
|
|
if(action & V_EMPTY_OK && *pp == ')') { // if this is an empty array. eg ()
|
|
emptyarray=1;
|
|
dnbr = -1; // flag this
|
|
} else { // else, get the dimensions
|
|
// start a new block - getargs macro must be the first executable stmt in a block
|
|
// split the argument into individual elements
|
|
// find the value of each dimension and store in dims[]
|
|
// the bracket in "(," is a signal to getargs that the list is in brackets
|
|
getargs(&p, MAXDIM * 2, (unsigned char *)"(,");
|
|
if((argc & 0x01) == 0) error("Dimensions");
|
|
dnbr = argc/2 + 1;
|
|
if(dnbr > MAXDIM) error("Dimensions");
|
|
for(i = 0; i < argc; i += 2) {
|
|
MMFLOAT f;
|
|
long long int in;
|
|
char *s;
|
|
int targ = T_NOTYPE;
|
|
evaluate(argv[i], &f, &in, (unsigned char **)&s, &targ, false); // get the value and type of the argument
|
|
if(targ == T_STR) dnbr = MAXDIM; // force an error to be thrown later (with the correct message)
|
|
if(targ == T_NBR) in = FloatToInt32(f);
|
|
dim[i/2] = in;
|
|
if(dim[i/2] < g_OptionBase) error("Dimensions");
|
|
}
|
|
}
|
|
}
|
|
|
|
// we now have the variable name and, if it is an array, the parameters
|
|
// search the table looking for a match
|
|
|
|
LocalhashIndex=hash;
|
|
OriginalLocalHash=LocalhashIndex-1;
|
|
if(OriginalLocalHash<0)OriginalLocalHash+=MAXVARS/2;
|
|
localifree=-1;
|
|
GlobalhashIndex=hash+MAXVARS/2;
|
|
OriginalGlobalHash=GlobalhashIndex-1;
|
|
if(OriginalGlobalHash<MAXVARS/2)OriginalGlobalHash+=MAXVARS/2;
|
|
globalifree=-1;
|
|
tmp=-1;
|
|
if(g_LocalIndex){ //search
|
|
if(g_vartbl[LocalhashIndex].type == T_NOTYPE){
|
|
localifree = LocalhashIndex;
|
|
} else {
|
|
while(g_vartbl[LocalhashIndex].name[0]!=0){
|
|
ip=(char *)name;
|
|
tp=(char *)g_vartbl[LocalhashIndex].name;
|
|
if(g_vartbl[LocalhashIndex].type==T_BLOCKED)tmp=LocalhashIndex;
|
|
if(*ip++ == *tp++) { // preliminary quick check
|
|
j = namelen-1;
|
|
while(j > 0 && *ip == *tp) { // compare each letter
|
|
j--; ip++; tp++;
|
|
}
|
|
if(j == 0 && (*(char *)tp == 0 || namelen == MAXVARLEN)) { // found a matching name
|
|
if(g_vartbl[LocalhashIndex].level == g_LocalIndex) break; //matching global while not in a subroutine
|
|
}
|
|
}
|
|
LocalhashIndex++;
|
|
LocalhashIndex %= MAXVARS/2;
|
|
if(LocalhashIndex==OriginalLocalHash)error("Too many local variables");
|
|
}
|
|
if(g_vartbl[LocalhashIndex].name[0]==0){ // not found
|
|
localifree=LocalhashIndex;
|
|
if(tmp!=-1){
|
|
localifree=tmp;
|
|
g_vartbl[LocalhashIndex].type=T_NOTYPE;
|
|
g_vartbl[LocalhashIndex].name[0]=0;
|
|
}
|
|
}
|
|
}
|
|
if(g_vartbl[LocalhashIndex].name[0]==0){ // not found in the local table so try the global
|
|
tmp=-1;
|
|
globalifree=-1;
|
|
if(g_vartbl[GlobalhashIndex].type == T_NOTYPE){
|
|
globalifree = GlobalhashIndex;
|
|
} else {
|
|
while(g_vartbl[GlobalhashIndex].name[0]!=0){
|
|
ip=(char *)name;
|
|
tp=(char *)g_vartbl[GlobalhashIndex].name;
|
|
if(g_vartbl[GlobalhashIndex].type==T_BLOCKED)tmp=GlobalhashIndex;
|
|
if(*ip++ == *tp++) { // preliminary quick check
|
|
j = namelen-1;
|
|
while(j > 0 && *ip == *tp) { // compare each letter
|
|
j--; ip++; tp++;
|
|
}
|
|
if(j == 0 && (*(char *)tp == 0 || namelen == MAXVARLEN)) { // found a matching name
|
|
break; //matching global while not in a subroutine
|
|
}
|
|
}
|
|
GlobalhashIndex++;
|
|
if(GlobalhashIndex==MAXVARS)GlobalhashIndex=MAXVARS/2;
|
|
if(GlobalhashIndex==OriginalGlobalHash)error("Too many global variables");
|
|
}
|
|
if(g_vartbl[GlobalhashIndex].name[0]==0){ // not found
|
|
globalifree=GlobalhashIndex;
|
|
if(tmp!=-1){
|
|
globalifree=tmp;
|
|
g_vartbl[GlobalhashIndex].type=T_NOTYPE;
|
|
g_vartbl[GlobalhashIndex].name[0]=0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
localifree=9999; //set a marker that a local variable is irrelevant
|
|
if(g_vartbl[GlobalhashIndex].type == T_NOTYPE){
|
|
globalifree = GlobalhashIndex;
|
|
} else {
|
|
while(g_vartbl[GlobalhashIndex].name[0]!=0){
|
|
ip=(char *)name;
|
|
tp=(char *)g_vartbl[GlobalhashIndex].name;
|
|
if(g_vartbl[GlobalhashIndex].type==T_BLOCKED)tmp=GlobalhashIndex;
|
|
if(*ip++ == *tp++) { // preliminary quick check
|
|
j = namelen-1;
|
|
while(j > 0 && *ip == *tp) { // compare each letter
|
|
j--; ip++; tp++;
|
|
}
|
|
if(j == 0 && (*(char *)tp == 0 || namelen == MAXVARLEN)) { // found a matching name
|
|
break; //matching global while not in a subroutine
|
|
}
|
|
}
|
|
GlobalhashIndex++;
|
|
if(GlobalhashIndex==MAXVARS)GlobalhashIndex=MAXVARS/2;
|
|
}
|
|
if(g_vartbl[GlobalhashIndex].name[0]==0){ // not found
|
|
globalifree=GlobalhashIndex;
|
|
if(tmp!=-1){
|
|
globalifree=tmp;
|
|
g_vartbl[GlobalhashIndex].type=T_NOTYPE;
|
|
g_vartbl[GlobalhashIndex].name[0]=0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// MMPrintString("search status : ");PInt(g_LocalIndex);PIntComma(localifree);PIntComma(LocalhashIndex);PIntComma(globalifree);PIntComma(GlobalhashIndex);
|
|
// MMPrintString((action & V_LOCAL ? " LOCAL" : " "));MMPrintString((action & V_LOCAL ? " DIM" : " "));PRet();
|
|
// At this point we know if a local variable has been found or if a global variable has been found
|
|
if(action & V_LOCAL) {
|
|
// if we declared the variable as LOCAL within a sub/fun and an existing local was found
|
|
if(localifree==-1) error("$ Local variable already declared", name);
|
|
} else if(action & V_DIM_VAR) {
|
|
// if are using DIM to declare a global variable and an existing global variable was found
|
|
if(globalifree==-1 ) error("$ Global variable already declared", name);
|
|
}
|
|
// we are not declaring the variable but it may need to be created
|
|
if(action & V_LOCAL) {
|
|
ifree = i = localifree;
|
|
} else if(localifree==-1){ // can only happen when a local variable has been found so we can ignore everything global
|
|
ifree= -1;
|
|
i = LocalhashIndex;
|
|
} else if(globalifree==-1){ //A global variable has been found
|
|
ifree= -1;
|
|
i = GlobalhashIndex;
|
|
} else { //nothing has been found so we are going to create a global unless EXPLICIT is set
|
|
ifree = i = globalifree;
|
|
}
|
|
|
|
// MMPrintString(name);PIntComma(i);MMPrintString((ifree==-1 ? " - found" : " - not there"));PRet();
|
|
|
|
// if we found an existing and matching variable
|
|
// set the global g_VarIndex indicating the index in the table
|
|
if(ifree==-1 && g_vartbl[i].name[0] != 0) {
|
|
g_VarIndex = vindex = i;
|
|
|
|
// check that the dimensions match
|
|
for(i = 0; i < MAXDIM && g_vartbl[vindex].dims[i] != 0; i++);
|
|
if(dnbr == -1) {
|
|
if(i == 0) error("Array dimensions");
|
|
} else {
|
|
if(i != dnbr) error("Array dimensions");
|
|
}
|
|
|
|
if(vtype == 0) {
|
|
if(!(g_vartbl[vindex].type & (DefaultType | T_IMPLIED))) error("$ Different type already declared", name);
|
|
} else {
|
|
if(!(g_vartbl[vindex].type & vtype)) error("$ Different type already declared", name);
|
|
}
|
|
|
|
// if it is a non arrayed variable or an empty array it is easy, just calculate and return a pointer to the value
|
|
if(dnbr == -1 || g_vartbl[vindex].dims[0] == 0) {
|
|
if(dnbr == -1 || g_vartbl[vindex].type & (T_PTR | T_STR))
|
|
return g_vartbl[vindex].val.s; // if it is a string or pointer just return the pointer to the data
|
|
else
|
|
if(g_vartbl[vindex].type & (T_INT))
|
|
return &(g_vartbl[vindex].val.i); // must be an integer, point to its value
|
|
else
|
|
return &(g_vartbl[vindex].val.f); // must be a straight number (float), point to its value
|
|
}
|
|
|
|
// if we reached this point it must be a reference to an existing array
|
|
// check that we are not using DIM and that all parameters are within the dimensions
|
|
if(action & V_DIM_VAR) error("Cannot re dimension array");
|
|
for(i = 0; i < dnbr; i++) {
|
|
if(dim[i] > g_vartbl[vindex].dims[i] || dim[i] < g_OptionBase)
|
|
error("Index out of bounds");
|
|
}
|
|
|
|
// then calculate the index into the array. Bug fix by Gerard Sexton.
|
|
nbr = dim[0] - g_OptionBase;
|
|
j = 1;
|
|
for(i = 1; i < dnbr; i++) {
|
|
j *= (g_vartbl[vindex].dims[i - 1] + 1 - g_OptionBase);
|
|
nbr += (dim[i] - g_OptionBase) * j;
|
|
}
|
|
// finally return a pointer to the value
|
|
if(g_vartbl[vindex].type & T_NBR)
|
|
return g_vartbl[vindex].val.s + (nbr * sizeof(MMFLOAT));
|
|
else
|
|
if(g_vartbl[vindex].type & T_INT)
|
|
return g_vartbl[vindex].val.s + (nbr * sizeof(long long int));
|
|
else
|
|
return g_vartbl[vindex].val.s + (nbr * (g_vartbl[vindex].size + 1));
|
|
}
|
|
|
|
// we reached this point if no existing variable has been found
|
|
if(action & V_NOFIND_ERR) error("Cannot find $", name);
|
|
if(action & V_NOFIND_NULL) return NULL;
|
|
if((OptionExplicit || dnbr != 0) && !(action & V_DIM_VAR))
|
|
error("$ is not declared", name);
|
|
if(vtype == 0) {
|
|
if(action & T_IMPLIED)
|
|
vtype = (action & (T_NBR | T_INT | T_STR));
|
|
else
|
|
vtype = DefaultType;
|
|
}
|
|
// now scan the sub/fun table to make sure that there is not a sub/fun with the same name
|
|
#ifdef rp2350
|
|
if(!(action & V_FUNCT) && (funtbl[funhash].name[0])) { // don't do this if we are defining the local variable for a function name
|
|
while(funtbl[funhash].name[0]!=0){
|
|
ip=(char *)name;
|
|
tp=funtbl[funhash].name;
|
|
if(*ip++ == *tp++) { // preliminary quick check
|
|
j = namelen-1;
|
|
while(j > 0 && *ip == *tp) { // compare each letter
|
|
j--; ip++; tp++;
|
|
}
|
|
if(j == 0 && (*(char *)tp == 0 || namelen == MAXVARLEN)) { // found a matching name
|
|
if(funtbl[funhash].index<MAXSUBFUN)error("A sub/fun has the same name: $", name);
|
|
}
|
|
}
|
|
funhash++;
|
|
if(funhash==MAXSUBFUN)funhash=0;
|
|
}
|
|
}
|
|
#else
|
|
if(!(action & V_FUNCT)) { // don't do this if we are defining the local variable for a function name
|
|
for(i = 0; i < MAXSUBFUN && subfun[i] != NULL; i++) {
|
|
x = subfun[i]; // point to the command token
|
|
x++; skipspace(x); // point to the identifier
|
|
s = name; // point to the new variable
|
|
if(*s != toupper(*x)) continue; // quick first test
|
|
while(1) {
|
|
if(!isnamechar(*s) && !isnamechar(*x)) error("A sub/fun has the same name: $", name);
|
|
if(*s != toupper(*x) || *s == 0 || !isnamechar(*x) || s - name >= MAXVARLEN) break;
|
|
s++; x++;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
// set a default string size
|
|
size = MAXSTRLEN;
|
|
|
|
// if it is an array we must be dimensioning it
|
|
// if it is a string array we skip over the dimension values and look for the LENGTH keyword
|
|
// and if found find the string size and change the g_vartbl entry
|
|
if(action & V_DIM_VAR) {
|
|
if(vtype & T_STR) {
|
|
i = 0;
|
|
if(*p == '(') {
|
|
do {
|
|
if(*p == '(') i++;
|
|
if(tokentype(*p) & T_FUN) i++;
|
|
if(*p == ')') i--;
|
|
p++;
|
|
} while(i);
|
|
}
|
|
skipspace(p);
|
|
if((s = checkstring(p, (unsigned char *)"LENGTH")) != NULL)
|
|
size = getint(s, 1, MAXSTRLEN) ;
|
|
else
|
|
if(!(*p == ',' || *p == 0 || tokenfunction(*p) == op_equal || tokenfunction(*p) == op_invalid)) error("Unexpected text: $", p);
|
|
}
|
|
}
|
|
|
|
|
|
// at this point we need to create the variable
|
|
// as a result of the previous search ifree is the index to the entry that we should use
|
|
|
|
// if we are adding to the top, increment the number of vars
|
|
if(ifree>=MAXVARS/2){
|
|
g_Globalvarcnt++;
|
|
if(g_Globalvarcnt>=MAXVARS/2)error("Not enough Global variable memory");
|
|
} else {
|
|
g_Localvarcnt++;
|
|
if(g_Localvarcnt>=MAXVARS/2)error("Not enough Local variable memory");
|
|
}
|
|
g_varcnt=g_Globalvarcnt+g_Localvarcnt;
|
|
g_VarIndex = vindex = ifree;
|
|
|
|
// initialise it: save the name, set the initial value to zero and set the type
|
|
s = name; x = g_vartbl[ifree].name; j = namelen;
|
|
while(j--) *x++ = *s++;
|
|
if(namelen < MAXVARLEN)*x++ = 0;
|
|
g_vartbl[ifree].type = vtype | (action & (T_IMPLIED | T_CONST));
|
|
if(suffix)g_vartbl[ifree].type|=T_EXPLICIT;
|
|
if(ifree<MAXVARS/2){
|
|
g_hashlist[g_hashlistpointer].level=g_LocalIndex;
|
|
g_hashlist[g_hashlistpointer++].hash=ifree;
|
|
g_vartbl[ifree].level = g_LocalIndex;
|
|
} else g_vartbl[ifree].level = 0;
|
|
// cleardims(&g_vartbl[ifree].dims[0]);
|
|
for(j = 0; j < MAXDIM; j++) g_vartbl[ifree].dims[j] = 0;
|
|
// MMPrintString("Creating variable : ");MMPrintString(g_vartbl[ifree].name);MMPrintString(", at depth : ");PInt(g_vartbl[ifree].level);MMPrintString(", Type : ");PInt(vtype);MMPrintString(", hash key : ");PInt(ifree);PRet();
|
|
// the easy request is for is a non array numeric variable, so just initialise to
|
|
// zero and return the pointer
|
|
if(dnbr == 0) {
|
|
if(vtype & T_NBR) {
|
|
g_vartbl[ifree].val.f = 0;
|
|
return &(g_vartbl[ifree].val.f);
|
|
} else if(vtype & T_INT) {
|
|
g_vartbl[ifree].val.i = 0;
|
|
return &(g_vartbl[ifree].val.i);
|
|
}
|
|
}
|
|
|
|
// if this is a definition of an empty array (only used in the parameter list for a sub/function)
|
|
if(dnbr == -1) {
|
|
g_vartbl[vindex].dims[0] = -1; // let the caller know that this is an empty array and needs more work
|
|
return g_vartbl[vindex].val.s; // just return a pointer to the data element as it will be replaced in the sub/fun with a pointer
|
|
}
|
|
|
|
// if this is an array copy the array dimensions and calculate the overall size
|
|
// for a non array string this will leave nbr = 1 which is just what we want
|
|
for(nbr = 1, i = 0; i < dnbr; i++) {
|
|
if(dim[i] <= g_OptionBase) error("Dimensions");
|
|
g_vartbl[vindex].dims[i] = dim[i];
|
|
nbr *= (dim[i] + 1 - g_OptionBase);
|
|
}
|
|
|
|
// we now have a string, an array of strings or an array of numbers
|
|
// all need some memory to be allocated (note: GetMemory() zeros the memory)
|
|
|
|
// First, set the important characteristics of the variable to indicate that the
|
|
// variable is not allocated. Thus, if GetMemory() fails with "not enough memory",
|
|
// the variable will remain not allocated
|
|
g_vartbl[ifree].val.s = NULL;
|
|
g_vartbl[ifree].type = T_BLOCKED;
|
|
i = *g_vartbl[ifree].name; *g_vartbl[ifree].name = 0;
|
|
j = g_vartbl[ifree].dims[0]; g_vartbl[ifree].dims[0] = 0;
|
|
|
|
|
|
// Now, grab the memory
|
|
if(vtype & (T_NBR | T_INT)) {
|
|
tmp=(nbr * sizeof(MMFLOAT));
|
|
if(tmp<=256)mptr = GetMemory(STRINGSIZE);
|
|
else mptr = GetMemory(tmp);
|
|
} else {
|
|
tmp=(nbr * (size + 1));
|
|
if(tmp<=(MAXDIM-1)*sizeof(g_vartbl[ifree].dims[1]) && j==0)mptr = (void *)&g_vartbl[ifree].dims[1];
|
|
else if(tmp<=256)mptr = GetMemory(STRINGSIZE);
|
|
else mptr = GetMemory(tmp);
|
|
}
|
|
|
|
|
|
// If we reached here the memory request was successful, so restore the details of
|
|
// the variable that were saved previously and set the variables pointer to the
|
|
// allocated memory
|
|
g_vartbl[ifree].type = vtype | (action & (T_IMPLIED | T_CONST));
|
|
if(suffix)g_vartbl[ifree].type|=T_EXPLICIT;
|
|
*g_vartbl[ifree].name = i;
|
|
g_vartbl[ifree].dims[0] = j;
|
|
g_vartbl[ifree].size = size;
|
|
g_vartbl[ifree].val.s = mptr;
|
|
return mptr;
|
|
}
|
|
|
|
|
|
|
|
|
|
/********************************************************************************************************************************************
|
|
utility routines
|
|
these routines form a library of functions that any command or function can use when dealing with its arguments
|
|
by centralising these routines it is hoped that bugs can be more easily found and corrected (unlike bwBasic !)
|
|
*********************************************************************************************************************************************/
|
|
|
|
// take a line of basic code and split it into arguments
|
|
// this function should always be called via the macro getargs
|
|
//
|
|
// a new argument is created by any of the chars in the string delim (not in brackets or quotes)
|
|
// with this function commands have much less work to do to evaluate the arguments
|
|
//
|
|
// The arguments are:
|
|
// pointer to a pointer which points to the string to be broken into arguments.
|
|
// the maximum number of arguments that are expected. an error will be thrown if more than this are found.
|
|
// buffer where the returned strings are to be stored
|
|
// pointer to an array of strings that will contain (after the function has returned) the values of each argument
|
|
// pointer to an integer that will contain (after the function has returned) the number of arguments found
|
|
// pointer to a string that contains the characters to be used in spliting up the line. If the first unsigned char of that
|
|
// string is an opening bracket '(' this function will expect the arg list to be enclosed in brackets.
|
|
void MIPS16 __not_in_flash_func(makeargs)(unsigned char **p, int maxargs, unsigned char *argbuf, unsigned char *argv[], int *argc, unsigned char *delim) {
|
|
unsigned char *op;
|
|
int inarg, expect_cmd, expect_bracket, then_tkn, else_tkn;
|
|
unsigned char *tp;
|
|
|
|
TestStackOverflow(); // throw an error if we have overflowed the PIC32's stack
|
|
|
|
tp = *p;
|
|
op = argbuf;
|
|
*argc = 0;
|
|
inarg = false;
|
|
expect_cmd = false;
|
|
expect_bracket = false;
|
|
then_tkn = tokenTHEN;
|
|
else_tkn = tokenELSE;
|
|
|
|
// skip leading spaces
|
|
while(*tp == ' ') tp++;
|
|
|
|
// check if we are processing a list enclosed in brackets and if so
|
|
// - skip the opening bracket
|
|
// - flag that a closing bracket should be found
|
|
if(*delim == '(') {
|
|
if(*tp != '(')
|
|
error("Syntax");
|
|
expect_bracket = true;
|
|
delim++;
|
|
tp++;
|
|
}
|
|
|
|
// the main processing loop
|
|
while(*tp) {
|
|
|
|
if(expect_bracket == true && *tp == ')') break;
|
|
|
|
// comment char causes the rest of the line to be skipped
|
|
if(*tp == '\'') {
|
|
break;
|
|
}
|
|
|
|
// the special characters that cause the line to be split up are in the string delim
|
|
// any other chars form part of the one argument
|
|
if(strchr((char *)delim, (char)*tp) != NULL && !expect_cmd) {
|
|
if(*tp == then_tkn || *tp == else_tkn) expect_cmd = true;
|
|
if(inarg) { // if we have been processing an argument
|
|
while(op > argbuf && *(op - 1) == ' ') op--; // trim trailing spaces
|
|
*op++ = 0; // terminate it
|
|
} else if(*argc) { // otherwise we have two delimiters in a row (except for the first argument)
|
|
argv[(*argc)++] = op; // create a null argument to go between the two delimiters
|
|
*op++ = 0; // and terminate it
|
|
}
|
|
|
|
inarg = false;
|
|
if(*argc >= maxargs) error("Syntax");
|
|
argv[(*argc)++] = op; // save the pointer for this delimiter
|
|
*op++ = *tp++; // copy the token or char (always one)
|
|
*op++ = 0; // terminate it
|
|
continue;
|
|
}
|
|
|
|
// check if we have a THEN or ELSE token and if so flag that a command should be next
|
|
if(*tp == then_tkn || *tp == else_tkn) expect_cmd = true;
|
|
|
|
|
|
// remove all spaces (outside of quoted text and bracketed text)
|
|
if(!inarg && *tp == ' ') {
|
|
tp++;
|
|
continue;
|
|
}
|
|
|
|
// not a special char so we must start a new argument
|
|
if(!inarg) {
|
|
if(*argc >= maxargs) error("Syntax");
|
|
argv[(*argc)++] = op; // save the pointer for this arg
|
|
inarg = true;
|
|
}
|
|
|
|
// if an opening bracket '(' copy everything until we hit the matching closing bracket
|
|
// this includes special characters such as , and ; and keeps track of any nested brackets
|
|
if(*tp == '(' || ((tokentype(*tp) & T_FUN) && !expect_cmd)) {
|
|
int x;
|
|
x = (getclosebracket(tp) - tp) + 1;
|
|
memcpy(op, tp, x);
|
|
op += x; tp += x;
|
|
continue;
|
|
}
|
|
|
|
// if quote mark (") copy everything until the closing quote
|
|
// this includes special characters such as , and ;
|
|
// the tokenise() function will have ensured that the closing quote is always there
|
|
if(*tp == '"') {
|
|
do {
|
|
*op++ = *tp++;
|
|
if(*tp == 0) error("Syntax");
|
|
} while(*tp != '"');
|
|
*op++ = *tp++;
|
|
continue;
|
|
}
|
|
|
|
// anything else is just copied into the argument
|
|
*op++ = *tp++;
|
|
if(expect_cmd)*op++ = *tp++; //copy rest of command token
|
|
expect_cmd = false;
|
|
}
|
|
if(expect_bracket && *tp != ')') error("Syntax");
|
|
while(op - 1 > argbuf && *(op-1) == ' ') --op; // trim any trailing spaces on the last argument
|
|
*op = 0; // terminate the last argument
|
|
}
|
|
|
|
|
|
static void MIPS16 display_string(const char *s, bool fill) {
|
|
// Indent each line by one space.
|
|
if (CurrentX == 0) DisplayPutC(' ');
|
|
|
|
// Display characters one at a time,
|
|
for (const char *p = s; *p; ++p) {
|
|
if (CurrentX + gui_font_width >= HRes) {
|
|
DisplayPutC(' '); // Leave one space at the end of each line and wrap to the next.
|
|
DisplayPutC(' '); // Indent each new line by one space.
|
|
if (*p == ' ') continue; // Skip first space on each new line.
|
|
}
|
|
DisplayPutC(*p);
|
|
}
|
|
|
|
// Fill to the end of the line with spaces.
|
|
if (fill) {
|
|
while (CurrentX + gui_font_width <= HRes) DisplayPutC(' ');
|
|
CurrentX = 0;
|
|
CurrentY += gui_font_height;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Displays an error message with context on the display.
|
|
*
|
|
* @param line_num The error line,
|
|
* -1 for the LIBRARY,
|
|
* -2 when error occurs at the prompt.
|
|
* @param line_txt The text of the line that caused the error.
|
|
* @param error_msg The error message.
|
|
*/
|
|
void MIPS16 LCD_error(int line_num, const char *line_txt, const char* error_msg) {
|
|
if (HRes == 0) return; // No display configured.
|
|
|
|
// Always write error to the actual display.
|
|
restorepanel();
|
|
|
|
// Store current property display values.
|
|
const unsigned char old_console = Option.DISPLAY_CONSOLE;
|
|
const int old_font = gui_font;
|
|
const int old_fcolour = gui_fcolour;
|
|
const int old_bcolour = gui_bcolour;
|
|
|
|
// Override properties required by DisplayPutC.
|
|
const int font = 1;
|
|
Option.DISPLAY_CONSOLE = 1;
|
|
SetFont(font);
|
|
gui_fcolour = 0xEE4B2B; // Bright Red.
|
|
gui_bcolour = 0x0;
|
|
|
|
// Display the error message halfway down the display (approx.)
|
|
const int chars_per_line = (HRes / gui_font_width) - 2;
|
|
int num_lines = 2;
|
|
num_lines += strlen(error_msg) / chars_per_line;
|
|
if (strlen(error_msg) % chars_per_line > 0) num_lines++;
|
|
num_lines += strlen(line_txt) / chars_per_line;
|
|
if (strlen(line_txt) % chars_per_line > 0) num_lines++;
|
|
CurrentX = 0;
|
|
CurrentY = (VRes / 2) - (num_lines * gui_font_height / 2);
|
|
|
|
display_string("", true);
|
|
display_string("ERROR: ", false);
|
|
display_string(error_msg, true);
|
|
if (*line_txt) {
|
|
char buf[32];
|
|
if (line_num == -1) {
|
|
sprintf(buf, "[LIBRARY] ");
|
|
} else {
|
|
sprintf(buf, "[%d] ", line_num);
|
|
}
|
|
display_string(buf, false);
|
|
display_string(line_txt, true);
|
|
}
|
|
display_string("", true);
|
|
|
|
// Restore display property values.
|
|
SetFont(old_font);
|
|
PromptFont=old_font;
|
|
Option.DISPLAY_CONSOLE = old_console;
|
|
gui_fcolour = old_fcolour;
|
|
gui_bcolour = old_bcolour;
|
|
}
|
|
// throw an error
|
|
// displays the error message and aborts the program
|
|
// the message can contain variable text which is indicated by a special character in the message string
|
|
// $ = insert a string at this place
|
|
// @ = insert a character
|
|
// % = insert a number
|
|
// the optional data to be inserted is the second argument to this function
|
|
// this uses longjump to skip back to the command input and cleanup the stack
|
|
void MIPS16 error(char *msg, ...) {
|
|
char *p, *tp, tstr[STRINGSIZE * 2];
|
|
va_list ap;
|
|
ScrewUpTimer = 0;
|
|
// first build the error message in the global string MMErrMsg
|
|
if(MMerrno == 0) MMerrno = 16; // indicate an error
|
|
memset(tstr, 0, STRINGSIZE * 2); // clear any previous string
|
|
if(*msg) {
|
|
va_start(ap, msg);
|
|
while(*msg) {
|
|
tp = &tstr[strlen(tstr)]; // point to the end of the string
|
|
if(*msg == '$') // insert a string
|
|
strcpy(tp, va_arg(ap, char *));
|
|
else if(*msg == '@') // insert a character
|
|
*tp = (va_arg(ap, int));
|
|
else if(*msg == '%') // insert an integer
|
|
IntToStr(tp, va_arg(ap, int), 10);
|
|
else if(*msg == '~') // insert a long long integer
|
|
IntToStr(tp, va_arg(ap, int64_t), 10);
|
|
else if(*msg == '|') // insert an integer
|
|
strcpy(tp,PinDef[va_arg(ap, int)].pinname);
|
|
else
|
|
*tp = *msg;
|
|
msg++;
|
|
}
|
|
}
|
|
|
|
// copy the error message into the global MMErrMsg truncating at any tokens or if the string is too long
|
|
for(p = MMErrMsg, tp = tstr; *tp < 127 && (tp - tstr) < MAXERRMSG - 1; ) *p++ = *tp++;
|
|
*p = 0;
|
|
if(optionlogging){
|
|
lfs_file_t lfs_file;
|
|
char crlf[]="\r\n";
|
|
lfs_file_open(&lfs, &lfs_file, "log.txt", LFS_O_APPEND | LFS_O_CREAT);
|
|
lfs_file_write(&lfs, &lfs_file, MMErrMsg, sizeof(MMErrMsg));
|
|
lfs_file_write(&lfs, &lfs_file, crlf, sizeof(crlf));
|
|
lfs_file_close(&lfs, &lfs_file);
|
|
}
|
|
if(OptionErrorSkip) longjmp(ErrNext, 1); // if OPTION ERROR SKIP/IGNORE is in force
|
|
#ifdef PICOMITE
|
|
multicore_fifo_push_blocking(0xFF);
|
|
busy_wait_ms(mergetimer+200);
|
|
if(mergerunning){
|
|
_excep_code = RESET_COMMAND;
|
|
SoftReset();
|
|
}
|
|
#endif
|
|
|
|
LoadOptions(); // make sure that the option struct is in a clean state
|
|
OptionConsole=1;
|
|
if(Option.DISPLAY_CONSOLE) {
|
|
OptionConsole=3;
|
|
#ifdef PICOMITEVGA
|
|
WriteBuf=(unsigned char *)FRAMEBUFFER;
|
|
DisplayBuf=(unsigned char *)FRAMEBUFFER;
|
|
#else
|
|
restorepanel();
|
|
#endif // we now have CurrentLinePtr pointing to the start of the line
|
|
SetFont(PromptFont);
|
|
gui_fcolour = PromptFC;
|
|
gui_bcolour = PromptBC;
|
|
if((DISPLAY_TYPE==SCREENMODE2 || DISPLAY_TYPE==SCREENMODE4 || DISPLAY_TYPE==SCREENMODE5) && gui_font_width>6){
|
|
SetFont((6<<4) | 1) ;
|
|
PromptFont=(6<<4) | 1;
|
|
} else {
|
|
#ifdef HDMI
|
|
if(((FullColour) || DISPLAY_TYPE==SCREENMODE3) && gui_font_width>8){
|
|
SetFont(1) ;
|
|
PromptFont = 1;
|
|
} else if(gui_font_width>16){
|
|
SetFont((2<<4) | 1) ;
|
|
PromptFont=(2<<4) | 1;
|
|
}
|
|
#else
|
|
if(gui_font_width>8){
|
|
SetFont(1) ;
|
|
PromptFont = 1;
|
|
}
|
|
#endif
|
|
}
|
|
if(CurrentX != 0) MMPrintString("\r\n"); // error message should be on a new line
|
|
}
|
|
if(MMCharPos > 1) MMPrintString("\r\n");
|
|
int line_num = -2;
|
|
if(CurrentLinePtr) {
|
|
tp = p = (char *)ProgMemory;
|
|
if (Option.LIBRARY_FLASH_SIZE==MAX_PROG_SIZE && CurrentLinePtr < LibMemory+MAX_PROG_SIZE)
|
|
tp = p = (char *)LibMemory;
|
|
//if(*CurrentLinePtr != T_NEWLINE && CurrentLinePtr < ProgMemory + MAX_PROG_SIZE) {
|
|
if(*CurrentLinePtr != T_NEWLINE && ((CurrentLinePtr < ProgMemory + MAX_PROG_SIZE) || (Option.LIBRARY_FLASH_SIZE==MAX_PROG_SIZE && CurrentLinePtr < LibMemory+MAX_PROG_SIZE))) {
|
|
// normally CurrentLinePtr points to a T_NEWLINE token but in this case it does not
|
|
// so we have to search for the start of the line and set CurrentLinePtr to that
|
|
while(*p != 0xff) {
|
|
while(*p) p++; // look for the zero marking the start of an element
|
|
if(p >= (char *)CurrentLinePtr || p[1] == 0) { // the previous line was the one that we wanted
|
|
CurrentLinePtr = (unsigned char *)tp;
|
|
break;
|
|
}
|
|
if(p[1] == T_NEWLINE) {
|
|
tp = ++p; // save because it might be the line we want
|
|
}
|
|
p++; // step over the zero marking the start of the element
|
|
skipspace(p);
|
|
if(p[0] == T_LABEL) p += p[1] + 2; // skip over the label
|
|
}
|
|
}
|
|
|
|
// we now have CurrentLinePtr pointing to the start of the line
|
|
// dump(CurrentLinePtr, 80);
|
|
llist(tknbuf, CurrentLinePtr);
|
|
p = (char *) tknbuf;
|
|
skipspace(p);
|
|
if(CurrentLinePtr >= ProgMemory && CurrentLinePtr < ProgMemory + MAX_PROG_SIZE){
|
|
line_num = CountLines(CurrentLinePtr);
|
|
StartEditPoint = CurrentLinePtr;
|
|
StartEditChar = 0;
|
|
} else {
|
|
line_num = -1;
|
|
}
|
|
}
|
|
|
|
// Print the line.
|
|
if (line_num != -2) {
|
|
if (line_num == -1) {
|
|
sprintf(tstr, "[LIBRARY] %s\r\n", p);
|
|
} else {
|
|
sprintf(tstr, "[%d] %s\r\n", line_num, p);
|
|
}
|
|
MMPrintString(tstr);
|
|
}
|
|
|
|
// Print the error message.
|
|
if (*MMErrMsg) {
|
|
sprintf(tstr, "Error : %s\r\n", MMErrMsg);
|
|
} else {
|
|
sprintf(tstr, "Error");
|
|
}
|
|
MMPrintString(tstr);
|
|
#ifndef PICOMITEVGA
|
|
if (!Option.DISPLAY_CONSOLE && Option.DISPLAY_TYPE>I2C_PANEL) {
|
|
int width=Option.Width;
|
|
int height=Option.Height;
|
|
LCD_error(line_num, p, MMErrMsg);
|
|
Option.Width=width;
|
|
Option.Height=height;
|
|
}
|
|
|
|
#endif
|
|
cmdline=NULL;
|
|
do_end(false);
|
|
longjmp(mark, 1); // jump back to the input prompt
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************************************
|
|
Routines to convert floats and integers to formatted strings
|
|
These replace the sprintf() libraries with much less flash usage
|
|
**********************************************************************************************/
|
|
|
|
#define IntToStrBufSize 65
|
|
|
|
// convert a integer to a string.
|
|
// sstr is a buffer where the chars are to be written to
|
|
// sum is the number to be converted
|
|
// base is the numbers base radix (10 = decimal, 16 = hex, etc)
|
|
// if base 10 the number will be signed otherwise it will be unsigned
|
|
void MIPS16 IntToStr(char *strr, long long int nbr, unsigned int base) {
|
|
int i, negative;
|
|
unsigned char digit;
|
|
unsigned long long int sum;
|
|
extern long long int llabs (long long int n);
|
|
|
|
unsigned char str[IntToStrBufSize];
|
|
|
|
if(nbr < 0 && base == 10) { // we can have negative numbers in base 10 only
|
|
nbr = llabs(nbr);
|
|
negative = true;
|
|
} else
|
|
negative = false;
|
|
|
|
// this generates the digits in reverse order
|
|
sum = (unsigned long long int) nbr;
|
|
i = 0;
|
|
do {
|
|
digit = sum % base;
|
|
if (digit < 0xA)
|
|
str[i++] = '0' + digit;
|
|
else
|
|
str[i++] = 'A' + digit - 0xA;
|
|
sum /= base;
|
|
} while (sum && i < IntToStrBufSize);
|
|
|
|
if(negative) *strr++ = '-';
|
|
|
|
// we now need to reverse the digits into their correct order
|
|
for(i--; i >= 0; i--) *strr++ = str[i];
|
|
*strr = 0;
|
|
}
|
|
|
|
|
|
// convert an integer to a string padded with a leading character
|
|
// p is a pointer to the destination
|
|
// nbr is the number to convert (can be signed in which case the number is preceeded by '-')
|
|
// padch is the leading padding char (usually a space)
|
|
// maxch is the desired width of the resultant string (incl padding chars)
|
|
// radix is the base of the number. Base 10 is signed, all others are unsigned
|
|
// Special case (used by FloatToStr() only):
|
|
// if padch is negative and nbr is zero prefix the number with the - sign
|
|
void MIPS16 IntToStrPad(char *p, long long int nbr, signed char padch, int maxch, int radix) {
|
|
int j;
|
|
char sign, buf[IntToStrBufSize];
|
|
|
|
sign = 0;
|
|
if ((nbr < 0 && radix == 10 && nbr!=0x8000000000000000) || padch < 0) { // if the number is negative or we are forced to use a - symbol
|
|
sign = '-'; // set the sign
|
|
nbr *= -1; // convert to a positive nbr
|
|
padch = abs(padch);
|
|
} else {
|
|
if(nbr >= 0 && maxch < 0 && radix == 10) // should we display the + sign?
|
|
sign = '+';
|
|
}
|
|
|
|
IntToStr(buf, nbr, radix);
|
|
j = abs(maxch) - strlen(buf); // calc padding required
|
|
if(j <= 0)j = 0;
|
|
else memset(p, padch, abs(maxch)); // fill the buffer with the padding char
|
|
if(sign != 0) { // if we need a sign
|
|
if(j == 0) j = 1; // make space if necessary
|
|
if(padch == '0')
|
|
p[0] = sign; // for 0 padding the sign is before the padding
|
|
else
|
|
p[j - 1] = sign; // for anything else the padding is before the sign
|
|
}
|
|
strcpy(&p[j], buf) ;
|
|
}
|
|
|
|
|
|
// convert a float to a string including scientific notation if necessary
|
|
// p is the buffer to store the string
|
|
// f is the number
|
|
// m is the nbr of chars before the decimal point (if negative print the + sign)
|
|
// n is the nbr chars after the point
|
|
// if n == STR_AUTO_PRECISION we should automatically determine the precision
|
|
// if n is negative always use exponential format
|
|
// ch is the leading pad char
|
|
void MIPS16 FloatToStr(char *p, MMFLOAT f, int m, int n, unsigned char ch) {
|
|
int exp, trim = false, digit;
|
|
MMFLOAT rounding;
|
|
char *pp;
|
|
if(f==INFINITY){
|
|
strcpy(p,"INF");
|
|
return;
|
|
}
|
|
ch &= 0x7f; // make sure that ch is an ASCII char
|
|
if(f == 0)
|
|
exp = 0;
|
|
else
|
|
exp = floor(log10(fabs(f))); // get the exponent part
|
|
if(((fabs(f) < 0.0001 || fabs(f) >= 1000000) && f != 0 && (n == STR_AUTO_PRECISION || n==STR_FLOAT_PRECISION)) || n < 0) {
|
|
// we must use scientific notation
|
|
f /= pow(10, exp); // scale the number to 1.2345
|
|
if(f >= 10) { f /= 10; exp++; }
|
|
if(n < 0) n = -n; // negative indicates always use exponantial format
|
|
FloatToStr(p, f, m, n, ch); // recursively call ourself to convert that to a string
|
|
p = p + strlen(p);
|
|
*p++ = 'e'; // add the exponent
|
|
if(exp >= 0) {
|
|
*p++ = '+';
|
|
IntToStrPad(p, exp, '0', 2, 10); // add a positive exponent
|
|
} else {
|
|
*p++ = '-';
|
|
IntToStrPad(p, exp * -1, '0', 2, 10); // add a negative exponent
|
|
}
|
|
} else {
|
|
// we can treat it as a normal number
|
|
|
|
// first figure out how many decimal places we want.
|
|
// n == STR_AUTO_PRECISION means that we should automatically determine the precision
|
|
if(n == STR_AUTO_PRECISION) {
|
|
trim = true;
|
|
n = STR_SIG_DIGITS - exp;
|
|
if(n < 0) n = 0;
|
|
}
|
|
if(n == STR_FLOAT_PRECISION) {
|
|
trim = true;
|
|
n = STR_FLOAT_DIGITS - exp;
|
|
if(n < 0) n = 0;
|
|
}
|
|
|
|
|
|
// calculate rounding to hide the vagaries of floating point
|
|
if(n > 0)
|
|
rounding = 0.5/pow(10, n);
|
|
else
|
|
rounding = 0.5;
|
|
if(f > 0) f += rounding; // add rounding for positive numbers
|
|
if(f < 0) f -= rounding; // add rounding for negative numbers
|
|
|
|
// convert the digits before the decimal point
|
|
if((int)f == 0 && f < 0)
|
|
IntToStrPad(p, 0, -ch, m, 10); // convert -0 incl padding if necessary
|
|
else
|
|
IntToStrPad(p, f, ch, m, 10); // convert the integer incl padding if necessary
|
|
p += strlen(p); // point to the end of the integer
|
|
pp = p;
|
|
|
|
// convert the digits after the decimal point
|
|
if(f < 0) f = -f; // make the number positive
|
|
if(n > 0) { // if we need to have a decimal point and following digits
|
|
*pp++ = '.'; // add the decimal point
|
|
f -= floor(f); // get just the fractional part
|
|
while(n--) {
|
|
f *= 10;
|
|
digit = floor(f); // get the next digit for the string
|
|
f -= digit;
|
|
*pp++ = digit + '0';
|
|
}
|
|
|
|
// if we do not have a fixed number of decimal places step backwards removing trailing zeros and the decimal point if necessary
|
|
while(trim && pp > p) {
|
|
pp--;
|
|
if(*pp == '.') break;
|
|
if(*pp != '0') { pp++; break; }
|
|
}
|
|
}
|
|
*pp = 0;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************************************
|
|
Various routines to clear memory or the interpreter's state
|
|
**********************************************************************************************/
|
|
|
|
|
|
// clear (or delete) variables
|
|
// if level is not zero it will only delete local variables at that level or greater
|
|
// if level is zero to will delete all variables and reset global settings
|
|
void MIPS16 __not_in_flash_func(ClearVars)(int level, bool all) {
|
|
int i, newhashpointer,hashcurrent,hashnext;
|
|
|
|
// first step through the variable table and delete local variables at that level or greater
|
|
if(level){
|
|
newhashpointer=g_hashlistpointer; //save the current number of stored values
|
|
for(i=g_hashlistpointer-1;i>=0;i--){ //delete in reverse order of creation
|
|
if(g_hashlist[i].level>= level){
|
|
hashnext = hashcurrent = g_hashlist[i].hash;
|
|
hashnext++;
|
|
hashnext %= MAXVARS/2;
|
|
if(((g_vartbl[hashcurrent].type & T_STR) || g_vartbl[hashcurrent].dims[0] != 0) && !(g_vartbl[hashcurrent].type & T_PTR) && ((uint32_t)g_vartbl[hashcurrent].val.s<(uint32_t)MMHeap + heap_memory_size)&& ((uint32_t)g_vartbl[hashcurrent].val.s>(uint32_t)MMHeap)) {
|
|
FreeMemorySafe((void **)&g_vartbl[hashcurrent].val.s);
|
|
// free any memory (if allocated)
|
|
}
|
|
// MMPrintString("Deleting ");MMPrintString(g_vartbl[g_hashlist[i].hash].name);PIntComma(g_hashlist[i].level);PIntComma(g_hashlist[i].hash);PRet();
|
|
g_hashlist[i].level=-1;
|
|
newhashpointer=i; //set the new highest index
|
|
memset(&g_vartbl[hashcurrent],0,sizeof(struct s_vartbl));
|
|
if(g_vartbl[hashnext].type){
|
|
g_vartbl[hashcurrent].type = T_BLOCKED ; // block slot
|
|
g_vartbl[hashcurrent].name[0] = '~'; // safety precaution
|
|
}
|
|
g_Localvarcnt--;
|
|
}
|
|
}
|
|
g_hashlistpointer=newhashpointer;
|
|
} else {
|
|
for(i = 0; i < MAXVARS; i++) {
|
|
if(((g_vartbl[i].type & T_STR) || g_vartbl[i].dims[0] != 0) && !(g_vartbl[i].type & T_PTR)) {
|
|
if((uint32_t)g_vartbl[i].val.s>(uint32_t)MMHeap && (uint32_t)g_vartbl[i].val.s<(uint32_t)MMHeap + heap_memory_size){
|
|
FreeMemorySafe((void **)&g_vartbl[i].val.s); // free any memory (if allocated)
|
|
}
|
|
}
|
|
#ifdef rp2350
|
|
#ifndef PICOMITEWEB
|
|
if(all){
|
|
if(((g_vartbl[i].type & T_STR) || g_vartbl[i].dims[0] != 0) && !(g_vartbl[i].type & T_PTR)) {
|
|
if((uint32_t)g_vartbl[i].val.s>(uint32_t)PSRAMbase && (uint32_t)g_vartbl[i].val.s<(uint32_t)PSRAMbase + PSRAMsize){
|
|
FreeMemorySafe((void **)&g_vartbl[i].val.s); // free any memory (if allocated)
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
memset(&g_vartbl[i],0,sizeof(struct s_vartbl));
|
|
}
|
|
}
|
|
// then step through the for...next table and remove any loops at the level or greater
|
|
for(i = 0; i < g_forindex; i++) {
|
|
if(g_forstack[i].level >= level) {
|
|
g_forindex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// also step through the do...loop table and remove any loops at the level or greater
|
|
for(i = 0; i < g_doindex; i++) {
|
|
if(g_dostack[i].level >= level) {
|
|
g_doindex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(level != 0) return;
|
|
|
|
g_forindex = g_doindex = 0;
|
|
g_LocalIndex = 0; // signal that all space is to be cleared
|
|
ClearTempMemory(); // clear temp string space
|
|
// we can now delete all variables by zeroing the counters
|
|
g_Localvarcnt = 0;
|
|
g_Globalvarcnt = 0;
|
|
g_OptionBase = 0;
|
|
g_DimUsed = false;
|
|
g_hashlistpointer=0;
|
|
}
|
|
|
|
|
|
// clear all stack pointers (eg, FOR/NEXT stack, DO/LOOP stack, GOSUB stack, etc)
|
|
// this is done at the command prompt or at any break
|
|
void MIPS16 ClearStack(void) {
|
|
NextData = 0;
|
|
NextDataLine = ProgMemory;
|
|
g_forindex = 0;
|
|
g_doindex = 0;
|
|
gosubindex = 0;
|
|
g_LocalIndex = 0;
|
|
g_TempMemoryIsChanged = true; // signal that temporary memory should be checked
|
|
InterruptReturn = NULL;
|
|
}
|
|
|
|
|
|
// clear the runtime (eg, variables, external I/O, etc) includes ClearStack() and ClearVars()
|
|
// this is done before running a program
|
|
void MIPS16 ClearRuntime(bool all) {
|
|
int i;
|
|
#ifdef PICOMITEWEB
|
|
if(TCPstate){
|
|
TCP_SERVER_T *state = (TCP_SERVER_T*)TCPstate;
|
|
for(int i=0 ; i<MaxPcb ; i++){
|
|
if(state->client_pcb[i] && state->telnet_pcb_no!=i)tcp_server_close(state, i);
|
|
if(state->buffer_recv[i])FreeMemorySafe((void **)&state->buffer_recv[i]);
|
|
state->inttrig[i]=0;
|
|
state->sent_len[i]=0;
|
|
state->recv_len[i]=0;
|
|
state->to_send[i]=0;
|
|
}
|
|
}
|
|
optionsuppressstatus=0;
|
|
#endif
|
|
CloseAllFiles();
|
|
ClearExternalIO(); // this MUST come before InitHeap(true)
|
|
ClearStack();
|
|
#ifdef USBKEYBOARD
|
|
clearrepeat();
|
|
#endif
|
|
OptionExplicit = false;
|
|
OptionEscape = false;
|
|
OptionConsole=3;
|
|
DefaultType = T_NBR;
|
|
ds18b20Timers = NULL; // InitHeap(true) will recover the memory allocated to this array
|
|
findlabel(NULL); // clear the label cache
|
|
OptionErrorSkip = 0;
|
|
optionangle=1.0;
|
|
useoptionangle=false;
|
|
optionfulltime=false;
|
|
optionfastaudio=0;
|
|
optionlogging=false;
|
|
/*frame
|
|
frame=NULL;
|
|
outframe=NULL;
|
|
*/
|
|
#ifndef PICOMITEVGA
|
|
if(ScrollLCD==ScrollLCDSPISCR){
|
|
ScrollStart=0;
|
|
spi_write_command(CMD_SET_SCROLL_START);
|
|
spi_write_data(0);
|
|
spi_write_data(0);
|
|
}
|
|
if(ScrollLCD==ScrollLCDSPISCR){
|
|
ScrollStart=0;
|
|
WriteComand(CMD_SET_SCROLL_START);
|
|
WriteData(0);
|
|
WriteData(0);
|
|
}
|
|
if(SSD16TYPE || Option.DISPLAY_TYPE==IPS_4_16 || SPI480)clear320();
|
|
#endif
|
|
MMerrno = 0; // clear the error flags
|
|
*MMErrMsg = 0;
|
|
InitHeap(true);
|
|
m_alloc(all? M_VAR : M_LIMITED);
|
|
ClearVars(0,true);
|
|
memset(cmdlinebuff,0,sizeof(cmdlinebuff));
|
|
memset(datastore, 0, sizeof(struct sa_data) * MAXRESTORE);
|
|
restorepointer = 0;
|
|
g_flag=0;
|
|
g_varcnt = 0;
|
|
CurrentLinePtr = ContinuePoint = NULL;
|
|
for(i = 0; i < MAXSUBFUN; i++) subfun[i] = NULL;
|
|
#ifdef GUICONTROLS
|
|
for(i = 1; i < Option.MaxCtrls; i++) {
|
|
memset(&Ctrl[i],0,sizeof(struct s_ctrl));
|
|
Ctrl[i].state = Ctrl[i].type = 0;
|
|
Ctrl[i].s = NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
// clear everything including program memory (includes ClearStack() and ClearRuntime(true))
|
|
// this is used before loading a program
|
|
void MIPS16 ClearProgram(bool psram) {
|
|
// InitHeap(true);
|
|
initFonts();
|
|
m_alloc(psram ? M_PROG : M_LIMITED); // init the variables for program memory
|
|
if(Option.DISPLAY_TYPE>=VIRTUAL && WriteBuf)FreeMemorySafe((void **)&WriteBuf);
|
|
ClearRuntime(true);
|
|
// ProgMemory[0] = ProgMemory[1] = ProgMemory[3] = ProgMemory[4] = 0;
|
|
PSize = 0;
|
|
StartEditPoint = NULL;
|
|
StartEditChar= 0;
|
|
ProgramChanged = false;
|
|
TraceOn = false;
|
|
}
|
|
|
|
|
|
|
|
|
|
// round a float to an integer
|
|
#ifdef rp2350
|
|
int __not_in_flash_func(FloatToInt32)(MMFLOAT x) {
|
|
#else
|
|
#ifdef PICOMITEVGA
|
|
int FloatToInt32(MMFLOAT x) {
|
|
#else
|
|
int __not_in_flash_func(FloatToInt32)(MMFLOAT x) {
|
|
#endif
|
|
#endif
|
|
if(x < LONG_MIN - 0.5 || x > LONG_MAX + 0.5)
|
|
error("Number too large");
|
|
return (x >= 0 ? (int)(x + 0.5) : (int)(x - 0.5)) ;
|
|
}
|
|
|
|
|
|
#ifdef rp2350
|
|
long long int __not_in_flash_func(FloatToInt64)(MMFLOAT x) {
|
|
#else
|
|
#ifdef PICOMITEVGA
|
|
long long int FloatToInt64(MMFLOAT x) {
|
|
#else
|
|
long long int __not_in_flash_func(FloatToInt64)(MMFLOAT x) {
|
|
#endif
|
|
#endif
|
|
if(x < (-(0x7fffffffffffffffLL) -1) - 0.5 || x > 0x7fffffffffffffffLL + 0.5)
|
|
error("Number too large");
|
|
if ((x < -0xfffffffffffff) || (x > 0xfffffffffffff))
|
|
return (long long int)(x);
|
|
else
|
|
return (x >= 0 ? (long long int )(x + 0.5) : (long long int )(x - 0.5)) ;
|
|
}
|
|
|
|
|
|
|
|
// make a string uppercase
|
|
void __not_in_flash_func(makeupper)(unsigned char *p) {
|
|
while(*p) {
|
|
*p = mytoupper(*p);
|
|
p++;
|
|
}
|
|
}
|
|
|
|
|
|
// find the value of a command token given its name
|
|
int GetCommandValue( unsigned char *n) {
|
|
int i;
|
|
for(i = 0; i < CommandTableSize - 1; i++)
|
|
if(str_equal(n, commandtbl[i].name))
|
|
return i;
|
|
error("Invalid statement in Type definition");
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// find the value of a token given its name
|
|
int GetTokenValue (unsigned char *n) {
|
|
int i;
|
|
for(i = 0; i < TokenTableSize - 1; i++)
|
|
if(str_equal(n, tokentbl[i].name))
|
|
return i + C_BASETOKEN;
|
|
error("Internal fault 4(sorry)");
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// skip to the end of a variable
|
|
unsigned char MIPS16 __not_in_flash_func(*skipvar)(unsigned char *p, int noerror) {
|
|
unsigned char *pp, *tp;
|
|
int i;
|
|
int inquote = false;
|
|
|
|
tp = p;
|
|
// check the first char for a legal variable name
|
|
skipspace(p);
|
|
if(!isnamestart(*p)) return tp;
|
|
|
|
do {
|
|
p++;
|
|
} while(isnamechar(*p));
|
|
|
|
// check the terminating char.
|
|
if(*p == '$' || *p == '%' || *p == '!') p++;
|
|
|
|
if(p - tp > MAXVARLEN) {
|
|
if(noerror) return p;
|
|
error("Variable name too long");
|
|
}
|
|
|
|
pp = p; skipspace(pp); if(*pp == (unsigned char)'(') p = pp;
|
|
if(*p == '(') {
|
|
// this is an array
|
|
|
|
p++;
|
|
if(p - tp > MAXVARLEN) {
|
|
if(noerror) return p;
|
|
error("Variable name too long");
|
|
}
|
|
|
|
// step over the parameters keeping track of nested brackets
|
|
i = 1;
|
|
while(1) {
|
|
if(*p == '\"') inquote = !inquote;
|
|
if(*p == 0) {
|
|
if(noerror) return p;
|
|
error("Expected closing bracket");
|
|
}
|
|
if(!inquote) {
|
|
if(*p == ')') if(--i == 0) break;
|
|
if(*p == '(' || (tokentype(*p) & T_FUN)) i++;
|
|
}
|
|
p++;
|
|
}
|
|
p++; // step over the closing bracket
|
|
}
|
|
return p;
|
|
}
|
|
|
|
|
|
|
|
// skip to the end of an expression (terminates on null, comma, comment or unpaired ')'
|
|
unsigned char __not_in_flash_func(*skipexpression)(unsigned char *p) {
|
|
int i, inquote;
|
|
|
|
for(i = inquote = 0; *p; p++) {
|
|
if(*p == '\"') inquote = !inquote;
|
|
if(!inquote) {
|
|
if(*p == ')') i--;
|
|
if(*p == '(' || (tokentype(*p) & T_FUN)) i++;
|
|
}
|
|
if(i < 0 || (i == 0 && (*p == ',' || *p == '\''))) break;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
|
|
// find the next command in the program
|
|
// this contains the logic for stepping over a line number and label (if present)
|
|
// p is the current place in the program to start the search from
|
|
// CLine is a pointer to a char pointer which in turn points to the start of the current line for error reporting (if NULL it will be ignored)
|
|
// EOFMsg is the error message to use if the end of the program is reached
|
|
// returns a pointer to the next command
|
|
unsigned char __not_in_flash_func(*GetNextCommand)(unsigned char *p, unsigned char **CLine, unsigned char *EOFMsg) {
|
|
do {
|
|
if(*p != T_NEWLINE) { // if we are not already at the start of a line
|
|
while(*p) p++; // look for the zero marking the start of an element
|
|
p++; // step over the zero
|
|
}
|
|
if(*p == 0) {
|
|
if(EOFMsg == NULL) return p;
|
|
error((char *)EOFMsg);
|
|
}
|
|
if(*p == T_NEWLINE) {
|
|
if(CLine) *CLine = p; // and a pointer to the line also for error reporting
|
|
p++;
|
|
}
|
|
if(*p == T_LINENBR) p += 3;
|
|
|
|
skipspace(p);
|
|
if(p[0] == T_LABEL) { // got a label
|
|
p += p[1] + 2; // skip over the label
|
|
skipspace(p); // and any following spaces
|
|
}
|
|
} while(*p < C_BASETOKEN);
|
|
return p;
|
|
}
|
|
|
|
|
|
// scans text looking for the matching closing bracket
|
|
// it will handle nested strings, brackets and functions
|
|
// it expects to be called pointing at the opening bracket or a function token
|
|
unsigned char __not_in_flash_func(*getclosebracket)(unsigned char *p) {
|
|
int i = 0;
|
|
int inquote = false;
|
|
|
|
do {
|
|
if(*p == 0) error("Expected closing bracket");
|
|
if(*p == '\"') inquote = !inquote;
|
|
if(!inquote) {
|
|
if(*p == ')') i--;
|
|
if(*p == '(' || (tokentype(*p) & T_FUN)) i++;
|
|
}
|
|
p++;
|
|
} while(i);
|
|
return p - 1;
|
|
}
|
|
|
|
|
|
// check that there is no excess text following an element
|
|
// will skip spaces and abort if a zero char is not found
|
|
void __not_in_flash_func(checkend)(unsigned char *p) {
|
|
skipspace(p);
|
|
if(*p == '\'') return;
|
|
if(*p)
|
|
error("Unexpected text: $", p);
|
|
}
|
|
|
|
|
|
// check if the next text in an element (a basic statement) corresponds to an alpha string
|
|
// leading whitespace is skipped and the string must be terminated with a valid terminating
|
|
// character. Returns a pointer to the end of the string if found or NULL is not
|
|
unsigned char __not_in_flash_func(*checkstring)(unsigned char *p, unsigned char *tkn) {
|
|
skipspace(p); // skip leading spaces
|
|
while(*tkn && (mytoupper(*tkn) == mytoupper(*p))) { tkn++; p++; } // compare the strings
|
|
// if(*tkn == 0 && (*p == (unsigned char)' ' || *p == (unsigned char)',' || *p == (unsigned char)'\'' || *p == 0 || *p == (unsigned char)'(' || *p == (unsigned char)'=')) {
|
|
if(*tkn == 0 && !isnamechar(*p)){
|
|
skipspace(p);
|
|
return p; // if successful return a pointer to the next non space character after the matched string
|
|
}
|
|
return NULL; // or NULL if not
|
|
}
|
|
|
|
/********************************************************************************************************************************************
|
|
A couple of I/O routines that do not belong anywhere else
|
|
*********************************************************************************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
/********************************************************************************************************************************************
|
|
string routines
|
|
these routines form a library of functions for manipulating MMBasic strings. These strings differ from ordinary C strings in that the length
|
|
of the string is stored in the first byte and the string is NOT terminated with a zero valued byte. This type of string can store the full
|
|
range of binary values (0x00 to 0xff) in each character.
|
|
*********************************************************************************************************************************************/
|
|
|
|
// convert a MMBasic string to a C style string
|
|
// if the MMstr contains a null byte that byte is skipped and not copied
|
|
unsigned char __not_in_flash_func(*MtoC)(unsigned char *p) {
|
|
int i;
|
|
unsigned char *p1, *p2;
|
|
i = *p;
|
|
p1 = p + 1; p2 = p;
|
|
while(i) {
|
|
if(p1) *p2++ = *p1;
|
|
p1++;
|
|
i--;
|
|
}
|
|
*p2 = 0;
|
|
return p;
|
|
}
|
|
|
|
|
|
// convert a c style string to a MMBasic string
|
|
unsigned char __not_in_flash_func(*CtoM)(unsigned char *p) {
|
|
int len, i;
|
|
unsigned char *p1, *p2;
|
|
len = i = strlen((char *)p);
|
|
if(len > MAXSTRLEN) error("String too long");
|
|
p1 = p + len; p2 = p + len - 1;
|
|
while(i--) *p1-- = *p2--;
|
|
*p = len;
|
|
return p;
|
|
}
|
|
|
|
|
|
// copy a MMBasic string to a new location
|
|
#ifdef rp2350
|
|
void __not_in_flash_func(Mstrcpy)(unsigned char *dest, unsigned char *src) {
|
|
#else
|
|
#ifdef PICOMITEVGA
|
|
void Mstrcpy(unsigned char *dest, unsigned char *src) {
|
|
#else
|
|
void __not_in_flash_func(Mstrcpy)(unsigned char *dest, unsigned char *src) {
|
|
#endif
|
|
#endif
|
|
int i;
|
|
i = *src + 1;
|
|
while(i--) *dest++ = *src++;
|
|
}
|
|
|
|
|
|
|
|
// concatenate two MMBasic strings
|
|
void Mstrcat(unsigned char *dest, unsigned char *src) {
|
|
int i;
|
|
i = *src;
|
|
*dest += i;
|
|
dest += *dest + 1 - i; src++;
|
|
while(i--) *dest++ = *src++;
|
|
}
|
|
|
|
|
|
|
|
// compare two MMBasic style strings
|
|
// returns 1 if s1 > s2 or 0 if s1 = s2 or -1 if s1 < s2
|
|
int Mstrcmp(unsigned char *s1, unsigned char *s2) {
|
|
register int i;
|
|
register unsigned char *p1, *p2;
|
|
|
|
// get the smaller length
|
|
i = *s1 < *s2 ? *s1 : *s2;
|
|
|
|
// skip the length byte and point to the unsigned char array
|
|
p1 = s1 + 1; p2 = s2 + 1;
|
|
|
|
// compare each char
|
|
while(i--) {
|
|
if(*p1 > *p2) return 1;
|
|
if(*p1 < *p2) return -1;
|
|
p1++; p2++;
|
|
}
|
|
// up to this point the strings matched - make the decision based on which one is shorter
|
|
if(*s1 > *s2) return 1;
|
|
if(*s1 < *s2) return -1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// these library functions went missing in the PIC32 C compiler ver 1.12 and later
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
* mystrncasecmp.c --
|
|
*
|
|
* Source code for the "mystrncasecmp" library routine.
|
|
*
|
|
* Copyright (c) 1988-1993 The Regents of the University of California.
|
|
* Copyright (c) 1995-1996 Sun Microsystems, Inc.
|
|
*
|
|
* See the file "license.terms" for information on usage and redistribution of
|
|
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
|
*
|
|
* RCS: @(#) $Id: mystrncasecmp.c,v 1.3 2007/04/16 13:36:34 dkf Exp $
|
|
*/
|
|
|
|
/*
|
|
* This array is designed for mapping upper and lower case letter together for
|
|
* a case independent comparison. The mappings are based upon ASCII character
|
|
* sequences.
|
|
*/
|
|
|
|
static unsigned char charmap[] = {
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
|
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
|
|
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
|
|
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
|
|
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
|
|
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
|
|
0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
|
|
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
|
|
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
|
|
0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
|
|
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
|
|
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
|
|
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
|
|
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
|
|
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
|
|
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xe1, 0xe2, 0xe3, 0xe4, 0xc5, 0xe6, 0xe7,
|
|
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
|
|
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
|
|
0xf8, 0xf9, 0xfa, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
|
|
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
|
|
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
|
|
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
|
};
|
|
|
|
|
|
/*
|
|
*----------------------------------------------------------------------
|
|
*
|
|
* mystrncasecmp --
|
|
*
|
|
* Compares two strings, ignoring case differences.
|
|
*
|
|
* Results:
|
|
* Compares up to length chars of s1 and s2, returning -1, 0, or 1 if s1
|
|
* is lexicographically less than, equal to, or greater than s2 over
|
|
* those characters.
|
|
*
|
|
* Side effects:
|
|
* None.
|
|
*
|
|
*----------------------------------------------------------------------
|
|
*/
|
|
|
|
|
|
int mystrncasecmp(
|
|
const unsigned char *s1, /* First string. */
|
|
const unsigned char *s2, /* Second string. */
|
|
size_t length) /* Maximum number of characters to compare
|
|
* (stop earlier if the end of either string
|
|
* is reached). */
|
|
{
|
|
register unsigned char u1, u2;
|
|
|
|
for (; length != 0; length--, s1++, s2++) {
|
|
u1 = (unsigned char) *s1;
|
|
u2 = (unsigned char) *s2;
|
|
if (charmap[u1] != charmap[u2]) {
|
|
return charmap[u1] - charmap[u2];
|
|
}
|
|
if (u1 == '\0') {
|
|
return 0;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// Compare two strings, ignoring case differences.
|
|
// Returns true if the strings are equal (ignoring case) otherwise returns false.
|
|
#if defined(__PIC32MX__)
|
|
inline
|
|
#endif
|
|
int __not_in_flash_func(str_equal)(const unsigned char *s1, const unsigned char *s2) {
|
|
if(charmap[*(unsigned char *)s1] != charmap[*(unsigned char *)s2]) return 0;
|
|
for ( ; ; ) {
|
|
if(*s2 == '\0') return 1;
|
|
s1++; s2++;
|
|
if(charmap[*(unsigned char *)s1] != charmap[*(unsigned char *)s2]) return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Compare two areas of memory, ignoring case differences.
|
|
// Returns true if they are equal (ignoring case) otherwise returns false.
|
|
int __not_in_flash_func(mem_equal)(unsigned char *s1, unsigned char *s2, int i) {
|
|
if(charmap[*(unsigned char *)s1] != charmap[*(unsigned char *)s2]) return 0;
|
|
while (--i) {
|
|
if(charmap[*(unsigned char *)++s1] != charmap[*(unsigned char *)++s2])
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
/* @endcond */
|