6502/cc65
1
0
Fork 0
mirror of https://github.com/cc65/cc65.git synced 2025-01-10 19:29:45 +00:00
Code Issues Projects Releases Wiki Activity

Fixed problems with the inline macros

Browse Source 
git-svn-id: svn://svn.cc65.org/cc65/trunk@1040 b7a2c559-68d2-44c3-8de9-860c34a00d81
This commit is contained in:
cuz 2001-10-11 21:54:25 +00:00
parent 46209118b1
commit de7da529f0
4 changed files with 213 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
src/common/coll.c
View File

@ -116,22 +116,22 @@ void CollInsert (Collection* C, void* Item, unsigned Index)
/* Grow the array if necessary */
if (C->Count >= C->Size) {
/* Must grow */
/* Must grow */
void** NewItems;
if (C->Size > 0) {
C->Size *= 2;
} else {
C->Size = 8;
}
NewItems = xmalloc (C->Size * sizeof (void*));
memcpy (NewItems, C->Items, C->Count * sizeof (void*));
xfree (C->Items);
C->Items = NewItems;
if (C->Size > 0) {
C->Size *= 2;
} else {
C->Size = 8;
}
NewItems = xmalloc (C->Size * sizeof (void*));
memcpy (NewItems, C->Items, C->Count * sizeof (void*));
xfree (C->Items);
C->Items = NewItems;
}
/* Move the existing elements if needed */
if (C->Count != Index) {
memmove (C->Items+Index+1, C->Items+Index, (C->Count-Index) * sizeof (void*));
memmove (C->Items+Index+1, C->Items+Index, (C->Count-Index) * sizeof (void*));
}
++C->Count;
@ -141,6 +141,89 @@ void CollInsert (Collection* C, void* Item, unsigned Index)
#if !defined(HAVE_INLINE)
void CollAppend (Collection* C, void* Item)
/* Append an item to the end of the collection */
{
/* Insert the item at the end of the current list */
CollInsert (C, Item, C->Count);
}
#endif
#if !defined(HAVE_INLINE)
void* CollAt (Collection* C, unsigned Index)
/* Return the item at the given index */
{
/* Check the index */
PRECONDITION (Index < C->Count);
/* Return the element */
return C->Items[Index];
}
#endif
#if !defined(HAVE_INLINE)
const void* CollConstAt (const Collection* C, unsigned Index)
/* Return the item at the given index */
{
/* Check the index */
PRECONDITION (Index < C->Count);
/* Return the element */
return C->Items[Index];
}
#endif
#if !defined(HAVE_INLINE)
void* CollLast (Collection* C)
/* Return the last item in a collection */
{
/* We must have at least one entry */
PRECONDITION (C->Count > 0);
/* Return the element */
return C->Items[C->Count-1];
}
#endif
#if !defined(HAVE_INLINE)
const void* CollConstLast (const Collection* C)
/* Return the last item in a collection */
{
/* We must have at least one entry */
PRECONDITION (C->Count > 0);
/* Return the element */
return C->Items[C->Count-1];
}
#endif
#if !defined(HAVE_INLINE)
void* CollPop (Collection* C)
/* Remove the last segment from the stack and return it. Calls FAIL if the
* collection is empty.
*/
{
/* We must have at least one entry */
PRECONDITION (C->Count > 0);
/* Return the element */
return C->Items[--C->Count];
}
#endif
int CollIndex (Collection* C, const void* Item)
/* Return the index of the given item in the collection. Return -1 if the
* item was not found in the collection.
@ -149,9 +232,9 @@ int CollIndex (Collection* C, const void* Item)
/* Linear search */
unsigned I;
for (I = 0; I < C->Count; ++I) {
if (Item == C->Items[I]) {
/* Found */
return (int)I;
if (Item == C->Items[I]) {
/* Found */
return (int)I;
}
}
@ -193,6 +276,22 @@ void CollDeleteItem (Collection* C, const void* Item)
#if !defined(HAVE_INLINE)
void CollReplace (Collection* C, void* Item, unsigned Index)
/* Replace the item at the given position. The old item will not be freed,
* just the pointer will get replaced.
*/
{
/* Check the index */
PRECONDITION (Index < C->Count);
/* Replace the item pointer */
C->Items[Index] = Item;
}
#endif
void CollMove (Collection* C, unsigned OldIndex, unsigned NewIndex)
/* Move an item from one position in the collection to another. OldIndex
* is the current position of the item, NewIndex is the new index after

43
src/common/coll.h
View File

@ -111,7 +111,8 @@ INLINE void CollAppend (Collection* C, void* Item)
CollInsert (C, Item, C->Count);
}
#else
# define CollAppend(C, Item) CollInsert (C, Item, (C)->Count)
void CollAppend (Collection* C, void* Item);
/* Append an item to the end of the collection */
#endif
#if defined(HAVE_INLINE)
@ -125,9 +126,8 @@ INLINE void* CollAt (Collection* C, unsigned Index)
return C->Items[Index];
}
#else
# define CollAt(C, Index) \
(PRECONDITION ((Index) < (C)->Count), \
(C)->Items[(Index)])
void* CollAt (Collection* C, unsigned Index);
/* Return the item at the given index */
#endif
#if defined(HAVE_INLINE)
@ -152,9 +152,8 @@ INLINE const void* CollConstAt (const Collection* C, unsigned Index)
return C->Items[Index];
}
#else
# define CollConstAt(C, Index) \
(PRECONDITION ((Index) < (C)->Count), \
(C)->Items[(Index)])
const void* CollConstAt (const Collection* C, unsigned Index);
/* Return the item at the given index */
#endif
#if defined(HAVE_INLINE)
@ -168,9 +167,8 @@ INLINE void* CollLast (Collection* C)
return C->Items[C->Count-1];
}
#else
# define CollLast(C) \
(PRECONDITION ((C)->Count > 0), \
(C)->Items[(C)->Count-1])
void* CollLast (Collection* C);
/* Return the last item in a collection */
#endif
#if defined(HAVE_INLINE)
@ -184,9 +182,8 @@ INLINE const void* CollConstLast (const Collection* C)
return C->Items[C->Count-1];
}
#else
# define CollConstLast(C) \
(PRECONDITION ((C)->Count > 0), \
(C)->Items[(C)->Count-1])
const void* CollConstLast (const Collection* C);
/* Return the last item in a collection */
#endif
#if defined(HAVE_INLINE)
@ -202,9 +199,10 @@ INLINE void* CollPop (Collection* C)
return C->Items[--C->Count];
}
#else
# define CollPop(C) \
(PRECONDITION ((C)->Count > 0), \
(C)->Items[--(C)->Count])
void* CollPop (Collection* C);
/* Remove the last segment from the stack and return it. Calls FAIL if the
* collection is empty.
*/
#endif
int CollIndex (Collection* C, const void* Item);
@ -239,7 +237,7 @@ INLINE void CollDeleteAll (Collection* C)
#if defined(HAVE_INLINE)
INLINE void CollReplace (Collection* C, void* Item, unsigned Index)
/* Replace the item at the given position. The old item will not be freed,
* just the pointer will et replaced.
* just the pointer will get replaced.
*/
{
/* Check the index */
@ -249,9 +247,10 @@ INLINE void CollReplace (Collection* C, void* Item, unsigned Index)
C->Items[Index] = Item;
}
#else
# define CollReplace(C, Item, Index) \
(PRECONDITION ((Index) < (C)->Count), \
(C)->Items[(Index)] = (Item))
void CollReplace (Collection* C, void* Item, unsigned Index);
/* Replace the item at the given position. The old item will not be freed,
* just the pointer will get replaced.
*/
#endif
void CollMove (Collection* C, unsigned OldIndex, unsigned NewIndex);
@ -280,10 +279,10 @@ void CollSort (Collection* C,
/* End of exprlist.h */
/* End of coll.h */
#endif

65
src/common/strbuf.c
View File

@ -124,6 +124,17 @@ void SB_Realloc (StrBuf* B, unsigned NewSize)
#if !defined(HAVE_INLINE)
char SB_At (const StrBuf* B, unsigned Index)
/* Get a character from the buffer */
{
PRECONDITION (Index < B->Len);
return B->Buf[Index];
}
#endif
void SB_Terminate (StrBuf* B)
/* Zero terminate the given string buffer. NOTE: The terminating zero is not
* accounted for in B->Len, if you want that, you have to use AppendChar!
@ -150,6 +161,26 @@ void SB_CopyBuf (StrBuf* Target, const char* Buf, unsigned Size)
#if !defined(HAVE_INLINE)
void SB_CopyStr (StrBuf* Target, const char* S)
/* Copy S to Target, discarding the old contents of Target */
{
SB_CopyBuf (Target, S, strlen (S));
}
#endif
#if !defined(HAVE_INLINE)
void SB_Copy (StrBuf* Target, const StrBuf* Source)
/* Copy Source to Target, discarding the old contents of Target */
{
SB_CopyBuf (Target, Source->Buf, Source->Len);
}
#endif
void SB_AppendChar (StrBuf* B, char C)
/* Append a character to a string buffer */
{
@ -176,6 +207,40 @@ void SB_AppendBuf (StrBuf* B, const char* S, unsigned Size)
#if !defined(HAVE_INLINE)
void SB_AppendStr (StrBuf* B, const char* S)
/* Append a string to the end of the string buffer */
{
SB_AppendBuf (B, S, strlen (S));
}
#endif
#if !defined(HAVE_INLINE)
void SB_Append (StrBuf* Target, const StrBuf* Source)
/* Append the contents of Source to Target */
{
SB_AppendBuf (Target, Source->Buf, Source->Len);
}
#endif
#if !defined(HAVE_INLINE)
void SB_Cut (StrBuf* B, unsigned Len)
/* Cut the contents of B at the given length. If the current length of the
* buffer is smaller than Len, nothing will happen.
*/
{
if (Len < B->Len) {
B->Len = Len;
}
}
#endif
void SB_Slice (StrBuf* Target, const StrBuf* Source, unsigned Start, unsigned Len)
/* Copy a slice from Source into Target. The current contents of Target are
* destroyed. If Start is greater than the length of Source, or if Len

22
src/common/strbuf.h
View File

@ -132,9 +132,8 @@ INLINE char SB_At (const StrBuf* B, unsigned Index)
return B->Buf[Index];
}
#else
# define SB_At(B, Index) \
(PRECONDITION ((Index) < (B)->Len), \
(B)->Buf[Index])
char SB_At (const StrBuf* B, unsigned Index);
/* Get a character from the buffer */
#endif
#if defined(HAVE_INLINE)
@ -182,7 +181,8 @@ INLINE void SB_CopyStr (StrBuf* Target, const char* S)
SB_CopyBuf (Target, S, strlen (S));
}
#else
# define SB_CopyStr(Target, S) SB_CopyBuf (Target, S, strlen (S))
void SB_CopyStr (StrBuf* Target, const char* S);
/* Copy S to Target, discarding the old contents of Target */
#endif
#if defined(HAVE_INLINE)
@ -192,7 +192,8 @@ INLINE void SB_Copy (StrBuf* Target, const StrBuf* Source)
SB_CopyBuf (Target, Source->Buf, Source->Len);
}
#else
# define SB_Copy(Target, Source) SB_CopyBuf (Target, (Source)->Buf, (Source)->Len)
void SB_Copy (StrBuf* Target, const StrBuf* Source);
/* Copy Source to Target, discarding the old contents of Target */
#endif
void SB_AppendChar (StrBuf* B, char C);
@ -208,7 +209,8 @@ INLINE void SB_AppendStr (StrBuf* B, const char* S)
SB_AppendBuf (B, S, strlen (S));
}
#else
# define SB_AppendStr(B, S) SB_AppendBuf (B, S, strlen (S))
void SB_AppendStr (StrBuf* B, const char* S);
/* Append a string to the end of the string buffer */
#endif
#if defined(HAVE_INLINE)
@ -218,7 +220,8 @@ INLINE void SB_Append (StrBuf* Target, const StrBuf* Source)
SB_AppendBuf (Target, Source->Buf, Source->Len);
}
#else
# define SB_Append(Target, Source) SB_AppendBuf (Target, (Source)->Buf, (Source)->Len)
void SB_Append (StrBuf* Target, const StrBuf* Source);
/* Append the contents of Source to Target */
#endif
#if defined(HAVE_INLINE)
@ -232,7 +235,10 @@ INLINE void SB_Cut (StrBuf* B, unsigned Len)
}
}
#else
# define SB_Cut(B, L) if ((L) < (B)->Len) { (B)->Len = (L); }
void SB_Cut (StrBuf* B, unsigned Len);
/* Cut the contents of B at the given length. If the current length of the
* buffer is smaller than Len, nothing will happen.
*/
#endif
void SB_Slice (StrBuf* Target, const StrBuf* Source, unsigned Start, unsigned Len);