BAS: Another file is closer to the coding style

interpreters/bas/auto.c

@@ -81,10 +81,6 @@
 
 #include "auto.h"
 
-#ifdef USE_DMALLOC
-#  include "dmalloc.h"
-#endif
-
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/

interpreters/bas/bas.c

@@ -36,10 +36,6 @@
 #include "value.h"
 #include "var.h"
 
-#ifdef USE_DMALLOC
-#  include "dmalloc.h"
-#endif
-
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/

interpreters/bas/config.h

@@ -26,9 +26,6 @@
 /* What does tputs return? */
 /* #undef TPUTS_RETURNS_VOID */
 
-/* Define as 1 if you use dmalloc. */
-/* #undef USE_DMALLOC */
-
 /* Define as 1 if you want LR0 parser. */
 /* #undef USE_LR0 */
 

interpreters/bas/fs.c

@@ -93,10 +93,6 @@
 
 #include "fs.h"
 
-#ifdef USE_DMALLOC
-#  include "dmalloc.h"
-#endif
-
 /****************************************************************************
  * Pre-processor Definitions
  ****************************************************************************/

interpreters/bas/global.c

@@ -28,10 +28,6 @@
 #include "global.h"
 #include "var.h"
 
-#ifdef USE_DMALLOC
-#include "dmalloc.h"
-#endif
-
 #include <nuttx/clock.h>
 
 #ifndef M_PI

interpreters/bas/main.c

@@ -80,10 +80,6 @@
 #include <string.h>
 #include <stdlib.h>
 
-#ifdef USE_DMALLOC
-#  include "dmalloc.h"
-#endif
-
 #include "bas.h"
 
 /****************************************************************************

interpreters/bas/statement.c

@@ -10,11 +10,6 @@
 
 #include "statement.h"
 
-#ifdef USE_DMALLOC
-#include "dmalloc.h"
-#endif
-
-
 struct Value *stmt_CALL(struct Value *value)
 {
   ++pc.token;

interpreters/bas/str.c

@@ -1,5 +1,66 @@
-/* Dyanamic strings. */
+/****************************************************************************
-/* #includes */ /*{{{C}}}*//*{{{*/
+ * apps/examples/interpreters/bas/value.c
+ * Dynamic strings.
+ *
+ *   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
+ ****************************************************************************/
+
 #include "config.h"
 
 #include <assert.h>
@@ -12,250 +73,384 @@
 
 #include "str.h"
 
-#ifdef USE_DMALLOC
+/****************************************************************************
-#include "dmalloc.h"
+ * Public Functions
-#endif
+ ****************************************************************************/
-/*}}}*/
 
-int cistrcmp(const char *s, const char *r) /*{{{*/
+int cistrcmp(const char *s, const char *r)
 {
-  assert(s!=(char*)0);
+  assert(s != (char *)0);
-  assert(r!=(char*)0);
+  assert(r != (char *)0);
-  while (*s && tolower(*s)==tolower(*r)) { ++s; ++r; };
+  while (*s && tolower(*s) == tolower(*r))
-  return ((tolower(*s)-tolower(*r)));
+    {
+      ++s;
+      ++r;
+    }
+
+  return ((tolower(*s) - tolower(*r)));
 }
-/*}}}*/
 
-struct String *String_new(struct String *this) /*{{{*/
+struct String *String_new(struct String *this)
 {
-  assert(this!=(struct String*)0);
+  assert(this != (struct String *)0);
-  this->length=0;
+  this->length = 0;
-  this->character=(char*)0;
+  this->character = (char *)0;
-  this->field=(struct StringField*)0;
+  this->field = (struct StringField *)0;
   return this;
 }
-/*}}}*/
+
-void String_destroy(struct String *this) /*{{{*/
+void String_destroy(struct String *this)
 {
-  assert(this!=(struct String*)0);
+  assert(this != (struct String *)0);
-  if (this->field) String_leaveField(this);
+  if (this->field)
-  if (this->length) free(this->character);
+    {
+      String_leaveField(this);
+    }
+
+  if (this->length)
+    {
+      free(this->character);
+    }
 }
-/*}}}*/
+
-int String_joinField(struct String *this, struct StringField *field, char *character, size_t length) /*{{{*/
+int String_joinField(struct String *this, struct StringField *field,
+                     char *character, size_t length)
 {
   struct String **n;
 
-  assert(this!=(struct String*)0);
+  assert(this != (struct String *)0);
-  if (this->field) String_leaveField(this);
+  if (this->field)
-  this->field=field;
+    {
-  if ((n=(struct String**)realloc(field->refStrings,sizeof(struct String*)*(field->refCount+1)))==(struct String**)0) return -1;
+      String_leaveField(this);
-  field->refStrings=n;
+    }
-  field->refStrings[field->refCount]=this;
+
+  this->field = field;
+  if ((n =
+       (struct String **)realloc(field->refStrings,
+                                 sizeof(struct String *) * (field->refCount +
+                                                            1))) ==
+      (struct String **)0)
+    {
+      return -1;
+    }
+
+  field->refStrings = n;
+  field->refStrings[field->refCount] = this;
   ++field->refCount;
-  if (this->length) free(this->character);
+  if (this->length)
-  this->character=character;
+    {
-  this->length=length;
+      free(this->character);
+    }
+
+  this->character = character;
+  this->length = length;
   return 0;
 }
-/*}}}*/
+
-void String_leaveField(struct String *this) /*{{{*/
+void String_leaveField(struct String *this)
 {
   struct StringField *field;
   int i;
   struct String **ref;
 
-  assert(this!=(struct String*)0);
+  assert(this != (struct String *)0);
-  field=this->field;
+  field = this->field;
-  assert(field!=(struct StringField*)0);
+  assert(field != (struct StringField *)0);
-  for (i=0,ref=field->refStrings; i<field->refCount; ++i,++ref)
+  for (i = 0, ref = field->refStrings; i < field->refCount; ++i, ++ref)
-  {
-    if (*ref==this)
     {
-      int further=--field->refCount-i;
+      if (*ref == this)
+        {
+          int further = --field->refCount - i;
 
-      if (further) memmove(ref,ref+1,further*sizeof(struct String**));
+          if (further)
-      this->character=(char*)0;
+            {
-      this->length=0;
+              memmove(ref, ref + 1, further * sizeof(struct String **));
-      this->field=(struct StringField*)0;
+            }
-      return;
+
+          this->character = (char *)0;
+          this->length = 0;
+          this->field = (struct StringField *)0;
+          return;
+        }
     }
-  }
+
   assert(0);
 }
-/*}}}*/
+
-struct String *String_clone(struct String *this, const struct String *original) /*{{{*/
+struct String *String_clone(struct String *this, const struct String *original)
 {
-  assert(this!=(struct String*)0);
+  assert(this != (struct String *)0);
   String_new(this);
-  String_appendString(this,original);
+  String_appendString(this, original);
   return this;
 }
-/*}}}*/
+
-int String_size(struct String *this, size_t length) /*{{{*/
+int String_size(struct String *this, size_t length)
 {
   char *n;
 
-  assert(this!=(struct String*)0);
+  assert(this != (struct String *)0);
-  if (this->field) String_leaveField(this);
+  if (this->field)
-  if (length)
-  {
-    if (length>this->length)
     {
-      if ((n=realloc(this->character,length+1))==(char*)0) return -1;
+      String_leaveField(this);
-      this->character=n;
+    }
+
+  if (length)
+    {
+      if (length > this->length)
+        {
+          if ((n = realloc(this->character, length + 1)) == (char *)0)
+            {
+              return -1;
+            }
+
+          this->character = n;
+        }
+
+      this->character[length] = '\0';
     }
-    this->character[length]='\0';
-  }
   else
-  {
+    {
-    if (this->length) free(this->character);
+      if (this->length)
-    this->character=(char*)0;
+        {
-  }
+          free(this->character);
-  this->length=length;
+        }
-  return 0;
-}
-/*}}}*/
-int String_appendString(struct String *this, const struct String *app) /*{{{*/
-{
-  size_t oldlength=this->length;
 
-  if (this->field) String_leaveField(this);
+      this->character = (char *)0;
-  if (app->length==0) return 0;
+    }
-  if (String_size(this,this->length+app->length)==-1) return -1;
-  memcpy(this->character+oldlength,app->character,app->length);
-  return 0;
-}
-/*}}}*/
-int String_appendChar(struct String *this, char ch) /*{{{*/
-{
-  size_t oldlength=this->length;
 
-  if (this->field) String_leaveField(this);
+  this->length = length;
-  if (String_size(this,this->length+1)==-1) return -1;
-  this->character[oldlength]=ch;
   return 0;
 }
-/*}}}*/
-int String_appendChars(struct String *this, const char *ch) /*{{{*/
-{
-  size_t oldlength=this->length;
-  size_t chlen=strlen(ch);
 
-  if (this->field) String_leaveField(this);
+int String_appendString(struct String *this, const struct String *app)
-  if (String_size(this,this->length+chlen)==-1) return -1;
+{
-  memcpy(this->character+oldlength,ch,chlen);
+  size_t oldlength = this->length;
+
+  if (this->field)
+    {
+      String_leaveField(this);
+    }
+
+  if (app->length == 0)
+    {
+      return 0;
+    }
+
+  if (String_size(this, this->length + app->length) == -1)
+    {
+      return -1;
+    }
+
+  memcpy(this->character + oldlength, app->character, app->length);
   return 0;
 }
-/*}}}*/
+
-int String_appendPrintf(struct String *this, const char *fmt, ...) /*{{{*/
+int String_appendChar(struct String *this, char ch)
+{
+  size_t oldlength = this->length;
+
+  if (this->field)
+    {
+      String_leaveField(this);
+    }
+  if (String_size(this, this->length + 1) == -1)
+    {
+      return -1;
+    }
+
+  this->character[oldlength] = ch;
+  return 0;
+}
+
+int String_appendChars(struct String *this, const char *ch)
+{
+  size_t oldlength = this->length;
+  size_t chlen = strlen(ch);
+
+  if (this->field)
+    {
+      String_leaveField(this);
+    }
+
+  if (String_size(this, this->length + chlen) == -1)
+    {
+      return -1;
+    }
+
+  memcpy(this->character + oldlength, ch, chlen);
+  return 0;
+}
+
+int String_appendPrintf(struct String *this, const char *fmt, ...)
 {
   char buf[1024];
-  size_t l,j;
+  size_t l, j;
   va_list ap;
 
-  if (this->field) String_leaveField(this);
+  if (this->field)
+    {
+      String_leaveField(this);
+    }
+
   va_start(ap, fmt);
-  l=vsprintf(buf,fmt,ap);
+  l = vsprintf(buf, fmt, ap);
   va_end(ap);
-  j=this->length;
+  j = this->length;
-  if (String_size(this,j+l)==-1) return -1;
+  if (String_size(this, j + l) == -1)
-  memcpy(this->character+j,buf,l);
+    {
-  return 0;
+      return -1;
-}
+    }
-/*}}}*/
-int String_insertChar(struct String *this, size_t where, char ch) /*{{{*/
-{
-  size_t oldlength=this->length;
 
-  if (this->field) String_leaveField(this);
+  memcpy(this->character + j, buf, l);
-  assert(where<oldlength);
-  if (String_size(this,this->length+1)==-1) return -1;
-  memmove(this->character+where+1,this->character+where,oldlength-where);
-  this->character[where]=ch;
   return 0;
 }
-/*}}}*/
-int String_delete(struct String *this, size_t where, size_t len) /*{{{*/
-{
-  size_t oldlength=this->length;
 
-  if (this->field) String_leaveField(this);
+int String_insertChar(struct String *this, size_t where, char ch)
-  assert(where<oldlength);
+{
-  assert(len>0);
+  size_t oldlength = this->length;
-  if ((where+len)<oldlength) memmove(this->character+where,this->character+where+len,oldlength-where-len);
+
-  this->character[this->length-=len]='\0';
+  if (this->field)
+    {
+      String_leaveField(this);
+    }
+
+  assert(where < oldlength);
+  if (String_size(this, this->length + 1) == -1)
+    {
+      return -1;
+    }
+
+  memmove(this->character + where + 1, this->character + where,
+          oldlength - where);
+  this->character[where] = ch;
   return 0;
 }
-/*}}}*/
+
-void String_ucase(struct String *this) /*{{{*/
+int String_delete(struct String *this, size_t where, size_t len)
+{
+  size_t oldlength = this->length;
+
+  if (this->field)
+    {
+      String_leaveField(this);
+    }
+
+  assert(where < oldlength);
+  assert(len > 0);
+  if ((where + len) < oldlength)
+    {
+      memmove(this->character + where, this->character + where + len,
+              oldlength - where - len);
+    }
+
+  this->character[this->length -= len] = '\0';
+  return 0;
+}
+
+void String_ucase(struct String *this)
 {
   size_t i;
 
-  for (i=0; i<this->length; ++i) this->character[i]=toupper(this->character[i]);
+  for (i = 0; i < this->length; ++i)
+    {
+      this->character[i] = toupper(this->character[i]);
+    }
 }
-/*}}}*/
+
-void String_lcase(struct String *this) /*{{{*/
+void String_lcase(struct String *this)
 {
   size_t i;
 
-  for (i=0; i<this->length; ++i) this->character[i]=tolower(this->character[i]);
+  for (i = 0; i < this->length; ++i)
+    {
+      this->character[i] = tolower(this->character[i]);
+    }
 }
-/*}}}*/
+
-int String_cmp(const struct String *this, const struct String *s) /*{{{*/
+int String_cmp(const struct String *this, const struct String *s)
 {
   size_t pos;
   int res;
-  const char *thisch,*sch;
+  const char *thisch, *sch;
 
-  for (pos=0,thisch=this->character,sch=s->character; pos<this->length && pos<s->length; ++pos,++thisch,++sch)
+  for (pos = 0, thisch = this->character, sch = s->character;
-  {
+       pos < this->length && pos < s->length; ++pos, ++thisch, ++sch)
-    if ((res=(*thisch-*sch))) return res;
+    {
-  }
+      if ((res = (*thisch - *sch)))
-  return (this->length-s->length);
+        {
+          return res;
+        }
+    }
+
+  return (this->length - s->length);
 }
-/*}}}*/
+
-void String_lset(struct String *this, const struct String *s) /*{{{*/
+void String_lset(struct String *this, const struct String *s)
 {
   size_t copy;
 
-  copy=(this->length<s->length ? this->length : s->length);
+  copy = (this->length < s->length ? this->length : s->length);
-  if (copy) memcpy(this->character,s->character,copy);
+  if (copy)
-  if (copy<this->length) memset(this->character+copy,' ',this->length-copy);
+    {
+      memcpy(this->character, s->character, copy);
+    }
+
+  if (copy < this->length)
+    {
+      memset(this->character + copy, ' ', this->length - copy);
+    }
 }
-/*}}}*/
+
-void String_rset(struct String *this, const struct String *s) /*{{{*/
+void String_rset(struct String *this, const struct String *s)
 {
   size_t copy;
 
-  copy=(this->length<s->length ? this->length : s->length);
+  copy = (this->length < s->length ? this->length : s->length);
-  if (copy) memcpy(this->character+this->length-copy,s->character,copy);
+  if (copy)
-  if (copy<this->length) memset(this->character,' ',this->length-copy);
+    {
-}
+      memcpy(this->character + this->length - copy, s->character, copy);
-/*}}}*/
+    }
-void String_set(struct String *this, size_t pos, const struct String *s, size_t length) /*{{{*/
-{
-  if (this->length>=pos)
-  {
-    if (this->length<(pos+length)) length=this->length-pos;
-    if (length) memcpy(this->character+pos,s->character,length);
-  }
-}
-/*}}}*/
 
-struct StringField *StringField_new(struct StringField *this) /*{{{*/
+  if (copy < this->length)
+    {
+      memset(this->character, ' ', this->length - copy);
+    }
+}
+
+void String_set(struct String *this, size_t pos, const struct String *s,
+                size_t length)
 {
-  this->refStrings=(struct String**)0;
+  if (this->length >= pos)
-  this->refCount=0;
+    {
+      if (this->length < (pos + length))
+        {
+          length = this->length - pos;
+        }
+
+      if (length)
+        {
+          memcpy(this->character + pos, s->character, length);
+        }
+    }
+}
+
+struct StringField *StringField_new(struct StringField *this)
+{
+  this->refStrings = (struct String **)0;
+  this->refCount = 0;
   return this;
 }
-/*}}}*/
+
-void StringField_destroy(struct StringField *this) /*{{{*/
+void StringField_destroy(struct StringField *this)
 {
   int i;
 
-  for (i=this->refCount; i>0; ) String_leaveField(this->refStrings[--i]);
+  for (i = this->refCount; i > 0;)
-  this->refCount=-1;
+    {
+      String_leaveField(this->refStrings[--i]);
+    }
+
+  this->refCount = -1;
   free(this->refStrings);
 }
-/*}}}*/

interpreters/bas/token.c

@@ -1402,11 +1402,6 @@ char *yytext;
 #include "token.h"
 #include "statement.h"
 
-#ifdef DMALLOC
-#include "dmalloc.h"
-#endif
-/*}}}*/
-
 static int matchdata;
 static int backslash_colon;
 static int uppercase;

interpreters/bas/value.c

@@ -100,10 +100,6 @@ extern long int lrint(double x);
 #include "error.h"
 #include "value.h"
 
-#ifdef USE_DMALLOC
-#  include "dmalloc.h"
-#endif
-
 /****************************************************************************
  * Private Data
  ****************************************************************************/

interpreters/bas/var.c

@@ -22,10 +22,6 @@
 #include "error.h"
 #include "var.h"
 
-#ifdef USE_DMALLOC
-#  include "dmalloc.h"
-#endif
-
 /****************************************************************************
  * Public Functions
  ****************************************************************************/