echoapi.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 704 行 · 第 1/2 页

                      case_prt( O_FLOW_NOT, ! )
                      case_prt( O_POINTS, @ )
                      case_str( O_GOTO )
                      case_str( O_BIG_GOTO )
                      case_str( O_IF_TRUE )
                      case_str( O_IF_FALSE )
                      case_str( O_INVOKE_LABEL )
                      case_str( O_LABEL )
                      case_str( O_BIG_LABEL )
                      case_str( O_LABEL_RETURN )
                      case_str( O_PROC )
                      case_str( O_PARM_DEF )
                      case_str( O_AUTO_DEF )
                      case_str( O_COMMA )
                      case_str( O_PASS_PROC_PARM )
                      case_str( O_DEFN_PROC_PARM )
                      case_str( O_CALL_PROC_PARM )
                      case_str( O_PRE_GETS )
                      case_str( O_POST_GETS )
                      case_str( O_SIDE_EFFECT )
                      default :
                        EchoAPIString( "O_0" );
                        itoa( op, buffer, 10 );
                        EchoAPIString( buffer );
                        break;
                    }
                    break;
                  }
                  case 'n' : {
                    EchoAPIHandle( (int)va_arg( args, cg_name ), "cg" );
                    break;
                  }
                  case 'P' : {
                    EchoAPIHandle( (int)va_arg( args, patch_handle ), "ph" );
                    break;
                  }
                  case 's' : {
                    cg_sym_handle handle = va_arg( args, cg_sym_handle );
                    EchoAPIString( FEName( handle ) );
                    EchoAPIChar( '[' );
                    itoa( (int)handle, buffer, 16 );
                    EchoAPIString( buffer );
                    EchoAPIChar( ']' );
                    break;
                  }
                  case 'S' : {
                    EchoAPIHandle( (int)va_arg( args, sel_handle ), "sh" );
                    break;
                  }
                  case 'T' : {
                    EchoAPIHandle( (int)va_arg( args, temp_handle ), "th" );
                    break;
                  }
                  case 't' : {
                    cg_type type = (cg_type)va_arg( args, int );
                    switch( type ) {
                      case_str( T_UINT_1 )
                      case_str( T_INT_1 )
                      case_str( T_UINT_2 )
                      case_str( T_INT_2 )
                      case_str( T_UINT_4 )
                      case_str( T_INT_4 )
                      case_str( T_UINT_8 )
                      case_str( T_INT_8 )
                      case_str( T_LONG_POINTER )
                      case_str( T_HUGE_POINTER )
                      case_str( T_NEAR_POINTER )
                      case_str( T_LONG_CODE_PTR )
                      case_str( T_NEAR_CODE_PTR )
                      case_str( T_SINGLE )
                #if defined( BY_C_FRONT_END ) || defined( BY_CPP_FRONT_END )
                      case_str( TY_DOUBLE )
                #else
                      case_str( T_DOUBLE )
                #endif
                      case_str( T_LONG_DOUBLE )
                      case_str( T_UNKNOWN )
                #if defined( BY_C_FRONT_END ) || defined( BY_CPP_FRONT_END )
                      case_str( TY_DEFAULT )
                #else
                      case_str( T_DEFAULT )
                #endif
                      case_str( T_INTEGER )
                #if defined( BY_C_FRONT_END ) || defined( BY_CPP_FRONT_END )
                      case_str( TY_UNSIGNED )
                #else
                      case_str( T_UNSIGNED )
                #endif
                      case_str( T_POINTER )
                      case_str( T_CODE_PTR )
                      case_str( T_BOOLEAN )
                      case_str( T_PROC_PARM )
                      default :
                        EchoAPIString( "T_0" );
                        itoa( type, buffer, 10 );
                        EchoAPIString( buffer );
                        break;
                    }
                    break;
                  }
                  case 'x' : {
                    int val = va_arg( args, int );
                    EchoAPIString( "0x" );
                    itoa( val, buffer, 16 );
                    EchoAPIString( buffer );
                    break;
                  }
                  default : {
                    EchoAPIString( "*** BAD %" );
                    EchoAPIChar( *text );
                    EchoAPIString( " ***" );
                    break;
                  }
                }
            } else {
                EchoAPIChar( *text );
            }
        }
    }
}

cg_name EchoAPICgnameReturn // EchoAPI cg_name RETURN VALUE
    ( cg_name retn )            // - cg_name value
{
    EchoAPI( " -> %n\n", retn );
    return retn;
}

call_handle EchoAPICallHandleReturn // EchoAPI call_handle RETURN VALUE
    ( call_handle retn )            // - call_handle value
{
    EchoAPI( " -> %C\n", retn );
    return retn;
}

cg_type EchoAPICgtypeReturn // EchoAPI cg_type RETURN VALUE
    ( cg_type retn )            // - cg_type value
{
    EchoAPI( " -> %t\n", retn );
    return retn;
}


int EchoAPIHexReturn      // EchoAPI HEXADECIMAL RETURN VALUE
    ( int retn )                // - value
{
    EchoAPI( " -> %x\n", retn );
    return retn;
}


int EchoAPIIntReturn      // EchoAPI DECIMAL RETURN VALUE
    ( int retn )                // - value
{
    EchoAPI( " -> %i\n", retn );
    return retn;
}


select_node *EchoAPISelHandleReturn // EchoAPI sel_handle RETURN VALUE
    ( select_node *retn )         // - sel_handle value
{
    EchoAPI( " -> %S\n", retn );
    return retn;
}


call_handle EchoAPITempHandleReturn // EchoAPI temp_handle RETURN VALUE
    ( temp_handle retn )            // - temp_handle value
{
    EchoAPI( " -> %T\n", retn );
    return retn;
}


void handleExists           // VERIFY EXISTING HANDLE
    ( handle_type hdltype
    , use_info *useinfo )              // - the handle
{
    if( useinfo == NULL ) {
        handleMsg( hdltype, "handle does not exist" );
    }
    if( useinfo->hdltype != hdltype ) {
        ErrExpectFound( hdltype, useinfo->hdltype );
    }
}

// USE HANDLE EXACTLY ONCE

void handleUseOnce( handle_type hdltype, use_info *useinfo )
{
    handleExists( hdltype, useinfo );
    if( useinfo->used ) {
        handleMsg( hdltype, "handle already used" );
    } else {
        useinfo->used = TRUE;
    }
}

static void handleSetup( handle_type hdltype, use_info *useinfo )
{
    useinfo->hdltype = hdltype;
    useinfo->used = FALSE;
}

void handleAddReuse( handle_type hdltype, use_info *useinfo )
{
    if( useinfo->hdltype == hdltype ) {
        if( useinfo->used ) {
            handleSetup( hdltype, useinfo );
        } else {
            handleMsg( hdltype, "Handle already exists" );
        }
    } else {
        handleSetup( hdltype, useinfo );
    }
}

void handleAdd( handle_type hdltype, use_info *useinfo )
{
    if( useinfo->hdltype != NO_HANDLE || useinfo->used ) {
        handleMsg( hdltype, "Handle already exists" );
    } else {
        handleSetup( hdltype, useinfo );
    }
}

void hdlAddUnary         // ADD A HANDLE AFTER A UNARY OPERATION
    ( handle_type hdltype       // - the handle type
    , tn handle                 // - the handle
    , tn old )                  // - handle operated upon by unary oper'n
{
    old = old;
    hdlAddReuse( hdltype, handle );
}

void hdlAddBinary        // ADD A HANDLE AFTER A BINARY OPERATION
    ( handle_type hdltype
    , tn handle                // - the handle
    , tn old_l                 // - handle operated upon by unary oper'n
    , tn old_r )               // - handle operated upon by unary oper'n
{
    old_l = old_l;
    old_r = old_r;
    hdlAddReuse( hdltype, handle );
}

void hdlAddTernary       // ADD A HANDLE AFTER A TERNARY OPERATION
    ( handle_type hdltype
    , tn handle                // - the handle
    , tn old_t                 // - handle operated upon by unary oper'n
    , tn old_l                 // - handle operated upon by unary oper'n
    , tn old_r )               // - handle operated upon by unary oper'n
{
    old_t = old_t;
    old_l = old_l;
    old_r = old_r;
    hdlAddReuse( hdltype, handle );
}

void hdlAllUsed          // VERIFY ALL HANDLES IN RING HAVE BEEN USED
    ( handle_type hdltype )
{
    // check to ensure that all nodes of type hdltype are used LMW
    // create linked list of node when creating, and check all are empty
    // after tree is burned
    hdltype = hdltype;
}

// Callback stuff

typedef struct cb_name CB_NAME;
struct cb_name                  // CB_NAME -- call back name
{   CB_NAME* next;              // - next in ring
    char const* name;           // - name
    void (*rtn)( void* );       // - rtn address
};
static CB_NAME* callback_names; // call-back names

// CALL-BACK NAMES

void CgEchoAPICbName                // REGISTER A CALL-BACK NAME
    ( void (*rtn)( void* )      // - rtn address
    , char const* name )        // - rtn name
{
    CB_NAME* cbn;

    _Alloc( cbn, sizeof( CB_NAME ) ); // Free'd in DbgFini
    cbn->rtn = rtn;
    cbn->name = name;
    // insert
    cbn->next = callback_names;
    callback_names = cbn;
}

void EchoAPIInit( void )
{
    callback_names = NULL;
    EchoAPIRedirect();
}

// remove callback name from list

void EchoAPIFini( void )
{
    CB_NAME *cbn, *next;               // - call back name

    for( cbn = callback_names; cbn; cbn = next ) {
        next = cbn->next;
        _Free( cbn, sizeof( CB_NAME ) );
    }
    callback_names = NULL;
    EchoAPIUnredirect();
}

static char* callBackName       // MAKE CALL-BACK NAME FOR PRINTING
    ( void (*rtn)( void* )      // - rtn address
    , char * buffer )           // - buffer
{
    CB_NAME* cbn;               // - call back name
    char const* name = NULL;    // - name to be used

    for( cbn = callback_names; cbn; cbn = cbn->next ) {
        if( rtn == cbn->rtn ) {
            name = cbn->name;
            break;
        }
    }
    if( name == NULL ) {
        sprintf( buffer, "%x", rtn );
    } else {
        sprintf( buffer, "%x:%s", rtn, name );
    }
    return buffer;
}


void EchoAPICallBack(               // CALL-BACK SUPPORT
    tn node
  , cg_callback rtn
  , callback_handle param
  , char *start_end )            // - call-back entry
{
    char buffer[64];

    EchoAPI( "\n*** CALL BACK[%x] to %c(%x) "
          , node
          , callBackName( rtn, buffer )
          , param );
    EchoAPI(start_end);
}