YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add indentation checks for code inside classes and fix appeared issues.

Browse Source 
Fix asserts in test_recordset.cpp.

JerryScript-DCO-1.0-Signed-off-by: Andrey Shitov a.shitov@samsung.com
This commit is contained in:
Andrey Shitov
2015-05-26 16:07:25 +03:00
parent cefeea06f6
commit 55b43071d1
4 changed files with 358 additions and 341 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/rcs/rcs-chunked-list.h
+29 -29
View File
@@ -36,46 +36,46 @@
*/ */
class rcs_chunked_list_t class rcs_chunked_list_t
{ {
public: public:
/** /**
* List node * List node
*/ */
typedef struct typedef struct
{ {
mem_cpointer_t prev_cp; /**< prev list's node */ mem_cpointer_t prev_cp; /**< prev list's node */
mem_cpointer_t next_cp; /**< next list's node */ mem_cpointer_t next_cp; /**< next list's node */
} node_t; } node_t;
void init (void); void init (void);
void free (void); void free (void);
node_t *get_first (void) const; node_t *get_first (void) const;
node_t *get_last (void) const; node_t *get_last (void) const;
node_t *get_prev (node_t *node_p) const; node_t *get_prev (node_t *node_p) const;
node_t *get_next (node_t *node_p) const; node_t *get_next (node_t *node_p) const;
node_t *append_new (void); node_t *append_new (void);
node_t *insert_new (node_t *after_p); node_t *insert_new (node_t *after_p);
void remove (node_t *node_p); void remove (node_t *node_p);
node_t *get_node_from_pointer (void *ptr) const; node_t *get_node_from_pointer (void *ptr) const;
uint8_t* get_data_space (node_t *node_p) const; uint8_t* get_data_space (node_t *node_p) const;
static size_t get_data_space_size (void); static size_t get_data_space_size (void);
private: private:
void set_prev (node_t *node_p, node_t *prev_node_p); void set_prev (node_t *node_p, node_t *prev_node_p);
void set_next (node_t *node_p, node_t *next_node_p); void set_next (node_t *node_p, node_t *next_node_p);
static size_t get_node_size (void); static size_t get_node_size (void);
void assert_list_is_correct (void) const; void assert_list_is_correct (void) const;
void assert_node_is_correct (const node_t *node_p) const; void assert_node_is_correct (const node_t *node_p) const;
node_t* head_p; /**< head node of list */ node_t* head_p; /**< head node of list */
node_t* tail_p; /**< tail node of list */ node_t* tail_p; /**< tail node of list */
}; };
/** /**
jerry-core/rcs/rcs-recordset.h
+161 -160
View File
@@ -57,151 +57,152 @@
*/ */
class rcs_recordset_t class rcs_recordset_t
{ {
public:
/* Constructor */
void init (void)
{
_chunk_list.init ();
JERRY_ASSERT (_chunk_list.get_data_space_size () % RCS_DYN_STORAGE_LENGTH_UNIT == 0);
} /* init */
/* Destructor */
void finalize (void)
{
_chunk_list.free ();
} /* finalize */
/**
* Record type
*/
class record_t
{
public: public:
/* Constructor */ typedef uint8_t type_t;
void init (void)
{
_chunk_list.init ();
JERRY_ASSERT (_chunk_list.get_data_space_size () % RCS_DYN_STORAGE_LENGTH_UNIT == 0); type_t get_type (void) const;
} /* init */ void set_type (type_t type);
/* Destructor */
void finalize (void)
{
_chunk_list.free ();
} /* finalize */
/** /**
* Record type * Dynamic storage-specific extended compressed pointer
*/
class record_t
{
public:
typedef uint8_t type_t;
type_t get_type (void) const;
void set_type (type_t type);
/**
* Dynamic storage-specific extended compressed pointer
*
* Note:
* the pointer can represent addresses aligned by RCS_DYN_STORAGE_ALIGNMENT,
* while mem_cpointer_t can only represent addressed aligned by MEM_ALIGNMENT.
*/
struct cpointer_t
{
static const uint32_t bit_field_width = MEM_CP_WIDTH + MEM_ALIGNMENT_LOG - RCS_DYN_STORAGE_ALIGNMENT_LOG;
union
{
struct
{
mem_cpointer_t base_cp : MEM_CP_WIDTH; /**< pointer to base of addressed area */
#if MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_ALIGNMENT_LOG
uint16_t ext : (MEM_ALIGNMENT_LOG - RCS_DYN_STORAGE_ALIGNMENT_LOG); /**< extension of the basic
* compressed pointer
* used for more detailed
* addressing */
#endif /* MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_ALIGNMENT_LOG */
} value;
uint16_t packed_value;
};
static cpointer_t compress (record_t* pointer_p);
static record_t* decompress (cpointer_t pointer_cp);
};
private:
/**
* Offset of 'type' field, in bits
*/
static const uint32_t _type_field_pos = 0u;
/**
* Width of 'type' field, in bits
*/
static const uint32_t _type_field_width = 4u;
protected:
void check_this (void) const;
uint32_t get_field (uint32_t field_pos, uint32_t field_width) const;
void set_field (uint32_t field_pos, uint32_t field_width, size_t value);
record_t* get_pointer (uint32_t field_pos, uint32_t field_width) const;
void set_pointer (uint32_t field_pos, uint32_t field_width, record_t* pointer_p);
/**
* Offset of a derived record's fields, in bits
*/
static const uint32_t _fields_offset_begin = _type_field_pos + _type_field_width;
};
private:
friend class rcs_record_iterator_t;
/**
* Type identifier for free record
*/
static const record_t::type_t _free_record_type_id = 0;
/**
* Chunked list used for memory allocation
*/
rcs_chunked_list_t _chunk_list;
void alloc_record_in_place (record_t* place_p,
size_t free_size,
record_t* next_record_p);
void init_free_record (record_t *free_rec_p, size_t size, record_t *prev_rec_p);
bool is_record_free (record_t *record_p);
protected:
/**
* First type identifier that can be used for storage-specific record types
*/
static const record_t::type_t _first_type_id = _free_record_type_id + 1;
/**
* Allocate new record of specified type
* *
* @return pointer to the new record * Note:
* the pointer can represent addresses aligned by RCS_DYN_STORAGE_ALIGNMENT,
* while mem_cpointer_t can only represent addressed aligned by MEM_ALIGNMENT.
*/ */
template< struct cpointer_t
typename T, /**< type of record structure */
typename ... SizeArgs> /**< type of arguments of T::size */
T* alloc_record (record_t::type_t type, /**< record's type identifier */
SizeArgs ... size_args) /**< arguments of T::size */
{ {
JERRY_ASSERT (type >= _first_type_id); static const uint32_t bit_field_width = MEM_CP_WIDTH + MEM_ALIGNMENT_LOG - RCS_DYN_STORAGE_ALIGNMENT_LOG;
size_t size = T::size (size_args...); union
{
struct
{
mem_cpointer_t base_cp : MEM_CP_WIDTH; /**< pointer to base of addressed area */
#if MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_ALIGNMENT_LOG
uint16_t ext : (MEM_ALIGNMENT_LOG - RCS_DYN_STORAGE_ALIGNMENT_LOG); /**< extension of the basic
* compressed pointer
* used for more detailed
* addressing */
#endif /* MEM_ALIGNMENT_LOG > RCS_DYN_STORAGE_ALIGNMENT_LOG */
} value;
uint16_t packed_value;
};
record_t *prev_rec_p; static cpointer_t compress (record_t* pointer_p);
T* rec_p = static_cast<T*> (alloc_space_for_record (size, &prev_rec_p)); static record_t* decompress (cpointer_t pointer_cp);
};
rec_p->set_type (type); private:
rec_p->set_size (size); /**
rec_p->set_prev (prev_rec_p); * Offset of 'type' field, in bits
*/
static const uint32_t _type_field_pos = 0u;
assert_state_is_correct (); /**
* Width of 'type' field, in bits
*/
static const uint32_t _type_field_width = 4u;
return rec_p; protected:
} /* alloc_record */ void check_this (void) const;
record_t* alloc_space_for_record (size_t bytes, record_t** out_prev_rec_p); uint32_t get_field (uint32_t field_pos, uint32_t field_width) const;
void free_record (record_t* record_p); void set_field (uint32_t field_pos, uint32_t field_width, size_t value);
record_t* get_first (void); record_t* get_pointer (uint32_t field_pos, uint32_t field_width) const;
void set_pointer (uint32_t field_pos, uint32_t field_width, record_t* pointer_p);
virtual record_t* get_prev (record_t* rec_p); /**
record_t* get_next (record_t* rec_p); * Offset of a derived record's fields, in bits
virtual void set_prev (record_t* rec_p, record_t *prev_rec_p); */
static const uint32_t _fields_offset_begin = _type_field_pos + _type_field_width;
};
virtual size_t get_record_size (record_t* rec_p); private:
friend class rcs_record_iterator_t;
void assert_state_is_correct (void); /**
* Type identifier for free record
*/
static const record_t::type_t _free_record_type_id = 0;
/**
* Chunked list used for memory allocation
*/
rcs_chunked_list_t _chunk_list;
void alloc_record_in_place (record_t* place_p,
size_t free_size,
record_t* next_record_p);
void init_free_record (record_t *free_rec_p, size_t size, record_t *prev_rec_p);
bool is_record_free (record_t *record_p);
protected:
/**
* First type identifier that can be used for storage-specific record types
*/
static const record_t::type_t _first_type_id = _free_record_type_id + 1;
/**
* Allocate new record of specified type
*
* @return pointer to the new record
*/
template<
typename T, /**< type of record structure */
typename ... SizeArgs> /**< type of arguments of T::size */
T* alloc_record (record_t::type_t type, /**< record's type identifier */
SizeArgs ... size_args) /**< arguments of T::size */
{
JERRY_ASSERT (type >= _first_type_id);
size_t size = T::size (size_args...);
record_t *prev_rec_p;
T* rec_p = static_cast<T*> (alloc_space_for_record (size, &prev_rec_p));
rec_p->set_type (type);
rec_p->set_size (size);
rec_p->set_prev (prev_rec_p);
assert_state_is_correct ();
return rec_p;
} /* alloc_record */
record_t* alloc_space_for_record (size_t bytes, record_t** out_prev_rec_p);
void free_record (record_t* record_p);
record_t* get_first (void);
virtual record_t* get_prev (record_t* rec_p);
record_t* get_next (record_t* rec_p);
virtual void set_prev (record_t* rec_p, record_t *prev_rec_p);
virtual size_t get_record_size (record_t* rec_p);
void assert_state_is_correct (void);
}; /* rcs_recordset_t */ }; /* rcs_recordset_t */
/** /**
@@ -219,19 +220,19 @@ typedef rcs_record_t::cpointer_t rcs_cpointer_t;
*/ */
class rcs_record_iterator_t class rcs_record_iterator_t
{ {
public: public:
rcs_record_iterator_t (rcs_record_t* rec_p); rcs_record_iterator_t (rcs_record_t* rec_p);
rcs_record_iterator_t (rcs_cpointer_t rec_ext_cp); rcs_record_iterator_t (rcs_cpointer_t rec_ext_cp);
protected: protected:
template<typename T> T read (void); template<typename T> T read (void);
template<typename T> void write (T value); template<typename T> void write (T value);
private: private:
rcs_record_t* _record_start_p; /**< start of current record */ rcs_record_t* _record_start_p; /**< start of current record */
uint8_t* _current_pos_p; /**< pointer to current offset in current record */ uint8_t* _current_pos_p; /**< pointer to current offset in current record */
rcs_recordset_t *_recordset_p; /**< recordset containing the record */ rcs_recordset_t *_recordset_p; /**< recordset containing the record */
}; /* rcs_record_iterator_t */ }; /* rcs_record_iterator_t */
/** /**
@@ -239,32 +240,32 @@ class rcs_record_iterator_t
*/ */
class rcs_free_record_t : public rcs_record_t class rcs_free_record_t : public rcs_record_t
{ {
public: public:
size_t get_size (void) const; size_t get_size (void) const;
void set_size (size_t size); void set_size (size_t size);
rcs_record_t* get_prev (void) const; rcs_record_t* get_prev (void) const;
void set_prev (rcs_record_t* prev_rec_p); void set_prev (rcs_record_t* prev_rec_p);
private: private:
/** /**
* Offset of 'length' field, in bits * Offset of 'length' field, in bits
*/ */
static const uint32_t _length_field_pos = _fields_offset_begin; static const uint32_t _length_field_pos = _fields_offset_begin;
/** /**
* Width of 'length' field, in bits * Width of 'length' field, in bits
*/ */
static const uint32_t _length_field_width = 12u; static const uint32_t _length_field_width = 12u;
/** /**
* Offset of 'previous record' field, in bits * Offset of 'previous record' field, in bits
*/ */
static const uint32_t _prev_field_pos = _length_field_pos + _length_field_width; static const uint32_t _prev_field_pos = _length_field_pos + _length_field_width;
/** /**
* Width of 'previous record' field, in bits * Width of 'previous record' field, in bits
*/ */
static const uint32_t _prev_field_width = rcs_cpointer_t::bit_field_width; static const uint32_t _prev_field_width = rcs_cpointer_t::bit_field_width;
}; };
/** /**
tests/unit/test_recordset.cpp
+136 -138
View File
@@ -13,8 +13,6 @@
* limitations under the License. * limitations under the License.
*/ */
#include <assert.h>
#include "jrt.h" #include "jrt.h"
#include "mem-allocator.h" #include "mem-allocator.h"
#include "rcs-recordset.h" #include "rcs-recordset.h"
@@ -45,175 +43,175 @@ extern "C"
class test_rcs_record_type_one_t : public rcs_record_t class test_rcs_record_type_one_t : public rcs_record_t
{ {
public: public:
static size_t size (uint32_t elements_count) static size_t size (uint32_t elements_count)
{ {
return JERRY_ALIGNUP (header_size + element_size * elements_count, return JERRY_ALIGNUP (header_size + element_size * elements_count,
RCS_DYN_STORAGE_LENGTH_UNIT); RCS_DYN_STORAGE_LENGTH_UNIT);
} }
size_t get_size () const size_t get_size () const
{ {
return get_field (length_field_pos, length_field_width) * RCS_DYN_STORAGE_LENGTH_UNIT; return get_field (length_field_pos, length_field_width) * RCS_DYN_STORAGE_LENGTH_UNIT;
} }
void set_size (size_t size) void set_size (size_t size)
{ {
JERRY_ASSERT (JERRY_ALIGNUP (size, RCS_DYN_STORAGE_ALIGNMENT) == size); JERRY_ASSERT (JERRY_ALIGNUP (size, RCS_DYN_STORAGE_ALIGNMENT) == size);
set_field (length_field_pos, length_field_width, size >> RCS_DYN_STORAGE_ALIGNMENT_LOG); set_field (length_field_pos, length_field_width, size >> RCS_DYN_STORAGE_ALIGNMENT_LOG);
} }
rcs_record_t* get_prev () const rcs_record_t* get_prev () const
{ {
return get_pointer (prev_field_pos, prev_field_width); return get_pointer (prev_field_pos, prev_field_width);
} }
void set_prev (rcs_record_t* prev_rec_p) void set_prev (rcs_record_t* prev_rec_p)
{ {
set_pointer (prev_field_pos, prev_field_width, prev_rec_p); set_pointer (prev_field_pos, prev_field_width, prev_rec_p);
} }
private: private:
static const uint32_t length_field_pos = _fields_offset_begin; static const uint32_t length_field_pos = _fields_offset_begin;
static const uint32_t length_field_width = 12u; static const uint32_t length_field_width = 12u;
static const uint32_t prev_field_pos = length_field_pos + length_field_width; static const uint32_t prev_field_pos = length_field_pos + length_field_width;
static const uint32_t prev_field_width = rcs_cpointer_t::bit_field_width; static const uint32_t prev_field_width = rcs_cpointer_t::bit_field_width;
static const size_t header_size = 2 * RCS_DYN_STORAGE_LENGTH_UNIT; static const size_t header_size = 2 * RCS_DYN_STORAGE_LENGTH_UNIT;
static const size_t element_size = sizeof (uint16_t); static const size_t element_size = sizeof (uint16_t);
}; };
class test_rcs_record_type_two_t : public rcs_record_t class test_rcs_record_type_two_t : public rcs_record_t
{ {
public: public:
static size_t size (void) static size_t size (void)
{ {
return JERRY_ALIGNUP (header_size, RCS_DYN_STORAGE_LENGTH_UNIT); return JERRY_ALIGNUP (header_size, RCS_DYN_STORAGE_LENGTH_UNIT);
} }
size_t get_size () const size_t get_size () const
{ {
return size (); return size ();
} }
void set_size (size_t size) void set_size (size_t size)
{ {
JERRY_ASSERT (size == get_size ()); JERRY_ASSERT (size == get_size ());
} }
rcs_record_t* get_prev () const rcs_record_t* get_prev () const
{ {
return get_pointer (prev_field_pos, prev_field_width); return get_pointer (prev_field_pos, prev_field_width);
} }
void set_prev (rcs_record_t* prev_rec_p) void set_prev (rcs_record_t* prev_rec_p)
{ {
set_pointer (prev_field_pos, prev_field_width, prev_rec_p); set_pointer (prev_field_pos, prev_field_width, prev_rec_p);
} }
private: private:
static const uint32_t prev_field_pos = _fields_offset_begin; static const uint32_t prev_field_pos = _fields_offset_begin;
static const uint32_t prev_field_width = rcs_cpointer_t::bit_field_width; static const uint32_t prev_field_width = rcs_cpointer_t::bit_field_width;
static const size_t header_size = RCS_DYN_STORAGE_LENGTH_UNIT; static const size_t header_size = RCS_DYN_STORAGE_LENGTH_UNIT;
}; };
class test_rcs_recordset_t : public rcs_recordset_t class test_rcs_recordset_t : public rcs_recordset_t
{ {
public: public:
test_rcs_record_type_one_t* test_rcs_record_type_one_t*
create_record_type_one (uint32_t elements_count) create_record_type_one (uint32_t elements_count)
{ {
return alloc_record<test_rcs_record_type_one_t, uint32_t> (_record_type_one_id, return alloc_record<test_rcs_record_type_one_t, uint32_t> (_record_type_one_id,
elements_count); elements_count);
} }
void void
free_record_type_one (test_rcs_record_type_one_t* rec_p) free_record_type_one (test_rcs_record_type_one_t* rec_p)
{ {
free_record (rec_p); free_record (rec_p);
} }
test_rcs_record_type_two_t* test_rcs_record_type_two_t*
create_record_type_two (void) create_record_type_two (void)
{ {
return alloc_record<test_rcs_record_type_two_t> (_record_type_two_id); return alloc_record<test_rcs_record_type_two_t> (_record_type_two_id);
} }
void void
free_record_type_two (test_rcs_record_type_two_t* rec_p) free_record_type_two (test_rcs_record_type_two_t* rec_p)
{ {
free_record (rec_p); free_record (rec_p);
} }
private: private:
static const int _record_type_one_id = _first_type_id + 0; static const int _record_type_one_id = _first_type_id + 0;
static const int _record_type_two_id = _first_type_id + 1; static const int _record_type_two_id = _first_type_id + 1;
virtual rcs_record_t* get_prev (rcs_record_t* rec_p) virtual rcs_record_t* get_prev (rcs_record_t* rec_p)
{
switch (rec_p->get_type ())
{ {
switch (rec_p->get_type ()) case _record_type_one_id:
{ {
case _record_type_one_id: return (static_cast<test_rcs_record_type_one_t*> (rec_p))->get_prev ();
{ }
return (static_cast<test_rcs_record_type_one_t*> (rec_p))->get_prev (); case _record_type_two_id:
} {
case _record_type_two_id: return (static_cast<test_rcs_record_type_two_t*> (rec_p))->get_prev ();
{ }
return (static_cast<test_rcs_record_type_two_t*> (rec_p))->get_prev (); default:
} {
default: JERRY_ASSERT (rec_p->get_type () < _first_type_id);
{
JERRY_ASSERT (rec_p->get_type () < _first_type_id);
return rcs_recordset_t::get_prev (rec_p); return rcs_recordset_t::get_prev (rec_p);
}
} }
} }
}
virtual void set_prev (rcs_record_t* rec_p, virtual void set_prev (rcs_record_t* rec_p,
rcs_record_t *prev_rec_p) rcs_record_t *prev_rec_p)
{
switch (rec_p->get_type ())
{ {
switch (rec_p->get_type ()) case _record_type_one_id:
{ {
case _record_type_one_id: return (static_cast<test_rcs_record_type_one_t*> (rec_p))->set_prev (prev_rec_p);
{ }
return (static_cast<test_rcs_record_type_one_t*> (rec_p))->set_prev (prev_rec_p); case _record_type_two_id:
} {
case _record_type_two_id: return (static_cast<test_rcs_record_type_two_t*> (rec_p))->set_prev (prev_rec_p);
{ }
return (static_cast<test_rcs_record_type_two_t*> (rec_p))->set_prev (prev_rec_p); default:
} {
default: JERRY_ASSERT (rec_p->get_type () < _first_type_id);
{
JERRY_ASSERT (rec_p->get_type () < _first_type_id);
return rcs_recordset_t::set_prev (rec_p, prev_rec_p); return rcs_recordset_t::set_prev (rec_p, prev_rec_p);
}
} }
} }
}
virtual size_t get_record_size (rcs_record_t* rec_p) virtual size_t get_record_size (rcs_record_t* rec_p)
{
switch (rec_p->get_type ())
{ {
switch (rec_p->get_type ()) case _record_type_one_id:
{ {
case _record_type_one_id: return (static_cast<test_rcs_record_type_one_t*> (rec_p))->get_size ();
{ }
return (static_cast<test_rcs_record_type_one_t*> (rec_p))->get_size (); case _record_type_two_id:
} {
case _record_type_two_id: return (static_cast<test_rcs_record_type_two_t*> (rec_p))->get_size ();
{ }
return (static_cast<test_rcs_record_type_two_t*> (rec_p))->get_size (); default:
} {
default: JERRY_ASSERT (rec_p->get_type () < _first_type_id);
{
JERRY_ASSERT (rec_p->get_type () < _first_type_id);
return rcs_recordset_t::get_record_size (rec_p); return rcs_recordset_t::get_record_size (rec_p);
}
} }
} }
}
}; };
int int
@@ -243,23 +241,23 @@ main (int __attr_unused___ argc,
{ {
if (rand () % 2) if (rand () % 2)
{ {
assert (type_one_records_number < test_sub_iters); JERRY_ASSERT (type_one_records_number < test_sub_iters);
uint32_t elements_count = ((uint32_t) rand ()) % test_max_type_one_record_elements; uint32_t elements_count = ((uint32_t) rand ()) % test_max_type_one_record_elements;
type_one_record_element_counts[type_one_records_number] = elements_count; type_one_record_element_counts[type_one_records_number] = elements_count;
type_one_records[type_one_records_number] = storage.create_record_type_one (elements_count); type_one_records[type_one_records_number] = storage.create_record_type_one (elements_count);
assert (type_one_records[type_one_records_number] != NULL); JERRY_ASSERT (type_one_records[type_one_records_number] != NULL);
type_one_records_number++; type_one_records_number++;
} }
else else
{ {
assert (type_two_records_number < test_sub_iters); JERRY_ASSERT (type_two_records_number < test_sub_iters);
type_two_records[type_two_records_number] = storage.create_record_type_two (); type_two_records[type_two_records_number] = storage.create_record_type_two ();
assert (type_two_records[type_two_records_number] != NULL); JERRY_ASSERT (type_two_records[type_two_records_number] != NULL);
type_two_records_number++; type_two_records_number++;
} }
@@ -271,13 +269,13 @@ main (int __attr_unused___ argc,
if (type_one_records_number == 0) if (type_one_records_number == 0)
{ {
assert (type_two_records_number != 0); JERRY_ASSERT (type_two_records_number != 0);
free_type_one = false; free_type_one = false;
} }
else if (type_two_records_number == 0) else if (type_two_records_number == 0)
{ {
assert (type_one_records_number != 0); JERRY_ASSERT (type_one_records_number != 0);
free_type_one = true; free_type_one = true;
} }
@@ -288,10 +286,10 @@ main (int __attr_unused___ argc,
if (free_type_one) if (free_type_one)
{ {
assert (type_one_records_number > 0); JERRY_ASSERT (type_one_records_number > 0);
int index_to_free = (rand () % type_one_records_number); int index_to_free = (rand () % type_one_records_number);
assert (index_to_free >= 0 && index_to_free < type_one_records_number); JERRY_ASSERT (index_to_free >= 0 && index_to_free < type_one_records_number);
storage.free_record_type_one (type_one_records[index_to_free]); storage.free_record_type_one (type_one_records[index_to_free]);
@@ -306,10 +304,10 @@ main (int __attr_unused___ argc,
} }
else else
{ {
assert (type_two_records_number > 0); JERRY_ASSERT (type_two_records_number > 0);
int index_to_free = (rand () % type_two_records_number); int index_to_free = (rand () % type_two_records_number);
assert (index_to_free >= 0 && index_to_free < type_two_records_number); JERRY_ASSERT (index_to_free >= 0 && index_to_free < type_two_records_number);
storage.free_record_type_two (type_two_records[index_to_free]); storage.free_record_type_two (type_two_records[index_to_free]);
tools/vera++/scripts/rules/jerry_indentation.tcl
+32 -14
View File
@@ -22,7 +22,9 @@ foreach fileName [getSourceFileNames] {
set is_in_comment "no" set is_in_comment "no"
set is_in_pp_define "no" set is_in_pp_define "no"
set is_in_class "no" set is_in_class "no"
set is_in_template "no"
set parentheses_level 0 set parentheses_level 0
set template_brackets_level 0
foreach token [getTokens $fileName 1 0 -1 -1 {}] { foreach token [getTokens $fileName 1 0 -1 -1 {}] {
set type [lindex $token 3] set type [lindex $token 3]
@@ -36,6 +38,8 @@ foreach fileName [getSourceFileNames] {
set is_in_pp_define "no" set is_in_pp_define "no"
} elseif {$type == "class"} { } elseif {$type == "class"} {
set is_in_class "yes" set is_in_class "yes"
} elseif {$type == "template"} {
set is_in_template "yes"
} elseif {$is_in_class == "yes" && $type == "semicolon" && $indent == 0} { } elseif {$is_in_class == "yes" && $type == "semicolon" && $indent == 0} {
set is_in_class "no" set is_in_class "no"
} elseif {$type == "ccomment"} { } elseif {$type == "ccomment"} {
@@ -52,20 +56,23 @@ foreach fileName [getSourceFileNames] {
incr indent -2 incr indent -2
} }
if {$is_in_pp_define == "no" && $is_in_comment == "no" && $is_in_class == "no" && $parentheses_level == 0} { if {$is_in_pp_define == "no" && $is_in_comment == "no" && $parentheses_level == 0 &&
$is_in_template == "no"} {
set line [getLine $fileName $lineNumber] set line [getLine $fileName $lineNumber]
if {$lineNumber != $lastCheckedLineNumber} { if {$lineNumber != $lastCheckedLineNumber} {
if {[string length $line] == 0} {
}
if {[regexp {^[[:blank:]]*} $line match]} { if {[regexp {^[[:blank:]]*} $line match]} {
set real_indent [string length $match] set real_indent [string length $match]
if {$indent != $real_indent} { if {$indent != $real_indent} {
if {![regexp {^[[:alnum:]_]{1,}:$} $line] || $real_indent != 0} { if {[regexp {^[[:blank:]]*(private:|public:|protected:)} $line]} {
report $fileName $lineNumber "Indentation: $real_indent -> $indent. Line: '$line'" if {$indent != $real_indent + 2} {
} set exp_indent [expr {$indent - 2}]
} report $fileName $lineNumber "Indentation: $real_indent -> $exp_indent. Line: '$line'"
}
} elseif {![regexp {^[[:alnum:]_]{1,}:$} $line] || $real_indent != 0} {
report $fileName $lineNumber "Indentation: $real_indent -> $indent. Line: '$line'"
}
}
} }
} }
@@ -73,7 +80,7 @@ foreach fileName [getSourceFileNames] {
if {$type == "leftbrace"} { if {$type == "leftbrace"} {
if {![regexp {^[[:blank:]]*\{[[:blank:]]*$} $line] if {![regexp {^[[:blank:]]*\{[[:blank:]]*$} $line]
&& ![regexp {[^\{=]=[^\{=]\{.*\},?} $line]} { && ![regexp {[^\{=]=[^\{=]\{.*\},?} $line]} {
report $fileName $lineNumber "Left brace is not the only non-space character in the line: '$line'" report $fileName $lineNumber "Left brace is not the only non-space character in the line: '$line'"
} }
} }
if {$type == "rightbrace"} { if {$type == "rightbrace"} {
@@ -84,11 +91,11 @@ foreach fileName [getSourceFileNames] {
} }
} }
if {$type == "rightbrace"} { if {$type == "rightbrace"} {
if {![regexp {^[[:blank:]]*\}((( [a-z_\(][a-z0-9_\(\)]{0,}){1,})?;| /\*.*\*/| //.*)?$} $line] if {![regexp {^[[:blank:]]*\};?((( [a-z_\(][a-z0-9_\(\)]{0,}){1,})?;| /\*.*\*/| //.*)?$} $line]
&& ![regexp {[^\{=]=[^\{=]\{.*\}[,;]?} $line]} { && ![regexp {[^\{=]=[^\{=]\{.*\}[,;]?} $line]} {
report $fileName $lineNumber "Right brace is not the only non-space character in the line and \ report $fileName $lineNumber "Right brace is not the only non-space character in the line and \
is not single right brace followed by \[a-z0-9_() \] string and single semicolon character: '$line'" is not single right brace followed by \[a-z0-9_() \] string and single semicolon character: '$line'"
} }
} }
} }
@@ -100,6 +107,17 @@ foreach fileName [getSourceFileNames] {
incr parentheses_level -1 incr parentheses_level -1
} }
if {$is_in_template == "yes"} {
if {$type == "less"} {
incr template_brackets_level
} elseif {$type == "greater"} {
incr template_brackets_level -1
if {$template_brackets_level == 0} {
set is_in_template "no"
}
}
}
set lastCheckedLineNumber $lineNumber set lastCheckedLineNumber $lineNumber
} }
} }