You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
197 lines
5.5 KiB
197 lines
5.5 KiB
/**
|
|
* @file combine_fix_mark.h
|
|
*
|
|
* @author Guy Maurel
|
|
* @license GPL v2+
|
|
* extract from combine.cpp
|
|
*/
|
|
|
|
#ifndef COMBINE_FIX_MARK_H_INCLUDED
|
|
#define COMBINE_FIX_MARK_H_INCLUDED
|
|
|
|
#include "ChunkStack.h"
|
|
|
|
|
|
/**
|
|
* Checks to see if the current paren is part of a cast.
|
|
* We already verified that this doesn't follow function, TYPE, IF, FOR,
|
|
* SWITCH, or WHILE and is followed by WORD, TYPE, STRUCT, ENUM, or UNION.
|
|
*
|
|
* @param start Pointer to the open paren
|
|
*/
|
|
void fix_casts(Chunk *start);
|
|
|
|
|
|
/**
|
|
* Simply change any STAR to PTR_TYPE and WORD to TYPE
|
|
*
|
|
* @param start points to the open paren
|
|
*/
|
|
void fix_fcn_def_params(Chunk *start);
|
|
|
|
|
|
/**
|
|
* CT_TYPE_CAST follows this pattern:
|
|
* dynamic_cast<...>(...)
|
|
*
|
|
* Mark everything between the <> as a type and set the paren parent
|
|
*/
|
|
void fix_type_cast(Chunk *start);
|
|
|
|
|
|
/**
|
|
* We are on a typedef.
|
|
* If the next word is not enum/union/struct, then the last word before the
|
|
* next ',' or ';' or '__attribute__' is a type.
|
|
*
|
|
* typedef [type...] [*] type [, [*]type] ;
|
|
* typedef <return type>([*]func)();
|
|
* typedef <return type>([*]func)(params);
|
|
* typedef <return type>(__stdcall *func)(); Bug # 633 MS-specific extension
|
|
* include the config-file "test/config/MS-calling_conventions.cfg"
|
|
* typedef <return type>func(params);
|
|
* typedef <enum/struct/union> [type] [*] type [, [*]type] ;
|
|
* typedef <enum/struct/union> [type] { ... } [*] type [, [*]type] ;
|
|
*/
|
|
void fix_typedef(Chunk *start);
|
|
|
|
|
|
/**
|
|
* We are on the start of a sequence that could be a variable definition
|
|
* - FPAREN_OPEN (parent == CT_FOR)
|
|
* - BRACE_OPEN
|
|
* - SEMICOLON
|
|
*/
|
|
Chunk *fix_variable_definition(Chunk *start);
|
|
|
|
|
|
void mark_cpp_constructor(Chunk *pc);
|
|
|
|
|
|
/**
|
|
* Mark all chunks belonging to a C++ lambda expression
|
|
*
|
|
* @param square_open points to a chunk of type CT_SQUARE_OPEN, and the parent type is
|
|
* assumed to have already been assigned the value CT_CPP_LAMBDA;
|
|
* under this assumption, the function marks all chunks as PCF_IN_LAMBDA
|
|
* until the corresponding closing CT_BRACE_CLOSE (with parent type
|
|
* CT_CPP_LAMBDA) is encountered
|
|
*/
|
|
void mark_cpp_lambda(Chunk *square_open);
|
|
|
|
|
|
/**
|
|
* Marks statement starts in a macro body.
|
|
* REVISIT: this may already be done
|
|
*/
|
|
void mark_define_expressions();
|
|
|
|
|
|
/**
|
|
* Just mark every CT_WORD until a semicolon as CT_SQL_WORD.
|
|
* Adjust the levels if pc is CT_SQL_BEGIN
|
|
*/
|
|
void mark_exec_sql(Chunk *pc);
|
|
|
|
|
|
/**
|
|
* Changes the return type to type and set the parent.
|
|
*
|
|
* @param pc the last chunk of the return type
|
|
* @param parent_type CT_NONE (no change) or the new parent type
|
|
*/
|
|
void mark_function_return_type(Chunk *fname, Chunk *start, E_Token parent_type);
|
|
|
|
|
|
/**
|
|
* We are on a function word. we need to:
|
|
* - find out if this is a call or prototype or implementation
|
|
* - mark return type
|
|
* - mark parameter types
|
|
* - mark brace pair
|
|
*
|
|
* REVISIT:
|
|
* This whole function is a mess.
|
|
* It needs to be reworked to eliminate duplicate logic and determine the
|
|
* function type more directly.
|
|
* 1. Skip to the close paren and see what is after.
|
|
* a. semicolon - function call or function proto
|
|
* b. open brace - function call (ie, list_for_each) or function def
|
|
* c. open paren - function type or chained function call
|
|
* d. qualifier - function def or proto, continue to semicolon or open brace
|
|
* 2. Examine the 'parameters' to see if it can be a proto/def
|
|
* 3. Examine what is before the function name to see if it is a proto or call
|
|
* Constructor/destructor detection should have already been done when the
|
|
* 'class' token was encountered (see mark_class_ctor).
|
|
*/
|
|
void mark_function(Chunk *pc);
|
|
|
|
|
|
/**
|
|
* Process a function type that is not in a typedef.
|
|
* pc points to the first close paren.
|
|
*
|
|
* void (*func)(params);
|
|
* const char * (*func)(params);
|
|
* const char * (^func)(params); -- Objective C
|
|
*
|
|
* @param pc Points to the first closing paren
|
|
*
|
|
* @return whether a function type was processed
|
|
*/
|
|
bool mark_function_type(Chunk *pc);
|
|
|
|
|
|
/**
|
|
* Just hit an assign. Go backwards until we hit an open brace/paren/square or
|
|
* semicolon (TODO: other limiter?) and mark as a LValue.
|
|
*/
|
|
void mark_lvalue(Chunk *pc);
|
|
|
|
|
|
/**
|
|
* Examines the stuff between braces { }.
|
|
* There should only be variable definitions and methods.
|
|
* Skip the methods, as they will get handled elsewhere.
|
|
*/
|
|
void mark_struct_union_body(Chunk *start);
|
|
|
|
|
|
/**
|
|
* We are on a word followed by a angle open which is part of a template.
|
|
* If the angle close is followed by a open paren, then we are on a template
|
|
* function def or a template function call:
|
|
* Vector2<float>(...) [: ...[, ...]] { ... }
|
|
* Or we could be on a variable def if it's followed by a word:
|
|
* Renderer<rgb32> rend;
|
|
*/
|
|
void mark_template_func(Chunk *pc, Chunk *pc_next);
|
|
|
|
|
|
/**
|
|
* We are on the first word of a variable definition.
|
|
* Mark all the variable names with PCF_VAR_1ST and PCF_VAR_DEF as appropriate.
|
|
* Also mark any '*' encountered as a CT_PTR_TYPE.
|
|
* Skip over []. Go until a ';' is hit.
|
|
*
|
|
* Example input:
|
|
* int a = 3, b, c = 2; ## called with 'a'
|
|
* foo_t f = {1, 2, 3}, g = {5, 6, 7}; ## called with 'f'
|
|
* struct {...} *a, *b; ## called with 'a' or '*'
|
|
* myclass a(4);
|
|
*/
|
|
Chunk *mark_variable_definition(Chunk *start);
|
|
|
|
|
|
void mark_variable_stack(ChunkStack &cs, log_sev_t sev);
|
|
|
|
|
|
/**
|
|
* TODO: add doc cmt
|
|
*
|
|
*/
|
|
PcfFlags mark_where_chunk(Chunk *pc, E_Token parent_type, PcfFlags flags);
|
|
|
|
|
|
#endif /* COMBINE_FIX_MARK_H_INCLUDED */
|