diff --git a/jerry-core/rcs/rcs-chunked-list.h b/jerry-core/rcs/rcs-chunked-list.h index 3365bd78d0..18f4a0d883 100644 --- a/jerry-core/rcs/rcs-chunked-list.h +++ b/jerry-core/rcs/rcs-chunked-list.h @@ -36,46 +36,46 @@ */ class rcs_chunked_list_t { - public: - /** - * List node - */ - typedef struct - { - mem_cpointer_t prev_cp; /**< prev list's node */ - mem_cpointer_t next_cp; /**< next list's node */ - } node_t; +public: + /** + * List node + */ + typedef struct + { + mem_cpointer_t prev_cp; /**< prev list's node */ + mem_cpointer_t next_cp; /**< next list's node */ + } node_t; - void init (void); - void free (void); + void init (void); + void free (void); - node_t *get_first (void) const; - node_t *get_last (void) const; + node_t *get_first (void) const; + node_t *get_last (void) const; - node_t *get_prev (node_t *node_p) const; - node_t *get_next (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 *append_new (void); - node_t *insert_new (node_t *after_p); + node_t *append_new (void); + 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; - uint8_t* get_data_space (node_t *node_p) const; + node_t *get_node_from_pointer (void *ptr) 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: - void set_prev (node_t *node_p, node_t *prev_node_p); - void set_next (node_t *node_p, node_t *next_node_p); +private: + void set_prev (node_t *node_p, node_t *prev_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_node_is_correct (const node_t *node_p) const; + void assert_list_is_correct (void) const; + void assert_node_is_correct (const node_t *node_p) const; - node_t* head_p; /**< head node of list */ - node_t* tail_p; /**< tail node of list */ + node_t* head_p; /**< head node of list */ + node_t* tail_p; /**< tail node of list */ }; /** diff --git a/jerry-core/rcs/rcs-recordset.h b/jerry-core/rcs/rcs-recordset.h index 5c35dbd8cc..2e60358cbb 100644 --- a/jerry-core/rcs/rcs-recordset.h +++ b/jerry-core/rcs/rcs-recordset.h @@ -57,151 +57,152 @@ */ 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: - /* Constructor */ - void init (void) - { - _chunk_list.init (); - - JERRY_ASSERT (_chunk_list.get_data_space_size () % RCS_DYN_STORAGE_LENGTH_UNIT == 0); - } /* init */ + typedef uint8_t type_t; - /* Destructor */ - void finalize (void) - { - _chunk_list.free (); - } /* finalize */ + type_t get_type (void) const; + void set_type (type_t type); /** - * Record 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. */ - class record_t + struct cpointer_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; + 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 */ + 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 */ + 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; + } value; + uint16_t packed_value; + }; + + static cpointer_t compress (record_t* pointer_p); + static record_t* decompress (cpointer_t pointer_cp); }; - private: - friend class rcs_record_iterator_t; + private: /** - * Type identifier for free record + * Offset of 'type' field, in bits */ - static const record_t::type_t _free_record_type_id = 0; + static const uint32_t _type_field_pos = 0u; /** - * Chunked list used for memory allocation + * Width of 'type' field, in bits */ - rcs_chunked_list_t _chunk_list; - - void alloc_record_in_place (record_t* place_p, - size_t free_size, - record_t* next_record_p); + static const uint32_t _type_field_width = 4u; - 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; + 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); /** - * Allocate new record of specified type - * - * @return pointer to the new record + * Offset of a derived record's fields, in bits */ - 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); + 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); - size_t size = T::size (size_args...); + 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; - record_t *prev_rec_p; - T* rec_p = static_cast (alloc_space_for_record (size, &prev_rec_p)); + /** + * 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); - rec_p->set_type (type); - rec_p->set_size (size); - rec_p->set_prev (prev_rec_p); + size_t size = T::size (size_args...); - assert_state_is_correct (); + record_t *prev_rec_p; + T* rec_p = static_cast (alloc_space_for_record (size, &prev_rec_p)); - return rec_p; - } /* alloc_record */ + rec_p->set_type (type); + rec_p->set_size (size); + rec_p->set_prev (prev_rec_p); - record_t* alloc_space_for_record (size_t bytes, record_t** out_prev_rec_p); - void free_record (record_t* record_p); + assert_state_is_correct (); - record_t* get_first (void); + return rec_p; + } /* alloc_record */ - 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); + record_t* alloc_space_for_record (size_t bytes, record_t** out_prev_rec_p); + void free_record (record_t* record_p); - virtual size_t get_record_size (record_t* rec_p); + record_t* get_first (void); - void assert_state_is_correct (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 */ /** @@ -219,19 +220,19 @@ typedef rcs_record_t::cpointer_t rcs_cpointer_t; */ class rcs_record_iterator_t { - public: - rcs_record_iterator_t (rcs_record_t* rec_p); - rcs_record_iterator_t (rcs_cpointer_t rec_ext_cp); +public: + rcs_record_iterator_t (rcs_record_t* rec_p); + rcs_record_iterator_t (rcs_cpointer_t rec_ext_cp); - protected: - template T read (void); - template void write (T value); +protected: + template T read (void); + template void write (T value); - private: - rcs_record_t* _record_start_p; /**< start of current record */ - uint8_t* _current_pos_p; /**< pointer to current offset in current record */ +private: + rcs_record_t* _record_start_p; /**< start of 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 */ /** @@ -239,32 +240,32 @@ class rcs_record_iterator_t */ class rcs_free_record_t : public rcs_record_t { - public: - size_t get_size (void) const; - void set_size (size_t size); - - rcs_record_t* get_prev (void) const; - void set_prev (rcs_record_t* prev_rec_p); - private: - /** - * Offset of 'length' field, in bits - */ - static const uint32_t _length_field_pos = _fields_offset_begin; - - /** - * Width of 'length' field, in bits - */ - static const uint32_t _length_field_width = 12u; - - /** - * Offset of 'previous record' field, in bits - */ - static const uint32_t _prev_field_pos = _length_field_pos + _length_field_width; - - /** - * Width of 'previous record' field, in bits - */ - static const uint32_t _prev_field_width = rcs_cpointer_t::bit_field_width; +public: + size_t get_size (void) const; + void set_size (size_t size); + + rcs_record_t* get_prev (void) const; + void set_prev (rcs_record_t* prev_rec_p); +private: + /** + * Offset of 'length' field, in bits + */ + static const uint32_t _length_field_pos = _fields_offset_begin; + + /** + * Width of 'length' field, in bits + */ + static const uint32_t _length_field_width = 12u; + + /** + * Offset of 'previous record' field, in bits + */ + static const uint32_t _prev_field_pos = _length_field_pos + _length_field_width; + + /** + * Width of 'previous record' field, in bits + */ + static const uint32_t _prev_field_width = rcs_cpointer_t::bit_field_width; }; /** diff --git a/tests/unit/test_recordset.cpp b/tests/unit/test_recordset.cpp index 3994d489ec..a3dcbf3676 100644 --- a/tests/unit/test_recordset.cpp +++ b/tests/unit/test_recordset.cpp @@ -13,8 +13,6 @@ * limitations under the License. */ -#include - #include "jrt.h" #include "mem-allocator.h" #include "rcs-recordset.h" @@ -45,175 +43,175 @@ extern "C" class test_rcs_record_type_one_t : public rcs_record_t { - public: - static size_t size (uint32_t elements_count) - { - return JERRY_ALIGNUP (header_size + element_size * elements_count, - RCS_DYN_STORAGE_LENGTH_UNIT); - } +public: + static size_t size (uint32_t elements_count) + { + return JERRY_ALIGNUP (header_size + element_size * elements_count, + RCS_DYN_STORAGE_LENGTH_UNIT); + } - size_t get_size () const - { - return get_field (length_field_pos, length_field_width) * RCS_DYN_STORAGE_LENGTH_UNIT; - } + size_t get_size () const + { + return get_field (length_field_pos, length_field_width) * RCS_DYN_STORAGE_LENGTH_UNIT; + } - void set_size (size_t size) - { - JERRY_ASSERT (JERRY_ALIGNUP (size, RCS_DYN_STORAGE_ALIGNMENT) == size); + void set_size (size_t 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 - { - return get_pointer (prev_field_pos, prev_field_width); - } + rcs_record_t* get_prev () const + { + return get_pointer (prev_field_pos, prev_field_width); + } - void set_prev (rcs_record_t* prev_rec_p) - { - set_pointer (prev_field_pos, prev_field_width, prev_rec_p); - } + void set_prev (rcs_record_t* prev_rec_p) + { + set_pointer (prev_field_pos, prev_field_width, prev_rec_p); + } - private: - static const uint32_t length_field_pos = _fields_offset_begin; - static const uint32_t length_field_width = 12u; +private: + static const uint32_t length_field_pos = _fields_offset_begin; + 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_width = rcs_cpointer_t::bit_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 size_t header_size = 2 * RCS_DYN_STORAGE_LENGTH_UNIT; - static const size_t element_size = sizeof (uint16_t); + static const size_t header_size = 2 * RCS_DYN_STORAGE_LENGTH_UNIT; + static const size_t element_size = sizeof (uint16_t); }; class test_rcs_record_type_two_t : public rcs_record_t { - public: - static size_t size (void) - { - return JERRY_ALIGNUP (header_size, RCS_DYN_STORAGE_LENGTH_UNIT); - } +public: + static size_t size (void) + { + return JERRY_ALIGNUP (header_size, RCS_DYN_STORAGE_LENGTH_UNIT); + } - size_t get_size () const - { - return size (); - } + size_t get_size () const + { + return size (); + } - void set_size (size_t size) - { - JERRY_ASSERT (size == get_size ()); - } + void set_size (size_t size) + { + JERRY_ASSERT (size == get_size ()); + } - rcs_record_t* get_prev () const - { - return get_pointer (prev_field_pos, prev_field_width); - } + rcs_record_t* get_prev () const + { + return get_pointer (prev_field_pos, prev_field_width); + } - void set_prev (rcs_record_t* prev_rec_p) - { - set_pointer (prev_field_pos, prev_field_width, prev_rec_p); - } + void set_prev (rcs_record_t* prev_rec_p) + { + set_pointer (prev_field_pos, prev_field_width, prev_rec_p); + } - private: - static const uint32_t prev_field_pos = _fields_offset_begin; - static const uint32_t prev_field_width = rcs_cpointer_t::bit_field_width; +private: + 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 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 { - public: - test_rcs_record_type_one_t* - create_record_type_one (uint32_t elements_count) - { - return alloc_record (_record_type_one_id, - elements_count); - } +public: + test_rcs_record_type_one_t* + create_record_type_one (uint32_t elements_count) + { + return alloc_record (_record_type_one_id, + elements_count); + } - void - free_record_type_one (test_rcs_record_type_one_t* rec_p) - { - free_record (rec_p); - } + void + free_record_type_one (test_rcs_record_type_one_t* rec_p) + { + free_record (rec_p); + } + + test_rcs_record_type_two_t* + create_record_type_two (void) + { + return alloc_record (_record_type_two_id); + } - test_rcs_record_type_two_t* - create_record_type_two (void) + void + free_record_type_two (test_rcs_record_type_two_t* rec_p) + { + free_record (rec_p); + } +private: + static const int _record_type_one_id = _first_type_id + 0; + static const int _record_type_two_id = _first_type_id + 1; + + virtual rcs_record_t* get_prev (rcs_record_t* rec_p) + { + switch (rec_p->get_type ()) + { + case _record_type_one_id: { - return alloc_record (_record_type_two_id); + return (static_cast (rec_p))->get_prev (); } - - void - free_record_type_two (test_rcs_record_type_two_t* rec_p) + case _record_type_two_id: { - free_record (rec_p); + return (static_cast (rec_p))->get_prev (); } - private: - static const int _record_type_one_id = _first_type_id + 0; - static const int _record_type_two_id = _first_type_id + 1; - - virtual rcs_record_t* get_prev (rcs_record_t* rec_p) - { - switch (rec_p->get_type ()) + default: { - case _record_type_one_id: - { - return (static_cast (rec_p))->get_prev (); - } - case _record_type_two_id: - { - return (static_cast (rec_p))->get_prev (); - } - 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, - rcs_record_t *prev_rec_p) + virtual void set_prev (rcs_record_t* 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 (rec_p))->set_prev (prev_rec_p); - } - case _record_type_two_id: - { - return (static_cast (rec_p))->set_prev (prev_rec_p); - } - default: - { - JERRY_ASSERT (rec_p->get_type () < _first_type_id); + return (static_cast (rec_p))->set_prev (prev_rec_p); + } + case _record_type_two_id: + { + return (static_cast (rec_p))->set_prev (prev_rec_p); + } + default: + { + 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 (rec_p))->get_size (); - } - case _record_type_two_id: - { - return (static_cast (rec_p))->get_size (); - } - default: - { - JERRY_ASSERT (rec_p->get_type () < _first_type_id); + return (static_cast (rec_p))->get_size (); + } + case _record_type_two_id: + { + return (static_cast (rec_p))->get_size (); + } + default: + { + 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 @@ -243,23 +241,23 @@ main (int __attr_unused___ argc, { 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; 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); - assert (type_one_records[type_one_records_number] != NULL); + JERRY_ASSERT (type_one_records[type_one_records_number] != NULL); type_one_records_number++; } 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 (); - assert (type_two_records[type_two_records_number] != NULL); + JERRY_ASSERT (type_two_records[type_two_records_number] != NULL); type_two_records_number++; } @@ -271,13 +269,13 @@ main (int __attr_unused___ argc, if (type_one_records_number == 0) { - assert (type_two_records_number != 0); + JERRY_ASSERT (type_two_records_number != 0); free_type_one = false; } else if (type_two_records_number == 0) { - assert (type_one_records_number != 0); + JERRY_ASSERT (type_one_records_number != 0); free_type_one = true; } @@ -288,10 +286,10 @@ main (int __attr_unused___ argc, 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); - 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]); @@ -306,10 +304,10 @@ main (int __attr_unused___ argc, } else { - assert (type_two_records_number > 0); + JERRY_ASSERT (type_two_records_number > 0); 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]); diff --git a/tools/vera++/scripts/rules/jerry_indentation.tcl b/tools/vera++/scripts/rules/jerry_indentation.tcl index 96a60fd379..6608702d64 100644 --- a/tools/vera++/scripts/rules/jerry_indentation.tcl +++ b/tools/vera++/scripts/rules/jerry_indentation.tcl @@ -22,7 +22,9 @@ foreach fileName [getSourceFileNames] { set is_in_comment "no" set is_in_pp_define "no" set is_in_class "no" + set is_in_template "no" set parentheses_level 0 + set template_brackets_level 0 foreach token [getTokens $fileName 1 0 -1 -1 {}] { set type [lindex $token 3] @@ -36,6 +38,8 @@ foreach fileName [getSourceFileNames] { set is_in_pp_define "no" } elseif {$type == "class"} { set is_in_class "yes" + } elseif {$type == "template"} { + set is_in_template "yes" } elseif {$is_in_class == "yes" && $type == "semicolon" && $indent == 0} { set is_in_class "no" } elseif {$type == "ccomment"} { @@ -52,20 +56,23 @@ foreach fileName [getSourceFileNames] { 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] if {$lineNumber != $lastCheckedLineNumber} { - if {[string length $line] == 0} { - } - if {[regexp {^[[:blank:]]*} $line match]} { set real_indent [string length $match] - if {$indent != $real_indent} { - if {![regexp {^[[:alnum:]_]{1,}:$} $line] || $real_indent != 0} { - report $fileName $lineNumber "Indentation: $real_indent -> $indent. Line: '$line'" - } - } + if {$indent != $real_indent} { + if {[regexp {^[[:blank:]]*(private:|public:|protected:)} $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 {![regexp {^[[:blank:]]*\{[[:blank:]]*$} $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"} { @@ -84,11 +91,11 @@ foreach fileName [getSourceFileNames] { } } if {$type == "rightbrace"} { - if {![regexp {^[[:blank:]]*\}((( [a-z_\(][a-z0-9_\(\)]{0,}){1,})?;| /\*.*\*/| //.*)?$} $line] - && ![regexp {[^\{=]=[^\{=]\{.*\}[,;]?} $line]} { + if {![regexp {^[[:blank:]]*\};?((( [a-z_\(][a-z0-9_\(\)]{0,}){1,})?;| /\*.*\*/| //.*)?$} $line] + && ![regexp {[^\{=]=[^\{=]\{.*\}[,;]?} $line]} { 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 } + 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 } }