static orl_return CheckSymbol( orl_symbol_handle orl_sym_hnd )
/************************************************************/
{
orl_symbol_binding binding;
char *name;
orl_symbol_type type;
unsigned char info;
name = ORLSymbolGetName( orl_sym_hnd );
binding = ORLSymbolGetBinding( orl_sym_hnd );
if( binding == ORL_SYM_BINDING_GLOBAL || binding == ORL_SYM_BINDING_WEAK ) {
type = ORLSymbolGetType( orl_sym_hnd );
info = ORLSymbolGetRawInfo( orl_sym_hnd );
if( !( type & ORL_SYM_TYPE_UNDEFINED ) ) {
if( type & ORL_SYM_CDAT_MASK || binding == ORL_SYM_BINDING_WEAK ) {
AddSym( name, SYM_WEAK, info );
} else {
AddSym( name, SYM_STRONG, info );
}
} else if( ORLSymbolGetValue( orl_sym_hnd ) != 0 ) {
AddSym( name, SYM_WEAK, info );
}
} else if( binding == ORL_SYM_BINDING_ALIAS ) {
AddSym( name, SYM_WEAK, 0 );
}
return( ORL_OKAY );
}
static orl_return CheckSymbol( orl_symbol_handle orl_sym_hnd )
/************************************************************/
{
orl_symbol_binding binding;
const char *name;
orl_symbol_type type;
unsigned char info;
name = ORLSymbolGetName( orl_sym_hnd );
binding = ORLSymbolGetBinding( orl_sym_hnd );
if( binding == ORL_SYM_BINDING_GLOBAL || binding == ORL_SYM_BINDING_WEAK ) {
type = ORLSymbolGetType( orl_sym_hnd );
info = ORLSymbolGetRawInfo( orl_sym_hnd );
if( (type & ORL_SYM_TYPE_UNDEFINED) == 0 ) {
if( (type & ORL_SYM_CDAT_MASK) || binding == ORL_SYM_BINDING_WEAK ) {
AddSym( name, SYM_WEAK, info );
} else {
AddSym( name, SYM_STRONG, info );
}
} else {
unsigned_64 val64;
ORLSymbolGetValue( orl_sym_hnd, &val64 );
if( val64.u._32[I64LO32] != 0 || val64.u._32[I64HI32] != 0 ) {
AddSym( name, SYM_WEAK, info );
}
}
} else if( binding == ORL_SYM_BINDING_ALIAS ) {
AddSym( name, SYM_WEAK, 0 );
}
return( ORL_OKAY );
}
symbol * HashReplace( symbol *sym )
/****************************************/
{
symbol * newsym;
if( sym->mod == NULL )
return sym;
Ring2Prune( &sym->mod->publist, sym );
if( IS_SYM_COMMUNAL(sym) ) {
sym->p.seg->isdead = TRUE;
}
if( !(LinkFlags & INC_LINK_FLAG) )
return sym;
newsym = AddSym();
newsym->e.mainsym = sym;
newsym->name = sym->name;
newsym->namelen_cmp = sym->namelen_cmp;
newsym->info = sym->info | SYM_DEAD | SYM_IS_ALTDEF;
Ring2Append( &sym->mod->publist, newsym );
RingAppend( &sym->u.altdefs, newsym );
if( IS_SYM_NICOMDEF(sym) ) {
sym->p.cdefsize = sym->p.seg->length;
}
return sym;
}
static symbol *DoSymOp( sym_flags op, char *symname, size_t length )
/******************************************************************/
{
unsigned hash;
symbol *sym;
size_t searchlen;
#ifdef _INT_DEBUG
char *symname_dbg;
symname_dbg = alloca( length + 1 );
memcpy( symname_dbg, symname, length );
symname_dbg[ length ] = '\0';
#endif
DEBUG(( DBG_OLD, "SymOp( %d, %s, %d )", op, symname_dbg, length ));
if( NameLen != 0 && NameLen < length ) {
searchlen = NameLen;
} else {
searchlen = length;
}
if( op & ST_STATIC ) {
hash = StaticHashFn( symname, searchlen );
/* If symbol isn't unique, don't look for duplicates. */
if( (op & (ST_CREATE | ST_STATIC | ST_NONUNIQUE)) ==
(ST_CREATE | ST_STATIC | ST_NONUNIQUE) )
sym = NULL;
else
sym = StaticSearchSym( symname, hash, searchlen );
} else {
hash = GlobalHashFn( symname, searchlen );
sym = GlobalSearchSym( symname, hash, searchlen );
}
DEBUG(( DBG_OLD, "- hash %d", hash ));
if( sym != NULL ) {
DEBUG(( DBG_OLD, "found symbol %s", symname_dbg ));
DEBUG(( DBG_OLD, " - handle = %h", sym ));
return( sym );
}
if( !(op & ST_FIND) ) {
sym = AddSym();
sym->name = AddSymbolStringTable( &PermStrings, symname, length );
sym->namelen_cmp = searchlen;
if( op & ST_STATIC ) {
sym->info |= SYM_STATIC;
sym->hash = StaticSymPtrs[hash];
StaticSymPtrs[hash] = sym;
} else {
sym->hash = GlobalSymPtrs[hash];
GlobalSymPtrs[hash] = sym;
}
DEBUG((DBG_OLD, "added symbol %s", symname_dbg ));
}
return( sym );
}
static symbol *DoSymOp( sym_flags op, char *symname, unsigned length )
/********************************************************************/
{
unsigned hash;
symbol *sym;
unsigned searchlen;
#ifdef _INT_DEBUG
char *symname_dbg;
symname_dbg = alloca( length + 1 );
memcpy( symname_dbg, symname, length );
symname_dbg[ length ] = '\0';
#endif
if( NameLen != 0 && NameLen < length ) {
searchlen = NameLen;
} else {
searchlen = length;
}
if( op & ST_STATIC ) {
hash = StaticHashFn( symname, searchlen );
/* jwlink: allow duplicate static symbols */
//sym = StaticSearchSym( symname, hash, searchlen );
if ( ( op & ( ST_CREATE|ST_STATIC|ST_DUPLICATE ) ) == ( ST_CREATE|ST_STATIC|ST_DUPLICATE) )
sym = NULL;
else
sym = StaticSearchSym( symname, hash, searchlen );
} else {
hash = GlobalHashFn( symname, searchlen );
sym = GlobalSearchSym( symname, hash, searchlen );
}
DEBUG(( DBG_OLD, "SymOp( %d, %s, %d ) - hash %d - handle = %h", op, symname_dbg, length, hash, sym ));
if( sym != NULL ) {
//DEBUG(( DBG_OLD, "found symbol %s", symname_dbg ));
//DEBUG(( DBG_OLD, " - handle = %h", sym ));
return( sym );
}
if( !(op & ST_FIND) ) {
sym = AddSym();
sym->name = AddSymbolStringTable( &PermStrings, symname, length );
sym->namelen_cmp = searchlen;
if( op & ST_STATIC ) {
sym->info |= SYM_STATIC;
sym->hash = StaticSymPtrs[hash];
StaticSymPtrs[hash] = sym;
} else {
sym->hash = GlobalSymPtrs[hash];
GlobalSymPtrs[hash] = sym;
}
DEBUG((DBG_OLD, "DoSymOp: added symbol %s hdl=%h info=%h", symname_dbg, sym, sym->info ));
}
return( sym );
}
symbol * AddAltDef( symbol *sym, sym_info sym_type )
/*********************************************************/
{
symbol * altsym;
if( !(LinkFlags & INC_LINK_FLAG) )
return sym;
altsym = AddSym();
SET_SYM_TYPE( altsym, sym_type );
altsym->info |= SYM_DEAD | SYM_IS_ALTDEF;
altsym->mod = CurrMod;
altsym->name = sym->name;
altsym->e.mainsym = sym;
Ring2Append( &CurrMod->publist, altsym );
RingAppend( &sym->u.altdefs, altsym );
return altsym;
}
void
MFCSimpleTypeView::ContextMenu(UINT nFlags, CPoint point)
{
long caty[] = {
// TypedValue::S_DOUBLE,
// TypedValue::S_LAMBDA,
TypedValue::S_FLOAT,
TypedValue::S_INT,
TypedValue::S_SHORT,
TypedValue::S_BYTE,
TypedValue::S_BOOL
};
CPoint popPt = point;
ClientToScreen(&popPt);
CMenu *ctxtMenu = new CMenu;
ctxtMenu->CreatePopupMenu();
CMenu *addVarMenu = new CMenu;
addVarMenu->CreatePopupMenu();
char buf[512];
long item = ItemAtPoint(point);
for (short i=0; i<sizeof(caty)/sizeof(caty[0]); i++) {
if (ID_VARIABLECONTEXT_ADD_VAR + caty[i] > ID_VARIABLECONTEXT_ADD_VAR_TYPE_RANGE) {
reportError("Internal error. type index value exceeded in menu creator, is %d and shouldn't exceed %d",
caty[i], ID_VARIABLECONTEXT_ADD_VAR_TYPE_RANGE-ID_VARIABLECONTEXT_ADD_VAR);
} else {
string tnm = findTypeName(caty[i]);
if (tnm.size()) {
sprintf(buf, "%s", tnm.c_str());
addVarMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_ADD_VAR + caty[i], buf);
}
}
}
ctxtMenu->AppendMenu(MF_POPUP, (UINT) addVarMenu->m_hMenu, "add variable");
ctxtMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_ADD_METHOD, "add method");
StabEnt *itemSym = NULL;
if (item >= 0) {
// delete selected item
// set selected item envelope
// set selected item display type
// set selected item length ... to create an array
itemSym = SymForItem(item);
if (itemSym != NULL) {
CMenu *setVarTypeMenu = new CMenu;
setVarTypeMenu->CreatePopupMenu();
for (short i=0; i<sizeof(caty)/sizeof(caty[0]); i++) {
if (ID_VARIABLECONTEXT_SET_VAR_TYPE + caty[i] > ID_VARIABLECONTEXT_SET_VAR_TYPE_RANGE) {
reportError("Internal error. type index value exceeded in menu creator, is %d and shouldn't exceed %d",
caty[i], ID_VARIABLECONTEXT_SET_VAR_TYPE_RANGE-ID_VARIABLECONTEXT_SET_VAR_TYPE);
} else {
string tnm = findTypeName(caty[i]);
if (tnm.size() && itemSym->type != caty[i]) {
sprintf(buf, "%s", tnm.c_str());
setVarTypeMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_SET_VAR_TYPE + caty[i], buf);
}
}
}
sprintf(buf, "set '%s' type", itemSym->uniqueName());
ctxtMenu->AppendMenu(MF_POPUP, (UINT) setVarTypeMenu->m_hMenu, buf);
sprintf(buf, "delete '%s'", itemSym->uniqueName());
ctxtMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_DELETE_SELECTED, buf);
sprintf(buf, "set '%s' envelope", itemSym->uniqueName());
ctxtMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_ENVELOPE_SELECTED, buf);
CMenu *dispVarMenu = new CMenu;
dispVarMenu->CreatePopupMenu();
dispVarMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_NODISPLAY_SELECTED, "none");
dispVarMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_CONTROL_SELECTED, "control");
dispVarMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_DISPLAY_SELECTED, "display");
sprintf(buf, "set '%s' display", itemSym->uniqueName());
ctxtMenu->AppendMenu(MF_POPUP, (UINT) dispVarMenu->m_hMenu, buf);
ctxtMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_SET_LENGTH_SELECTED, "set length");
}
}
// add item
// by type
// structures ????
short ret = ctxtMenu->TrackPopupMenuEx(
TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_RETURNCMD,
popPt.x, popPt.y, this, NULL);
if (ret >= ID_VARIABLECONTEXT_ADD_VAR && ret <= ID_VARIABLECONTEXT_ADD_VAR_TYPE_RANGE) {
long typ = ret - ID_VARIABLECONTEXT_ADD_VAR;
if (parent && parent->Symbol()) {
StabEnt *pSym = parent->Symbol();
Stackable *stkbl = pSym->StackableValue();
if (stkbl) {
char *vnm = "variable%d";
switch(typ) {
case TypedValue::S_BYTE: vnm = "bytevar"; break;
case TypedValue::S_SHORT: vnm = "wordvar"; break;
case TypedValue::S_INT: vnm = "intvar"; break;
case TypedValue::S_LONG: vnm = "longvar"; break;
case TypedValue::S_FLOAT: vnm = "floatvar"; break;
}
string nmbuf = glob.makeUniqueName(pSym, vnm, 1);
StabEnt *nsym=DefineSymbol(nmbuf, typ, 0, 0, pSym, TypedValue::REF_STACK, false, false, StabEnt::DISPLAY_NOT);
stkbl->ReAllocateChildren();
AddSym(nsym);
}
}
} else if (ret == ID_VARIABLECONTEXT_ADD_METHOD) {
if (parent && parent->Symbol()) {
StabEnt *pSym = parent->Symbol();
string nmbuf = glob.makeUniqueName(pSym, "action", 1);
QuaPerceptualSet *quaLink=parent->QuaLink();
if (quaLink) {
StabEnt *mSym = quaLink->CreateMethod(nmbuf, pSym);
if (mSym) {
AddSym(mSym);
fprintf(stderr, "tried to add method element\n");
}
}
}
} else if (ret >= ID_VARIABLECONTEXT_SET_VAR_TYPE && ret <= ID_VARIABLECONTEXT_SET_VAR_TYPE_RANGE) {
long typ = ret - ID_VARIABLECONTEXT_SET_VAR_TYPE;
if (itemSym && parent && parent->Symbol()) {
StabEnt *pSym = parent->Symbol();
Stackable *stkbl = pSym->StackableValue();
if (stkbl) {
bool validChange = false;
switch(typ) {
case TypedValue::S_BYTE: validChange = true; break;
case TypedValue::S_SHORT: validChange = true; break;
case TypedValue::S_INT: validChange = true; break;
case TypedValue::S_LONG: validChange = true; break;
case TypedValue::S_FLOAT: validChange = true; break;
}
if (validChange) {
itemSym->type = typ;
stkbl->ReAllocateChildren();
}
}
}
} else if (ret == ID_VARIABLECONTEXT_DELETE_SELECTED) {
if (itemSym) {
glob.DeleteSymbol(itemSym, true);
RemoveSym(itemSym);
if (parent && parent->Symbol()) {
StabEnt *pSym = parent->Symbol();
Stackable *stkbl = pSym->StackableValue();
if (stkbl) {
stkbl->ReAllocateChildren();
}
}
}
} else if (ret == ID_VARIABLECONTEXT_ENVELOPE_SELECTED) {
if (itemSym) {
itemSym->SetEnvelopeMode(true);
}
} else if (ret == ID_VARIABLECONTEXT_NODISPLAY_SELECTED) {
if (itemSym) {
itemSym->SetDisplayMode(StabEnt::DISPLAY_NOT);
// forces redisplay of this entry to show icon change
GetListCtrl().SetItemText(item, 3, "N");
}
} else if (ret == ID_VARIABLECONTEXT_DISPLAY_SELECTED) {
if (itemSym) {
itemSym->SetDisplayMode(StabEnt::DISPLAY_DISP);
// forces redisplay of this entry
GetListCtrl().SetItemText(item, 3, "D");
}
} else if (ret == ID_VARIABLECONTEXT_CONTROL_SELECTED) {
if (itemSym) {
itemSym->SetDisplayMode(StabEnt::DISPLAY_CTL);
// forces redisplay of this entry
GetListCtrl().SetItemText(item, 3, "C");
}
} else if (ret == ID_VARIABLECONTEXT_SET_LENGTH_SELECTED) {
reportError("Currently only undimensioned data are supported by this interface .... but they can be added manually by hand-editting the script");
}
}
void
main ()
{
int id, *XXX;
char *YYY;
void *ZZZ;
struct
{
int a, b;
}
*AAA;
Symbol s;
fprintf (stderr, "#####\n");
id = NewSymTbl (7);
s = AddSym (id, "aaa", 1);
pr (s);
s = FindSym (id, "aaa", 2);
pr (s);
s = AddSym (id, "bbb", 2);
pr (s);
s = FindSym (id, "bbb", 2);
pr (s);
s = AddSym (id, "ccc", 2);
pr (s);
s = AddSym (id, "ddd", 2);
pr (s);
s->ptr = XXX;
s = AddSym (id, "ddd", 2);
pr (s);
s = AddSym (id, "eee", 2);
pr (s);
s = FindSym (id, "eee", 1);
pr (s);
s = AddSym (id, "fff", 2);
pr (s);
s->ptr = (Symbol) YYY;
s = AddSym (id, "fff", 2);
pr (s);
s->ptr = (Symbol) ZZZ;
s = AddSym (id, "fff", 2);
pr (s);
s->ptr = (Symbol) AAA;
s = FindSym (id, "fff", 2);
pr (s);
s = AddSym (id, "ggg", 2);
pr (s);
s = AddSym (id, "hhh", 2);
pr (s);
fprintf (stderr, "#####\n");
}
