sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

BAS: Another file closer to the coding standard

Browse Source
This commit is contained in:
Gregory Nutt 2014-11-02 08:49:20 -06:00
parent 011dde0387
commit 2a0ed1c17b
3 changed files with 308 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

459
interpreters/bas/auto.c
View File

@ -1,5 +1,66 @@
/* Local variables and the run time stack. */
/* #includes */ /*{{{C}}}*//*{{{*/
/****************************************************************************
* apps/examples/interpreters/bas/auto.c
* BASIC file system interface.
*
* Copyright (c) 1999-2014 Michael Haardt
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Adapted to NuttX and re-released under a 3-clause BSD license:
*
* Copyright (C) 2014 Gregory Nutt. All rights reserved.
* Authors: Alan Carvalho de Assis <Alan Carvalho de Assis>
* Gregory Nutt <gnutt@nuttx.org>
*
* 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. Neither the name NuttX 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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "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 THE
* COPYRIGHT OWNER OR CONTRIBUTORS 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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
@ -10,10 +71,10 @@
#include <assert.h>
#include <ctype.h>
#ifdef HAVE_GETTEXT
#include <libintl.h>
#define _(String) gettext(String)
# include <libintl.h>
# define _(String) gettext(String)
#else
#define _(String) String
# define _(String) String
#endif
#include <stdlib.h>
#include <string.h>
@ -21,220 +82,308 @@
#include "auto.h"
#ifdef USE_DMALLOC
#include "dmalloc.h"
# include "dmalloc.h"
#endif
/*}}}*/
/* #defines */ /*{{{*/
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define INCREASE_STACK 16
/*}}}*/
/****************************************************************************
* Public Functions
****************************************************************************/
/* interpretation methods */
struct Auto *Auto_new(struct Auto *this) /*{{{*/
struct Auto *Auto_new(struct Auto *this)
{
this->stackPointer=0;
this->stackCapacity=0;
this->framePointer=0;
this->frameSize=0;
this->onerror.line=-1;
this->erl=0;
this->stackPointer = 0;
this->stackCapacity = 0;
this->framePointer = 0;
this->frameSize = 0;
this->onerror.line = -1;
this->erl = 0;
Value_new_NIL(&this->err);
Value_new_NIL(&this->lastdet);
this->begindata.line=-1;
this->slot=(union AutoSlot*)0;
this->cur=this->all=(struct Symbol*)0;
this->begindata.line = -1;
this->slot = (union AutoSlot *)0;
this->cur = this->all = (struct Symbol *)0;
return this;
}
/*}}}*/
void Auto_destroy(struct Auto *this) /*{{{*/
void Auto_destroy(struct Auto *this)
{
struct Symbol *l;
Value_destroy(&this->err);
Value_destroy(&this->lastdet);
if (this->stackCapacity) free(this->slot);
for (l=this->all; l!=(struct Symbol*)0; )
{
struct Symbol *f;
if (this->stackCapacity)
{
free(this->slot);
}
f=l;
l=l->next;
free(f->name);
free(f);
}
for (l = this->all; l != (struct Symbol *)0;)
{
struct Symbol *f;
f = l;
l = l->next;
free(f->name);
free(f);
}
}
/*}}}*/
struct Var *Auto_pushArg(struct Auto *this) /*{{{*/
struct Var *Auto_pushArg(struct Auto *this)
{
if ((this->stackPointer+1)>=this->stackCapacity)
{
this->slot=realloc(this->slot,sizeof(this->slot[0])*(this->stackCapacity?(this->stackCapacity=this->stackPointer+INCREASE_STACK):(this->stackCapacity=INCREASE_STACK)));
}
if ((this->stackPointer + 1) >= this->stackCapacity)
{
this->slot =
realloc(this->slot,
sizeof(this->slot[0]) *
(this->
stackCapacity ? (this->stackCapacity =
this->stackPointer +
INCREASE_STACK) : (this->stackCapacity =
INCREASE_STACK)));
}
return &this->slot[this->stackPointer++].var;
}
/*}}}*/
void Auto_pushFuncRet(struct Auto *this, int firstarg, struct Pc *pc) /*{{{*/
{
if (this->stackPointer+2>=this->stackCapacity)
{
this->slot=realloc(this->slot,sizeof(this->slot[0])*(this->stackCapacity?(this->stackCapacity=this->stackCapacity+INCREASE_STACK):(this->stackCapacity=INCREASE_STACK)));
}
this->slot[this->stackPointer].retException.onerror=this->onerror;
this->slot[this->stackPointer].retException.resumeable=this->resumeable;
++this->stackPointer;
this->slot[this->stackPointer].retFrame.pc=*pc;
this->slot[this->stackPointer].retFrame.framePointer=this->framePointer;
this->slot[this->stackPointer].retFrame.frameSize=this->frameSize;
++this->stackPointer;
this->framePointer=firstarg;
this->frameSize=this->stackPointer-firstarg;
this->onerror.line=-1;
}
/*}}}*/
void Auto_pushGosubRet(struct Auto *this, struct Pc *pc) /*{{{*/
{
if ((this->stackPointer+1)>=this->stackCapacity)
{
this->slot=realloc(this->slot,sizeof(this->slot[0])*(this->stackCapacity?(this->stackCapacity=this->stackPointer+INCREASE_STACK):(this->stackCapacity=INCREASE_STACK)));
}
this->slot[this->stackPointer].retFrame.pc=*pc;
++this->stackPointer;
}
/*}}}*/
struct Var *Auto_local(struct Auto *this, int l) /*{{{*/
{
assert(this->frameSize>(l+2));
return &(this->slot[this->framePointer+l].var);
}
/*}}}*/
int Auto_funcReturn(struct Auto *this, struct Pc *pc) /*{{{*/
{
int i,retFrame,retException;
if (this->stackPointer==0) return 0;
void Auto_pushFuncRet(struct Auto *this, int firstarg, struct Pc *pc)
{
if (this->stackPointer + 2 >= this->stackCapacity)
{
this->slot =
realloc(this->slot,
sizeof(this->slot[0]) *
(this->
stackCapacity ? (this->stackCapacity =
this->stackCapacity +
INCREASE_STACK) : (this->stackCapacity =
INCREASE_STACK)));
}
this->slot[this->stackPointer].retException.onerror = this->onerror;
this->slot[this->stackPointer].retException.resumeable = this->resumeable;
++this->stackPointer;
this->slot[this->stackPointer].retFrame.pc = *pc;
this->slot[this->stackPointer].retFrame.framePointer = this->framePointer;
this->slot[this->stackPointer].retFrame.frameSize = this->frameSize;
++this->stackPointer;
this->framePointer = firstarg;
this->frameSize = this->stackPointer - firstarg;
this->onerror.line = -1;
}
void Auto_pushGosubRet(struct Auto *this, struct Pc *pc)
{
if ((this->stackPointer + 1) >= this->stackCapacity)
{
this->slot =
realloc(this->slot,
sizeof(this->slot[0]) *
(this->
stackCapacity ? (this->stackCapacity =
this->stackPointer +
INCREASE_STACK) : (this->stackCapacity =
INCREASE_STACK)));
}
this->slot[this->stackPointer].retFrame.pc = *pc;
++this->stackPointer;
}
struct Var *Auto_local(struct Auto *this, int l)
{
assert(this->frameSize > (l + 2));
return &(this->slot[this->framePointer + l].var);
}
int Auto_funcReturn(struct Auto *this, struct Pc *pc)
{
int i, retFrame, retException;
if (this->stackPointer == 0)
{
return 0;
}
assert(this->frameSize);
retFrame=this->framePointer+this->frameSize-1;
retException=this->framePointer+this->frameSize-2;
assert(retException>=0 && retFrame<this->stackPointer);
for (i=0; i<this->frameSize-2; ++i) Var_destroy(&this->slot[this->framePointer+i].var);
this->stackPointer=this->framePointer;
if (pc!=(struct Pc*)0) *pc=this->slot[retFrame].retFrame.pc;
this->frameSize=this->slot[retFrame].retFrame.frameSize;
this->framePointer=this->slot[retFrame].retFrame.framePointer;
this->onerror=this->slot[retException].retException.onerror;
retFrame = this->framePointer + this->frameSize - 1;
retException = this->framePointer + this->frameSize - 2;
assert(retException >= 0 && retFrame < this->stackPointer);
for (i = 0; i < this->frameSize - 2; ++i)
{
Var_destroy(&this->slot[this->framePointer + i].var);
}
this->stackPointer = this->framePointer;
if (pc != (struct Pc *)0)
{
*pc = this->slot[retFrame].retFrame.pc;
}
this->frameSize = this->slot[retFrame].retFrame.frameSize;
this->framePointer = this->slot[retFrame].retFrame.framePointer;
this->onerror = this->slot[retException].retException.onerror;
return 1;
}
/*}}}*/
int Auto_gosubReturn(struct Auto *this, struct Pc *pc) /*{{{*/
int Auto_gosubReturn(struct Auto *this, struct Pc *pc)
{
if (this->stackPointer<=this->framePointer+this->frameSize) return 0;
if (this->stackPointer <= this->framePointer + this->frameSize)
{
return 0;
}
--this->stackPointer;
if (pc) *pc=this->slot[this->stackPointer].retFrame.pc;
if (pc)
{
*pc = this->slot[this->stackPointer].retFrame.pc;
}
return 1;
}
/*}}}*/
void Auto_frameToError(struct Auto *this, struct Program *program, struct Value *v) /*{{{*/
void Auto_frameToError(struct Auto *this, struct Program *program, struct Value *v)
{
int i=this->stackPointer,framePointer,frameSize,retFrame;
int i = this->stackPointer, framePointer, frameSize, retFrame;
struct Pc p;
framePointer=this->framePointer;
frameSize=this->frameSize;
while (i>framePointer+frameSize)
{
p=this->slot[--i].retFrame.pc;
Value_errorSuffix(v,_("Called"));
Program_PCtoError(program,&p,v);
}
framePointer = this->framePointer;
frameSize = this->frameSize;
while (i > framePointer + frameSize)
{
p = this->slot[--i].retFrame.pc;
Value_errorSuffix(v, _("Called"));
Program_PCtoError(program, &p, v);
}
if (i)
{
retFrame=framePointer+frameSize-1;
i=framePointer;
p=this->slot[retFrame].retFrame.pc;
frameSize=this->slot[retFrame].retFrame.frameSize;
framePointer=this->slot[retFrame].retFrame.framePointer;
Value_errorSuffix(v,_("Proc Called"));
Program_PCtoError(program,&p,v);
}
{
retFrame = framePointer + frameSize - 1;
i = framePointer;
p = this->slot[retFrame].retFrame.pc;
frameSize = this->slot[retFrame].retFrame.frameSize;
framePointer = this->slot[retFrame].retFrame.framePointer;
Value_errorSuffix(v, _("Proc Called"));
Program_PCtoError(program, &p, v);
}
}
/*}}}*/
void Auto_setError(struct Auto *this, long int line, struct Pc *pc, struct Value *v) /*{{{*/
void Auto_setError(struct Auto *this, long int line, struct Pc *pc, struct Value *v)
{
this->erpc=*pc;
this->erl=line;
this->erpc = *pc;
this->erl = line;
Value_destroy(&this->err);
Value_clone(&this->err,v);
Value_clone(&this->err, v);
}
/*}}}*/
/* compilation methods */
int Auto_find(struct Auto *this, struct Identifier *ident) /*{{{*/
int Auto_find(struct Auto *this, struct Identifier *ident)
{
struct Symbol *find;
for (find=this->cur; find!=(struct Symbol*)0; find=find->next)
{
const char *s=ident->name;
const char *r=find->name;
while (*s && tolower(*s)==tolower(*r)) { ++s; ++r; };
if (tolower(*s)==tolower(*r))
for (find = this->cur; find != (struct Symbol *)0; find = find->next)
{
ident->sym=find;
return 1;
const char *s = ident->name;
const char *r = find->name;
while (*s && tolower(*s) == tolower(*r))
{
++s;
++r;
}
if (tolower(*s) == tolower(*r))
{
ident->sym = find;
return 1;
}
}
}
return 0;
}
/*}}}*/
int Auto_variable(struct Auto *this, const struct Identifier *ident) /*{{{*/
int Auto_variable(struct Auto *this, const struct Identifier *ident)
{
struct Symbol **tail;
int offset;
for (offset=0,tail=&this->cur; *tail!=(struct Symbol*)0; tail=&(*tail)->next,++offset)
{
const char *s=ident->name;
const char *r=(*tail)->name;
for (offset = 0, tail = &this->cur;
*tail != (struct Symbol *)0;
tail = &(*tail)->next, ++offset)
{
const char *s = ident->name;
const char *r = (*tail)->name;
while (*s && tolower(*s) == tolower(*r))
{
++s;
++r;
}
if (tolower(*s) == tolower(*r))
{
return 0;
}
}
(*tail) = malloc(sizeof(struct Symbol));
(*tail)->next = (struct Symbol *)0;
(*tail)->name = strcpy(malloc(strlen(ident->name) + 1), ident->name);
(*tail)->type = LOCALVAR;
(*tail)->u.local.type = ident->defaultType;
while (*s && tolower(*s)==tolower(*r)) { ++s; ++r; };
if (tolower(*s)==tolower(*r)) return 0;
}
(*tail)=malloc(sizeof(struct Symbol));
(*tail)->next=(struct Symbol*)0;
(*tail)->name=strcpy(malloc(strlen(ident->name)+1),ident->name);
(*tail)->type=LOCALVAR;
(*tail)->u.local.type=ident->defaultType;
/* the offset -1 of the V_VOID procedure return symbol is ok, it is not used */
(*tail)->u.local.offset=offset-(this->cur->u.local.type==V_VOID?1:0);
(*tail)->u.local.offset =
offset - (this->cur->u.local.type == V_VOID ? 1 : 0);
return 1;
}
/*}}}*/
enum ValueType Auto_argType(const struct Auto *this, int l) /*{{{*/
enum ValueType Auto_argType(const struct Auto *this, int l)
{
struct Symbol *find;
int offset;
if (this->cur->u.local.type==V_VOID) ++l;
for (offset=0,find=this->cur; l!=offset; find=find->next,++offset) assert(find!=(struct Symbol*)0);
assert(find!=(struct Symbol*)0);
if (this->cur->u.local.type == V_VOID)
{
++l;
}
for (offset = 0, find = this->cur; l != offset; find = find->next, ++offset)
{
assert(find != (struct Symbol *)0);
}
assert(find != (struct Symbol *)0);
return find->u.local.type;
}
/*}}}*/
enum ValueType Auto_varType(const struct Auto *this, struct Symbol *sym) /*{{{*/
enum ValueType Auto_varType(const struct Auto *this, struct Symbol *sym)
{
struct Symbol *find;
for (find=this->cur; find->u.local.offset!=sym->u.local.offset; find=find->next) assert(find!=(struct Symbol*)0);
assert(find!=(struct Symbol*)0);
for (find = this->cur;
find->u.local.offset != sym->u.local.offset;
find = find->next)
{
assert(find != (struct Symbol *)0);
}
assert(find != (struct Symbol *)0);
return find->u.local.type;
}
/*}}}*/
void Auto_funcEnd(struct Auto *this) /*{{{*/
void Auto_funcEnd(struct Auto *this)
{
struct Symbol **tail;
for (tail=&this->all; *tail!=(struct Symbol*)0; tail=&(*tail)->next);
*tail=this->cur;
this->cur=(struct Symbol*)0;
for (tail = &this->all; *tail != (struct Symbol *)0; tail = &(*tail)->next);
*tail = this->cur;
this->cur = (struct Symbol *)0;
}
/*}}}*/

4
interpreters/bas/fs.c
View File

@ -168,7 +168,9 @@ static int size(int dev)
file = n;
for (i = capacity; i <= dev; ++i)
file[i] = (struct FileStream *)0;
{
file[i] = (struct FileStream *)0;
}
capacity = dev + 1;
}

2
interpreters/bas/token.c
View File

@ -4243,7 +4243,7 @@ static void yy_load_buffer_state (void)
* In that case, we don't want to reset the lineno or column.
*/
if (b != YY_CURRENT_BUFFER
if (b != YY_CURRENT_BUFFER)
{
b->yy_bs_lineno = 1;
b->yy_bs_column = 0;