zcy
/
tinyriscv-openocd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix end-of-line style properties on newly added files. 

git-svn-id: svn://svn.berlios.de/openocd/trunk@2384 b42882b7-edfa-0310-969c-e2dbd0fdcd60
__archive__
zwelch 2009-06-24 07:43:18 +00:00
parent 0ace4d24db
commit 3324841558
4 changed files with 379 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
src/flash/at91sam3.c Executable file → Normal file
View File

46
src/flash/at91sam3.h Executable file → Normal file
View File

@ -1,23 +1,23 @@
/*************************************************************************** /***************************************************************************
* Copyright (C) 2009 by Duane Ellis * * Copyright (C) 2009 by Duane Ellis *
* openocd@duaneellis.com * * openocd@duaneellis.com *
* * * *
* This program is free software; you can redistribute it and/or modify * * This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by * * it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or * * the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. * * (at your option) any later version. *
* * * *
* This program is distributed in the hope that it will be useful, * * This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of * * but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. * * GNU General Public License for more details. *
* * * *
* You should have received a copy of the GNU General Public License * * You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the * * along with this program; if not, write to the *
* Free Software Foundation, Inc., * * Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
// nothing to do here other then export this. // nothing to do here other then export this.
extern flash_driver_t at91sam3_flash; extern flash_driver_t at91sam3_flash;

476
src/helper/membuf.c
View File

@ -1,238 +1,238 @@
/*************************************************************************** /***************************************************************************
* Copyright (C) 2009 By Duane Ellis * * Copyright (C) 2009 By Duane Ellis *
* openocd@duaneellis.com * * openocd@duaneellis.com *
* * * *
* This program is free software; you can redistribute it and/or modify * * This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by * * it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or * * the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. * * (at your option) any later version. *
* * * *
* This program is distributed in the hope that it will be useful, * * This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of * * but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. * * GNU General Public License for more details. *
* * * *
* You should have received a copy of the GNU General Public License * * You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the * * along with this program; if not, write to the *
* Free Software Foundation, Inc., * * Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#include <malloc.h> #include <malloc.h>
#include <string.h> #include <string.h>
#include "membuf.h" #include "membuf.h"
struct membuf { struct membuf {
// buflen is alway "+1" bigger then // buflen is alway "+1" bigger then
// what is shown here, the +1 is for // what is shown here, the +1 is for
// the NULL string terminator // the NULL string terminator
#define DEFAULT_BUFSIZE 100 #define DEFAULT_BUFSIZE 100
size_t maxlen; // allocated size size_t maxlen; // allocated size
size_t curlen; // where we are inserting at size_t curlen; // where we are inserting at
char *_strtoklast; char *_strtoklast;
void *buf; void *buf;
}; };
#define space_avail( pBuf ) (pBuf->maxlen - pBuf->curlen) #define space_avail( pBuf ) (pBuf->maxlen - pBuf->curlen)
#define dataend( pBuf ) ( ((char *)(pBuf->buf)) + pBuf->curlen ) #define dataend( pBuf ) ( ((char *)(pBuf->buf)) + pBuf->curlen )
size_t size_t
membuf_len( struct membuf *pBuf ) membuf_len( struct membuf *pBuf )
{ {
return pBuf->curlen; return pBuf->curlen;
} }
const void * const void *
membuf_datapointer( struct membuf *pBuf ) membuf_datapointer( struct membuf *pBuf )
{ {
return ((void *)(pBuf->buf)); return ((void *)(pBuf->buf));
} }
const char * const char *
membuf_strtok( struct membuf *pBuf, const char *sep, void **pLast ) membuf_strtok( struct membuf *pBuf, const char *sep, void **pLast )
{ {
if( pBuf ){ if( pBuf ){
pBuf->_strtoklast = NULL; pBuf->_strtoklast = NULL;
*pLast = pBuf; *pLast = pBuf;
return strtok_r( ((char *)(pBuf->buf)), sep, &(pBuf->_strtoklast) ); return strtok_r( ((char *)(pBuf->buf)), sep, &(pBuf->_strtoklast) );
} else { } else {
// recover our pBuf // recover our pBuf
pBuf = *((struct membuf **)(pLast)); pBuf = *((struct membuf **)(pLast));
return strtok_r( NULL, sep, &(pBuf->_strtoklast) ); return strtok_r( NULL, sep, &(pBuf->_strtoklast) );
} }
} }
struct membuf * struct membuf *
membuf_new(void) membuf_new(void)
{ {
// by default - parameters are zero. // by default - parameters are zero.
struct membuf *pBuf; struct membuf *pBuf;
pBuf = calloc( 1, sizeof(*pBuf) ); pBuf = calloc( 1, sizeof(*pBuf) );
if( pBuf ){ if( pBuf ){
// we *ALWAYS* allocate +1 for null terminator. // we *ALWAYS* allocate +1 for null terminator.
pBuf->buf = calloc( DEFAULT_BUFSIZE+1, sizeof(char)); pBuf->buf = calloc( DEFAULT_BUFSIZE+1, sizeof(char));
if( pBuf->buf == NULL ){ if( pBuf->buf == NULL ){
free(pBuf); free(pBuf);
pBuf = NULL; pBuf = NULL;
} else { } else {
pBuf->maxlen = DEFAULT_BUFSIZE; pBuf->maxlen = DEFAULT_BUFSIZE;
} }
} }
return pBuf; return pBuf;
} }
struct membuf * struct membuf *
membuf_grow( struct membuf *pBuf, int n ) membuf_grow( struct membuf *pBuf, int n )
{ {
void *vp; void *vp;
signed int newsize; signed int newsize;
// this is a *SIGNED* value // this is a *SIGNED* value
newsize = ((int)(pBuf->maxlen)) + n; newsize = ((int)(pBuf->maxlen)) + n;
// do not go negative, or too small // do not go negative, or too small
if( newsize < DEFAULT_BUFSIZE ){ if( newsize < DEFAULT_BUFSIZE ){
newsize = DEFAULT_BUFSIZE; newsize = DEFAULT_BUFSIZE;
} }
// always alloc +1 for the null terminator // always alloc +1 for the null terminator
vp = realloc( pBuf->buf, newsize+1 ); vp = realloc( pBuf->buf, newsize+1 );
if( vp ){ if( vp ){
pBuf->buf = vp; pBuf->buf = vp;
pBuf->maxlen = newsize; pBuf->maxlen = newsize;
return pBuf; return pBuf;
} else { } else {
return NULL; return NULL;
} }
} }
void membuf_reset( struct membuf *pBuf ) void membuf_reset( struct membuf *pBuf )
{ {
pBuf->curlen = 0; pBuf->curlen = 0;
} }
void membuf_delete( struct membuf *pBuf ) void membuf_delete( struct membuf *pBuf )
{ {
if( pBuf ){ if( pBuf ){
if( pBuf->buf){ if( pBuf->buf){
// wack data so it cannot be reused // wack data so it cannot be reused
memset(pBuf->buf,0,pBuf->maxlen); memset(pBuf->buf,0,pBuf->maxlen);
free(pBuf->buf); free(pBuf->buf);
} }
// wack dat so it cannot be reused // wack dat so it cannot be reused
memset(pBuf,0,sizeof(pBuf)); memset(pBuf,0,sizeof(pBuf));
free(pBuf); free(pBuf);
} }
} }
int int
membuf_sprintf( struct membuf *pBuf , const char *fmt, ... ) membuf_sprintf( struct membuf *pBuf , const char *fmt, ... )
{ {
int r; int r;
va_list ap; va_list ap;
va_start( ap, fmt ); va_start( ap, fmt );
r = membuf_vsprintf( pBuf, fmt, ap ); r = membuf_vsprintf( pBuf, fmt, ap );
va_end(ap); va_end(ap);
return r; return r;
} }
int int
membuf_vsprintf( struct membuf *pBuf, const char *fmt, va_list ap ) membuf_vsprintf( struct membuf *pBuf, const char *fmt, va_list ap )
{ {
int r; int r;
size_t sa; size_t sa;
int grew; int grew;
grew = 0; grew = 0;
for(;;) { for(;;) {
sa = space_avail(pBuf); sa = space_avail(pBuf);
// do work // do work
r = vsnprintf( dataend( pBuf ), r = vsnprintf( dataend( pBuf ),
sa, sa,
fmt, fmt,
ap ); ap );
if( (r > 0) && (((size_t)(r)) < sa) ){ if( (r > 0) && (((size_t)(r)) < sa) ){
// Success! // Success!
pBuf->curlen += ((size_t)(r)); pBuf->curlen += ((size_t)(r));
// remember: We always alloc'ed +1 // remember: We always alloc'ed +1
// so this does not overflow // so this does not overflow
((char *)(pBuf->buf))[ pBuf->curlen ] = 0; ((char *)(pBuf->buf))[ pBuf->curlen ] = 0;
r = 0; r = 0;
break; break;
} }
// failure // failure
if( r < 0 ){ if( r < 0 ){
// Option(A) format error // Option(A) format error
// Option(B) glibc2.0 bug // Option(B) glibc2.0 bug
// assume (B). // assume (B).
r = (4 * DEFAULT_BUFSIZE); r = (4 * DEFAULT_BUFSIZE);
} }
// don't do this again // don't do this again
if( grew ){ if( grew ){
r = -1; r = -1;
break; break;
} }
grew = 1; grew = 1;
pBuf = membuf_grow( pBuf, r ); pBuf = membuf_grow( pBuf, r );
if(pBuf == NULL){ if(pBuf == NULL){
// grow failed // grow failed
r = -1; r = -1;
break; break;
} }
} }
return r; return r;
} }
struct membuf * struct membuf *
membuf_strcat( struct membuf *pBuf, const char *pStr ) membuf_strcat( struct membuf *pBuf, const char *pStr )
{ {
return membuf_append( pBuf, pStr, strlen( pStr ) ); return membuf_append( pBuf, pStr, strlen( pStr ) );
} }
struct membuf * struct membuf *
membuf_append( struct membuf *pBuf, const void *pData, size_t len ) membuf_append( struct membuf *pBuf, const void *pData, size_t len )
{ {
size_t sa; size_t sa;
int r; int r;
// how much room is there? // how much room is there?
sa = space_avail( pBuf ); sa = space_avail( pBuf );
// will it fit? // will it fit?
if( sa < len ){ if( sa < len ){
// if not, how much do we need? // if not, how much do we need?
r = ((int)(sa - len)); r = ((int)(sa - len));
// do the grow. // do the grow.
pBuf = membuf_grow( pBuf, r ); pBuf = membuf_grow( pBuf, r );
// failed? // failed?
if(pBuf==NULL){ if(pBuf==NULL){
return pBuf; return pBuf;
} }
} }
// append // append
memcpy( dataend(pBuf), memcpy( dataend(pBuf),
pData, pData,
len ); len );
pBuf->curlen += len; pBuf->curlen += len;
return pBuf; return pBuf;
} }

236
src/helper/membuf.h
View File

@ -1,118 +1,118 @@
#ifndef HELPER_MEMBUF_H #ifndef HELPER_MEMBUF_H
#define HELPER_MEMBUF_H #define HELPER_MEMBUF_H
/** @file */ /** @file */
/** @page MEMBUF - an auto-growing string buffer /** @page MEMBUF - an auto-growing string buffer
* *
* With OpenOCD often, one must write code that sends text to * With OpenOCD often, one must write code that sends text to
* different places.. the historical command_ctx, or JIM output, * different places.. the historical command_ctx, or JIM output,
* and/or other places. * and/or other places.
* *
* This is a simple 'string buffer' that auto-grows. * This is a simple 'string buffer' that auto-grows.
* *
* More correctly put, this is a "memory buffer" * More correctly put, this is a "memory buffer"
* it may contain binary data * it may contain binary data
* *
* Note: Internally the buffer always has a 'null terminator' * Note: Internally the buffer always has a 'null terminator'
*/ */
/* contents of this structure are 'opaque' */ /* contents of this structure are 'opaque' */
struct membuf; struct membuf;
/** Create a new membuf /** Create a new membuf
* By default the memory buffer has "some non-zero-size" * By default the memory buffer has "some non-zero-size"
* (couple hundred bytes, exact amount is opaque) * (couple hundred bytes, exact amount is opaque)
*/ */
struct membuf *membuf_new(void); struct membuf *membuf_new(void);
/** delete (destroy) the mem buffer /** delete (destroy) the mem buffer
* @param pBuf - buffer to release * @param pBuf - buffer to release
*/ */
void membuf_delete( struct membuf *pBuf ); void membuf_delete( struct membuf *pBuf );
/** grow/shrink a membuf by specified amount. /** grow/shrink a membuf by specified amount.
* @param pBuf - the buffer * @param pBuf - the buffer
* @param amount - the amount to grow or shrink by. * @param amount - the amount to grow or shrink by.
* *
* Symantics of 'realloc()' return NULL on failure * Symantics of 'realloc()' return NULL on failure
*/ */
struct membuf *membuf_grow( struct membuf *pBuf, int amount ); struct membuf *membuf_grow( struct membuf *pBuf, int amount );
/** how long is this buffer (memlen(), strlen()) /** how long is this buffer (memlen(), strlen())
* @param pBuf - the buffer * @param pBuf - the buffer
* *
* @returns: length of current buffer. * @returns: length of current buffer.
*/ */
size_t membuf_len( struct membuf *pBuf ); size_t membuf_len( struct membuf *pBuf );
/** reset an membuf to zero length. /** reset an membuf to zero length.
* @param pBuf - buffer to reset * @param pBuf - buffer to reset
* *
* Note this does not 'release' the memory buffer * Note this does not 'release' the memory buffer
*/ */
void membuf_reset( struct membuf *pBuf ); void membuf_reset( struct membuf *pBuf );
/** sprintf() to the string buffer /** sprintf() to the string buffer
* @param pBuf - buffer to capture sprintf() data into * @param pBuf - buffer to capture sprintf() data into
* @param fmt - printf format * @param fmt - printf format
* *
* Returns 0 on success * Returns 0 on success
* Returns non-zero on failure * Returns non-zero on failure
*/ */
int membuf_sprintf( struct membuf *pBuf , const char *fmt, ... ); int membuf_sprintf( struct membuf *pBuf , const char *fmt, ... );
/** vsprintf() to the string buffer /** vsprintf() to the string buffer
* @param pBuf - buffer to capture sprintf() data into * @param pBuf - buffer to capture sprintf() data into
* @param fmt - printf format * @param fmt - printf format
* @param ap - va_list for fmt * @param ap - va_list for fmt
* *
* Returns 0 on success * Returns 0 on success
* Returns non-zero on failure * Returns non-zero on failure
*/ */
int membuf_vsprintf( struct membuf *pBuf , const char *fmt, va_list ap); int membuf_vsprintf( struct membuf *pBuf , const char *fmt, va_list ap);
/** Tokenize lines using strtok() /** Tokenize lines using strtok()
* @param pBuf - buffer to tokenize * @param pBuf - buffer to tokenize
* @param delim - delimiter parameter for strtok_r() * @param delim - delimiter parameter for strtok_r()
* *
* Identical to "strtok()" - pass "pBuff=NULL" on second call * Identical to "strtok()" - pass "pBuff=NULL" on second call
* *
* NOTE: This call is <b>destructive</b> to the buffer. * NOTE: This call is <b>destructive</b> to the buffer.
*/ */
const char *membuf_strtok( struct membuf *pBuf, const char *delim, void **pSave ); const char *membuf_strtok( struct membuf *pBuf, const char *delim, void **pSave );
/** Return pointer to the memory in the buffer /** Return pointer to the memory in the buffer
* @param pBuf - buffer * @param pBuf - buffer
* *
* NOTE: Thou shall not modify this pointer, it is <b>CONST</b> * NOTE: Thou shall not modify this pointer, it is <b>CONST</b>
*/ */
const void *membuf_datapointer( struct membuf *pBuf ); const void *membuf_datapointer( struct membuf *pBuf );
/** Append data to the buffer /** Append data to the buffer
* @param pBuf - buffer to append * @param pBuf - buffer to append
* @param pData - pointer to data to append * @param pData - pointer to data to append
* @param len - length of data to append * @param len - length of data to append
* *
* Modified symantics of "memcpy()". On memory allocation failure * Modified symantics of "memcpy()". On memory allocation failure
* returns NULL. On success, returns pointer to orginal membuf. * returns NULL. On success, returns pointer to orginal membuf.
*/ */
struct membuf *membuf_append( struct membuf *pBuf, const void *pData, size_t len ); struct membuf *membuf_append( struct membuf *pBuf, const void *pData, size_t len );
/** Append string to the buffer /** Append string to the buffer
* @param pBuf - buffer to append * @param pBuf - buffer to append
* @param str - string to append * @param str - string to append
* *
* Modified symantics of "strcat()". On memory allocation failure * Modified symantics of "strcat()". On memory allocation failure
* returns NULL. On success, returns pointer to orginal membuf. * returns NULL. On success, returns pointer to orginal membuf.
*/ */
struct membuf *membuf_strcat( struct membuf *pBuf, const char *s ); struct membuf *membuf_strcat( struct membuf *pBuf, const char *s );
#endif #endif