コード例 #1
0
ファイル: keysym.cpp プロジェクト: Ukusbobra/open-watcom-v2
KeySymbol::~KeySymbol()
//---------------------
{
    WBRFree( _nameProg );
    WBRFree( _contClassProg );
    WBRFree( _contFunctionProg );
    delete _fileFilter;
}
コード例 #2
0
ファイル: gtfunc.cpp プロジェクト: Azarien/open-watcom-v2
TreeFuncNode::TreeFuncNode( TreeWindow * prt, dr_sym_type stp,
                            drmem_hdl drhdl, Module * mod, char * nm,
                            TreeCycleList * flatNode, TreeRefList * flatRef )
                :TreeCycleNode(prt, flatNode, flatRef )
                ,_symType(stp)
                ,_drhandle(drhdl)
                ,_module(mod)
                ,_name(nm)
                ,_decName(NULL)
//------------------------------------------------------------
{
    drmem_hdl   container;
    char *      name;
    String      accum;

    container = DRGetContaining( drhdl );
    if( container != DRMEM_HDL_NULL ) {
        accum = strrev( _name );
        strrev( _name );

        while( container != DRMEM_HDL_NULL ) {
            Symbol contSym( drhdl, NULL, mod, DRGetName( container ) );
            name = WBRStrDup( contSym.name() );
            accum += "::";
            accum += strrev( name );
            WBRFree( name );

            container = DRGetContaining( container );
        }

        _decName = WBRStrDup( (const char *)accum );
        strrev( _decName );
    }
}
コード例 #3
0
ファイル: classlat.cpp プロジェクト: Ukusbobra/open-watcom-v2
static int ClassLattice::deriveHook( dr_sym_type, dr_handle handle,
                                     char * name, dr_handle inheritHandle,
                                     void * obj )
//-------------------------------------------------------------------------
{
    ClassLattice *   addnode;
    dr_access        effAccess;
    dr_access        access;
    dr_virtuality    virtuality;
    ClassLattice *   me = (ClassLattice *) obj;

    access = DRGetAccess( inheritHandle );
    virtuality = DRGetVirtuality( inheritHandle );

    if( access > me->_effAccess ) {
        effAccess = access;
    } else {
        effAccess = me->_effAccess;
    }

    addnode = me->joinTo( handle, virtuality, effAccess, me->_level + 1 );

    if( addnode != NULL ) {
        WBRFree( name );
    } else {
        addnode = me->newLattice( handle, me->_module, name, me->_flatClasses,
                                  access, (dr_virtuality) VIRT_NOT_SET,
                                  me->_level + 1 );
    }

    DerivationPtr * ptr = me->ClassLattice::newPtr( addnode, access, virtuality );
    me->_deriveds.add( ptr );

    return TRUE;
}
コード例 #4
0
ファイル: classlat.cpp プロジェクト: Ukusbobra/open-watcom-v2
static int ClassLattice::baseHook( dr_sym_type, dr_handle handle, char * name,
                                   dr_handle inheritHandle, void * obj )
//----------------------------------------------------------------------------
{
    dr_access        access;
    dr_access        effAccess;
    dr_virtuality    virtuality;
    ClassLattice *   addnode = NULL;
    ClassLattice *   me = (ClassLattice *) obj;

    access = DRGetAccess( inheritHandle );
    virtuality = DRGetVirtuality( inheritHandle );

    if( access > me->_effAccess ) {
        effAccess = access;
    } else {
        effAccess = me->_effAccess;
    }

    addnode = me->joinTo( handle, virtuality, effAccess, me->_level - 1 );

    if( addnode != NULL ) {
        WBRFree( name );
    } else {
        // NYI - _module isn't necessarily what we want it to be!
        addnode = me->newLattice( handle, me->_module, name, me->_flatClasses,
                                  effAccess, virtuality, me->_level - 1 );
    }

    DerivationPtr * ptr = me->newPtr( addnode, access, virtuality );

    me->_bases.add( ptr );

    return TRUE;
}
コード例 #5
0
ファイル: module.cpp プロジェクト: Azarien/open-watcom-v2
static bool searchHook( dr_sym_context * symctxt, void *data )
//------------------------------------------------------------
{
    FindSymData * info;
    bool          accept;
    Symbol *      sym;

    info = (FindSymData *) data;
    if( symctxt->name == NULL ) {
        symctxt->name = DRGetName( symctxt->handle );
    }
    accept = info->keysym->matches( symctxt );

    if( accept ) {
        if( info->numItems == 0 ) {
            WBRFree( symctxt->name );
            symctxt->name = NULL;
            info->context = new SearchContext( *symctxt->context );
            return false;   // <----- early return -- stop search
        }

        if( info->numItems > 0 ) {
            info->numItems -= 1;
        }

        sym = Symbol::defineSymbol( symctxt->type, symctxt->handle,
                                    symctxt->context->classhdl,
                                    info->call_module,
                                    symctxt->name );
        info->data->add( sym );

#if DEBUG
        if( !(info->data->count() % 10) ) {
            WString stat;
            stat.printf( "Loading - %d found", info->data->count() );
            browseTop->statusText( stat.gets() );
        }
#endif
    } else {
        WBRFree( symctxt->name );
    }

    return true;    // continue searching
}
コード例 #6
0
ファイル: keysym.cpp プロジェクト: Ukusbobra/open-watcom-v2
void KeySymbol::setSearchString( String & str, void ** prog,
                                 const char * name )
//------------------------------------------------------------
{
    WBRFree( *prog );   // free existing program
    str = name;         // assign to the string

    try {
        *prog = WBRRegComp( name );
    } catch( CauseOfDeath cause ) {
        IdentifyAssassin( cause );
    }
}
コード例 #7
0
ファイル: classlat.cpp プロジェクト: Ukusbobra/open-watcom-v2
ClassLattice::~ClassLattice( void )
//---------------------------------
{
    int     i;

    WBRFree( _name );
    for( i = _bases.count(); i > 0; i -= 1 ) {
        delete _bases[ i - 1 ];
    }
    _bases.reset();
    for( i = _deriveds.count(); i > 0; i -= 1 ) {
        delete _deriveds[ i - 1 ];
    }
    _deriveds.reset();

}
コード例 #8
0
ファイル: module.cpp プロジェクト: Azarien/open-watcom-v2
static bool referenceHook( drmem_hdl, dr_ref_info * refinfo, char * name,
                           void * info )
//-----------------------------------------------------------------------
{
    Reference * ref;
    WVList *    list = (WVList *) info;

    for( int i = 0; i < list->count(); i++ ) {
        ref = (Reference *) (*list)[i];
        if( ref->line() == refinfo->line && ref->column() == refinfo->column
                && strcmp( ref->sourceFile(), refinfo->file ) == 0 ) {
            WBRFree( name );
            return true;
        }
    }
    list->add( new Reference( refinfo, name ) );
    return true;    // keep going
}
コード例 #9
0
static bool FunctionSym::callHook( dr_handle, dr_ref_info * ref, char * name,
                                   void * info )
//---------------------------------------------------------------------------
{
    Symbol *         sym;
    callSearchData * data = (callSearchData *) info;
    dr_handle        other;
    dr_sym_type      stype;

    other = ref->dependent;
    stype = DRGetSymType( other );
    if( stype == DR_SYM_FUNCTION ) {
        sym = Symbol::defineSymbol(stype, other, DR_HANDLE_NUL, data->me->getModule(),name);
        data->list->add( sym );
    } else {
        WBRFree( name );
    }
    return TRUE;    // continue
}
コード例 #10
0
ファイル: module.cpp プロジェクト: Azarien/open-watcom-v2
static bool refSymHook( drmem_hdl drhdl, dr_ref_info *, char * name,
                        void * info )
//-------------------------------------------------------------------
{
    RefSymData *data = (RefSymData *) info;
    dr_sym_type stype;
    Symbol *    sym;
    int         i;

    for( i = 0; i < data->list->count(); i += 1 ) {
        if( ((Symbol *)(*data->list)[ i ])->getHandle() == drhdl ) {
            WBRFree( name );
            return true;        // <---- early return
        }
    }

    stype = DRGetSymType( drhdl );
    sym = Symbol::defineSymbol( stype, drhdl, DRMEM_HDL_NULL, data->me, name );
    data->list->add( sym );

    return true;    // continue
}
コード例 #11
0
ファイル: opscan.cpp プロジェクト: Azarien/open-watcom-v2
bool Scanner::error( const char * err )
/*************************************/
{
    WString msg;
    WString title;
    char *  name = _scanStream->name();
    msgRetType ret;

    msg.printf( "%s near '%s'\n\nContinue?", err, _buffer );
    title.printf( "Syntax error in %s", name );

    ret = WMessageDialog::message( browseTop, MsgError, MsgOkCancel,
                                    msg, title );

    WBRFree( name );

    if( ret == MsgRetCancel ) {
        return true;
    } else {
        return false;
    }
}
コード例 #12
0
ファイル: dtvclass.cpp プロジェクト: ABratovic/open-watcom-v2
void DTViewClass::addDescriptions()
//---------------------------------
// add the non-symbol lines
{
    int             i;
    ClassMember *   mem;
    dr_access       prevAccess = (dr_access) 0;
    dr_handle       prevParent = _symbol->getHandle();
    char *          tmpName;
    WCPtrOrderedVector<ClassMember> desc;

    for( i = 0; i < _members->entries(); i += 1 ) {
        mem  = (*_members)[ i ];
        if( mem->_parent != prevParent ) {
            prevAccess = (dr_access) 0;
            prevParent = mem->_parent;
            if( mem->_parent ) {
                tmpName = DRGetName( mem->_parent );
            } else {
                tmpName = NULL;
            }
            desc.append( new ClassMember( mem->_parent, (dr_access) 0,
                                tmpName ) );
            WBRFree( tmpName );
        }
        if( mem->_access != prevAccess ) {
            prevAccess = mem->_access;
            desc.append( new ClassMember( mem->_parent, mem->_access,
                                AccessStr[ mem->_access ] ) );
        }
    }

    for( i = 0; i < desc.entries(); i += 1 ) {
        _members->insert( desc[ i ] );
    }

    desc.clear();       // don't own elements, so don't destroy
}
コード例 #13
0
ファイル: keysym.cpp プロジェクト: Ukusbobra/open-watcom-v2
bool KeySymbol::matches( dr_sym_context * ctxt )
//----------------------------------------------
{
    bool   accept;
    char * container;

    if( !(SymTypeConvert[ ctxt->type ] & _searchFor) ) {
        return( FALSE );
    }

    if( !_anonymous ) {
        if( ctxt->name == NULL || *ctxt->name == 0 ) {
            return( FALSE );
        }
    }

    if( !_artificial ) {
        if( DRIsArtificial( ctxt->handle ) ) {
            return( FALSE );
        }
    }

    if( !_declaration ) {
        if( !DRIsSymDefined( ctxt->handle ) ) {
            return( FALSE );
        }
    }

    if( _nameProg && ctxt->name ) {
        if( ctxt->name ) {
            if( !RegExec( (regexp *) _nameProg, ctxt->name, TRUE ) ) {
                return( FALSE );
            }
        } else {
            if( !RegExec( (regexp *) _nameProg, "", TRUE ) ) {
                return( FALSE );
            }
        }
    }

    if( _contClassProg ) {
        if(  ctxt->context->classhdl ) {
            container = DRGetName( ctxt->context->classhdl );
            if( container ) {
                accept = (bool) RegExec( (regexp *) _contClassProg,
                                         container, TRUE );
                WBRFree( container );
                if( !accept ) {
                    return( FALSE );
                }
            } else {
                if( !RegExec( (regexp *) _contClassProg, "", TRUE ) ) {
                    return( FALSE );
                }
            }
        } else {
            return( FALSE );    // not local to anything
        }
    }

    if( _contFunctionProg ) {
        if( ctxt->context->functionhdl ) {
            container = DRGetName( ctxt->context->functionhdl );
            if( container ) {
                accept = (bool) RegExec( (regexp *) _contFunctionProg,
                                         container, TRUE );
                WBRFree( container );
                if( !accept ) {
                    return( FALSE );
                }
            } else {
                if( !RegExec( (regexp *) _contFunctionProg, "", TRUE ) ) {
                    return( FALSE );
                }
            }
        } else {
            return( FALSE );    // not local to anything
        }
    }

    if( !_fileFilter->matches( ctxt->handle ) ) {
        return FALSE;
    }

    return( TRUE );
}
コード例 #14
0
ファイル: gtfunc.cpp プロジェクト: Azarien/open-watcom-v2
bool TreeFuncNode::TreeFuncHook( drmem_hdl owner, dr_ref_info * ref,
                                 char* ownerName, void * info )
//------------------------------------------------------------------
// this function really needs to be split up
{
    int             parentIndex;
    int             parentRoot;
    TreeFuncNode *  parent = NULL;
    int             childIndex;
    int             childRoot;
    TreeFuncNode *  child = NULL;
    FuncSearchData* data = (FuncSearchData *) info;
    char *          depName;
    bool            accept;

    #if DEBUG
    data->funcsFound += 1;

    if( !(data->funcsFound % 10) ) {
        WString stat;
        stat.printf( "Loading - %d found", data->funcsFound );
        browseTop->statusText( stat.gets() );
    }
    #endif

    // find if the symbol matches the filter

    depName = DRGetName( ref->dependent );
    accept = data->key->matches( ref->dependent, depName );
    WBRFree( depName ); // OPTIMIZE -- could use this later

    if( !accept ) {
        return true;    // <---- early return -- discard symbol, keep looking
    }


    for( int i = data->roots->count(); i > 0; i -= 1 ) {
        TreeFuncNode * rt = (TreeFuncNode*) (*data->roots)[ i - 1 ];
        parentIndex = rt->findNode( owner );
        if( !parent ) {
            if( parentIndex >= 0 ) {
                parent = (TreeFuncNode *)(*rt->_flatNodes)[ parentIndex ];
                parentRoot = i - 1;
            }
        }

        if( !child ) {
            childIndex = rt->findNode( ref->dependent );
            if( childIndex >= 0 ) {
                child = (TreeFuncNode *)(*rt->_flatNodes)[ childIndex ];
                childRoot = i - 1;
            }
        }

        if( child != NULL && parent != NULL ) {
            break;
        }
    }

    if( child != NULL && parent != NULL ) {
        WBRFree( ownerName );

        if( parentRoot == childRoot ) {
            int prtIdx = child->findParent( parent );
            if( prtIdx < 0 ) {
                if( ref->dependent == owner ) {     // direct recursion -- a->a
                    bool inReferences = false;

                    for( int refIdx = 0; refIdx < child->_flatReferences->count(); refIdx += 1 ) {
                        if( (*child->_flatReferences)[ refIdx ]->getHandle() == owner ) {
                            TreeNode * node = (*child->_flatReferences)[ refIdx ];
                            for( int ref2idx = 0; ref2idx < node->getCount( ParentList ); ref2idx += 1 ) {
                                if( node->getNode( ParentList, ref2idx )->getHandle() == owner ) {
                                    TreePtr * ptr = node->getPtr( ParentList, ref2idx );
                                    ((TreeRefPtr*)ptr)->incRefs();
                                    inReferences = true;
                                    break;
                                }
                            }
                        }
                        if( inReferences ) {
                            break;
                        }
                    }

                    if( !inReferences ) {
                        TreeRefNode * newRef;
                        newRef = new TreeRefNode( data->parentWin, parent, parent );
                        parent->_children.add( newRef );
                        parent->_hasRef = true;

                        parent->_flatReferences->add( newRef );
                    }
                } else {
                    parent->_children.add( child );
                    child->_parents.add(
                        new TreeFuncPtr( data->parentWin, child, parent, *ref ) );
                }
            } else {
                TreePtr * ptr = child->getPtr( ParentList, prtIdx );
                ((TreeFuncPtr *)ptr)->incRefs();
            }
        } else {
            int     i;

            for( i = child->_flatNodes->count(); i > 0; i -= 1 ) {
                parent->_flatNodes->add( (*child->_flatNodes)[ i - 1 ] );
            }

            data->roots->removeAt( childRoot );
            parent->_children.add( child );
            child->_parents.add(
                    new TreeFuncPtr( data->parentWin, child, parent, *ref ) );

            TreeCycleList * fList = child->_flatNodes;
            TreeRefList * rList = child->_flatReferences;

            for( i = fList->count(); i > 0; i -= 1 ) {
                TreeFuncNode * node = (TreeFuncNode *) (*fList)[ i - 1 ];
                node->_flatNodes = parent->_flatNodes;
                node->_flatReferences = parent->_flatReferences;
            }

            for( i = rList->count(); i > 0; i -= 1 ) {
                parent->_flatReferences->add( (*rList)[ i - 1 ] );
            }

            delete fList;
            delete rList;
        }
    } else {
        if( child != NULL ) {
            parent = new TreeFuncNode( data->parentWin, DRGetSymType( owner ),
                                       owner, data->mod, ownerName,
                                       child->_flatNodes,
                                       child->_flatReferences );

            parent->_children.add( child );
            child->_parents.add(
                    new TreeFuncPtr( data->parentWin, child, parent, *ref ) );
        } else {
            if( parent != NULL ) {
                WBRFree( ownerName );

                child = new TreeFuncNode( data->parentWin,
                                          DRGetSymType( ref->dependent ),
                                          ref->dependent, data->mod,
                                          DRGetName( ref->dependent ),
                                          parent->_flatNodes,
                                          parent->_flatReferences );
                parent->_children.add( child );
                child->_parents.add(
                    new TreeFuncPtr( data->parentWin, child, parent, *ref ) );

            } else {    // child == parent == NULL

                parent = new TreeFuncNode( data->parentWin,
                                           DRGetSymType( owner ),
                                           owner, data->mod, ownerName );

                if( ref->dependent == owner ) {
                    TreeRefNode * newRef;
                    newRef = new TreeRefNode( data->parentWin, parent, parent );
                    parent->_children.add( newRef );
                    parent->_hasRef = true;

                    parent->_flatReferences->add( newRef );
                } else {
                    child = new TreeFuncNode( data->parentWin,
                                              DRGetSymType( ref->dependent ),
                                              ref->dependent, data->mod,
                                              DRGetName( ref->dependent ),
                                              parent->_flatNodes,
                                              parent->_flatReferences );

                    child->_parents.add(
                        new TreeFuncPtr( data->parentWin, child, parent, *ref ) );
                    parent->_children.add( child );
                }

                data->roots->add( parent );
            }
        }
    }

    return true;
}
コード例 #15
0
ファイル: gtfunc.cpp プロジェクト: Azarien/open-watcom-v2
TreeFuncNode::~TreeFuncNode()
{
    WBRFree( _name );
    WBRFree( _decName );
}
コード例 #16
0
ファイル: opscan.cpp プロジェクト: Azarien/open-watcom-v2
int Scanner::getToken( YYSTYPE & lval )
/*************************************/
{
    int         c;
    int         count;
    int         fnd;
    bool        flush = false;
    bool        inquoted = false;
    bool        escaped = false;

    if( _stutter ) {
        _stutter = false;
        return _lastToken;
    }

    c = _scanStream->get();
    for(;;) {
        if( isspace( c ) ) {
            c = _scanStream->get();
        } else if( strchr( StartComments, c ) ) {
            do {
                c = _scanStream->get();
            } while( c != EOF && !strchr( EndComments, c ) );
            c = _scanStream->get();
        } else {
            break;
        }
    }
    if( c == '"' ) {
        inquoted = true;
        c = _scanStream->get();         // skip the quote
    }
    for( count = 0; ; count += 1 ) {

        if(( c == '\\' ) && ( _lookFor == LF_MagicString )) {
            c = _scanStream->get();
            if( isspace( c )) {
                _scanStream->unget( c );
                c = '\\';
            } else {
                escaped = true;
            }
        }

        if( c == EOF ) {
            if( count == 0 ) {
                if( CurrentScanner > 0 ) {
                    if( _lastToken == T_FileSync || _lastToken == EOF ) {
                        delete this;
                        return yylex();
                    } else {
                        _lastToken = T_FileSync;
                        return T_FileSync;
                    }
                } else {
                    return 0;       // done
                }
            } else {
                flush = true;
            }
        } else if( inquoted && !escaped ) {
            if( c == '"' ) {
                c = _scanStream->get();         // skip the quote
                flush = true;
            }
        } else if( isspace( c ) || strchr( StartComments, c ) ) {
            flush = true;
        } else if( strchr( Special, c ) && !escaped ) {
            if( count == 0 ) {
                _lastToken = c;
                return c;
            } else {
                flush = true;
            }
        }

        if( count >= BufSize - 1 ) {
            flush = true;
        }

        if( flush ) {
            _scanStream->unget( c );
            _buffer[ count ] = '\0';

            if(( _lookFor != LF_String ) && ( _lookFor != LF_MagicString )) {
                fnd = tryToken( _lookFor, _buffer );

                if( fnd > 0 ) {
                    lval = fnd;
                    return fnd;
                } else {
                    if( _recovering ) {
                        flush = false;
                        count = -1;
                    } else {
                        WString msg;
                        char * ambigs;
                        ambigs = tryAmbig( _lookFor, _buffer );

                        if( ambigs != NULL ) {
                            msg.printf( "[%s] is ambiguous -- try %s --",
                                        _buffer, ambigs );
                            WBRFree( ambigs );
                        } else {
                            msg.printf( "Unrecognized symbol [%s]", _buffer );
                        }
                        if( error( msg ) ) {
                            return 0;
                        }

                        _recovering = true;
                        flush = false;
                        count = -1;
                    }
                }
            } else {
                _stringTable.add( strdup( _buffer ));
                lval = _stringTable.count() - 1;
                if( _lookFor == LF_String ) {
                    _lastToken = T_String;
                } else {
                    _lastToken = T_MagicString;
                }
                return _lastToken;
            }
        } else {
            _buffer[ count ] = (char) c;
        }
        escaped = false;
        c = _scanStream->get();
    }
}
コード例 #17
0
ファイル: keysym.cpp プロジェクト: Ukusbobra/open-watcom-v2
bool KeySymbol::matches( Symbol * sym )
//-------------------------------------
// FIXME -- check the parent against both
//          functions and classes
{
    bool   accept;
    char * container;

    if( !(SymTypeConvert[ sym->symtype() ] & _searchFor) ) {
        return( FALSE );
    }

    if( !_anonymous ) {
        if( sym->isAnonymous() ) {
            return( FALSE );
        }
    }

    if( !_artificial ) {
        if( sym->isArtificial() ) {
            return( FALSE );
        }
    }

    if( !_declaration ) {
        if( !sym->isDefined() ) {
            return( FALSE );
        }
    }

    if( _nameProg ) {
        if( sym->name() ) {
            if( !RegExec( (regexp *) _nameProg, (char *) sym->name(), TRUE ) ) {
                return( FALSE );
            }
        } else {
            if( !RegExec( (regexp *) _nameProg, "", TRUE ) ) {
                return( FALSE );
            }
        }
    }

    if( _contClassProg ) {
        if( sym->getParent() ) {
            container = DRGetName( sym->getParent() );
            if( container ) {
                accept = (bool) RegExec( (regexp *) _contClassProg,
                                         container, TRUE );
                WBRFree( container );
                if( !accept ) {
                    return( FALSE );
                }
            } else {
                if( !RegExec( (regexp *) _contClassProg, "", TRUE ) ) {
                    return( FALSE );
                }
            }
        } else {
            return( FALSE );    // not local to anything
        }
    }

    // NYI -- can't check for containing function as this is not
    //        stored in the symbol

    if( !_fileFilter->matches( sym->getHandle() ) ) {
        return FALSE;
    }

    return( TRUE );
}