encounter
/
MWCC
mirror of https://git.wuffs.org/MWCC
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
MWCC/compiler_and_linker/unsorted/CBrowse.c

738 lines
20 KiB
C
Raw Blame History

#include "compiler/CBrowse.h"
#include "compiler/CDecl.h"
#include "compiler/CError.h"
#include "compiler/CMangler.h"
#include "compiler/CParser.h"
#include "compiler/CPrep.h"
#include "compiler/CompilerTools.h"
#include "compiler/Unmangle.h"
#include "compiler/objects.h"
#include "compiler/templates.h"
#include "cos.h"
#include "plugin.h"
Boolean gUseTokenStreamSource;
Boolean gForceSourceLoc;
Boolean gUseNameTable;
static GList gBrowseData;
static GList gClassData;
static GList gMemberFuncList;
static int gNextMemberFuncID;
enum ELanguage {
langUnknown,
langC,
langCPlus,
langPascal,
langObjectPascal,
langJava,
langAssembler,
langFortran,
langRez
};
enum EBrowserItem {
browseFunction,
browseGlobal,
browseClass,
browseMacro,
browseEnum,
browseTypedef,
browseConstant,
browseTemplate,
browsePackage,
browseCompSymbolStart = 0x70,
browseEnd = 0xFF
};
enum {
kAbstract = 1,
kStatic = 2,
kFinal = 4,
kMember = 8,
kInterface = 0x80,
kPublic = 0x100,
kInline = 0x80,
kPascal = 0x100,
kAsm = 0x200,
kVirtual = 0x400,
kCtor = 0x800,
kDtor = 0x1000,
kNative = 0x2000,
kSynch = 0x4000,
kIntrinsic = 0x8000,
kConst = 0x10000,
kTransient = 0x80,
kVolatile = 0x100
};
enum EAccess {
accessNone = 0,
accessPrivate = 1,
accessProtected = 2,
accessPublic = 4
};
enum EMember {
memberFunction,
memberData,
memberEnd = 0xFF
};
enum ETemplateType {
templateClass,
templateFunction
};
static enum EAccess gFromAccessType[] = {
accessPublic,
accessPrivate,
accessProtected,
accessNone
};
typedef struct BrowseHeader {
SInt32 browse_header;
SInt32 browse_version;
SInt16 browse_language;
SInt16 uses_name_table;
SInt32 earliest_compatible_version;
SInt32 reserved[15];
} BrowseHeader;
// forward decls
static void RecordUndefinedMemberFunctions(void);
void CBrowse_Setup(CParams *params) {
BrowseHeader hdr;
CError_ASSERT(123, params != NULL);
params->objectdata.browsedata = NULL;
InitGList(&gBrowseData, 0x10000);
InitGList(&gMemberFuncList, 1024);
gNextMemberFuncID = 1;
gForceSourceLoc = 0;
gUseNameTable = 0;
memclrw(&hdr, sizeof(hdr));
hdr.browse_header = 0xBEABBAEB;
hdr.browse_version = 2;
hdr.earliest_compatible_version = 2;
hdr.browse_language = copts.cplusplus ? langCPlus : langC;
hdr.uses_name_table = gUseNameTable;
AppendGListData(&gBrowseData, &hdr, sizeof(hdr));
}
void CBrowse_Finish(CParams *params) {
CWMemHandle hnd;
CError_ASSERT(151, params != NULL);
if (gBrowseData.size >= sizeof(BrowseHeader)) {
RecordUndefinedMemberFunctions();
AppendGListByte(&gBrowseData, -1);
COS_ResizeHandle(gBrowseData.data, gBrowseData.size);
if (CWSecretAttachHandle(params->context, gBrowseData.data, &hnd) == cwNoErr) {
params->objectdata.browsedata = hnd;
gBrowseData.data = NULL;
}
}
}
void CBrowse_Cleanup(CParams *params) {
FreeGList(&gBrowseData);
FreeGList(&gClassData);
FreeGList(&gMemberFuncList);
}
static void AppendGList(GList *dst, GList *src) {
SInt32 offset = dst->size;
AppendGListNoData(dst, src->size);
memcpy(*dst->data + offset, *src->data, src->size);
}
static void RecordName(GList *gl, const char *str, SInt32 id) {
HashNameNode *name;
CError_ASSERT(190, gl && str && *str);
if (id < 0 && gUseNameTable) {
for (name = name_hash_nodes[CHash(str)]; name; name = name->next) {
if (!strcmp(str, name->name)) {
id = name->id;
break;
}
}
}
if (id >= 0 && gUseNameTable) {
AppendGListWord(gl, -1);
AppendGListLong(gl, id);
} else {
int len = strlen(str);
AppendGListWord(gl, len);
if (len)
AppendGListData(gl, str, len + 1);
}
}
void CBrowse_BeginClass(DeclInfo *di, GList *gl) {
char *buf;
ClassList *base;
SInt32 i;
TypeClass *tclass;
CError_ASSERT(227, di && di->thetype && gl);
*gl = gClassData;
if (
!di->file ||
!di->file->fileID ||
!di->file->recordbrowseinfo ||
!di->file2 ||
!di->file2->fileID ||
di->x60 <= 0
)
{
memclrw(&gClassData, sizeof(gClassData));
return;
}
if (IsTempName(TYPE_CLASS(di->thetype)->classname)) {
memclrw(&gClassData, sizeof(gClassData));
return;
}
InitGList(&gClassData, 0x4000);
AppendGListByte(&gClassData, browseClass);
AppendGListWord(&gClassData, di->file->fileID);
AppendGListWord(&gClassData, di->file2->fileID);
AppendGListLong(&gClassData, di->x60 - 1);
CError_ASSERT(270, gClassData.size == 9);
AppendGListLong(&gClassData, di->x60 - 1);
AppendGListLong(&gClassData, 0);
RecordName(&gClassData, TYPE_CLASS(di->thetype)->classname->name, TYPE_CLASS(di->thetype)->classname->id);
CMangler_MangleType(di->thetype, 0);
AppendGListByte(&name_mangle_list, 0);
buf = lalloc(name_mangle_list.size + 1);
strcpy(buf, *name_mangle_list.data);
while (*buf && *buf >= '0' && *buf <= '9')
buf++;
if (strcmp(TYPE_CLASS(di->thetype)->classname->name, buf))
RecordName(&gClassData, buf, -1);
else
AppendGListWord(&gClassData, 0);
AppendGListLong(&gClassData, 0);
i = 0;
base = TYPE_CLASS(di->thetype)->bases;
while (base) {
base = base->next;
i++;
}
AppendGListByte(&gClassData, i);
for (base = TYPE_CLASS(di->thetype)->bases; base; base = base->next) {
AppendGListByte(&gClassData, gFromAccessType[base->access]);
AppendGListByte(&gClassData, base->is_virtual);
tclass = base->base;
if ((tclass->flags & CLASS_FLAGS_800) && !TEMPL_CLASS_INST(tclass)->is_specialized)
tclass = TYPE_CLASS(TEMPL_CLASS_INST(tclass)->templ);
CMangler_MangleType(TYPE(tclass), 0);
AppendGListByte(&name_mangle_list, 0);
buf = lalloc(name_mangle_list.size + 1);
strcpy(buf, *name_mangle_list.data);
while (*buf && *buf >= '0' && *buf <= '9')
buf++;
i = base->base->classname->id;
while (*buf && *buf >= '0' && *buf <= '9') {
i = -1;
buf++;
}
RecordName(&gClassData, buf, i);
}
}
void CBrowse_AddClassMemberVar(ObjMemberVar *ivar, SInt32 startOffset, SInt32 endOffset) {
short len;
CError_ASSERT(360, ivar);
if (gClassData.data && startOffset > 0 && endOffset >= startOffset) {
if (tk == ';')
endOffset++;
AppendGListByte(&gClassData, memberData);
AppendGListByte(&gClassData, gFromAccessType[ivar->access]);
AppendGListLong(&gClassData, 0);
AppendGListLong(&gClassData, startOffset - 1);
AppendGListLong(&gClassData, endOffset - 1);
len = strlen(ivar->name->name);
AppendGListWord(&gClassData, len);
AppendGListData(&gClassData, ivar->name->name, len + 1);
}
}
void CBrowse_AddClassMemberFunction(Object *object, SInt32 startOffset, SInt32 endOffset) {
SInt32 flags;
SInt32 id;
TypeMethod *tfunc;
CError_ASSERT(380, object);
if (
!IsTempName(object->name) &&
gClassData.data &&
startOffset > 0 &&
endOffset >= startOffset
)
{
flags = 0;
CError_ASSERT(391, object->type && IS_TYPE_FUNC(object->type));
tfunc = TYPE_METHOD(object->type);
if (tfunc->flags & FUNC_FLAGS_100)
return;
if (object->datatype == DVFUNC)
flags |= kVirtual;
if (tfunc->flags & FUNC_FLAGS_8)
flags |= kAbstract;
if (tfunc->x26)
flags |= kStatic;
if (tfunc->flags & FUNC_FLAGS_1000)
flags |= kCtor;
if (tfunc->flags & FUNC_FLAGS_2000)
flags |= kDtor;
AppendGListByte(&gClassData, memberFunction);
AppendGListByte(&gClassData, gFromAccessType[object->access]);
AppendGListLong(&gClassData, flags);
id = tfunc->x22;
if (id <= 0) {
// TODO: this is not 64-bit safe
if (!(tfunc->flags & FUNC_FLAGS_2) || id == -1)
AppendGListLong(&gMemberFuncList, (SInt32) object);
tfunc->x22 = id = gNextMemberFuncID++;
}
AppendGListLong(&gClassData, id);
AppendGListLong(&gClassData, startOffset - 1);
AppendGListLong(&gClassData, endOffset);
}
}
void CBrowse_AddClassMemberData(Object *object, SInt32 startOffset, SInt32 endOffset) {
short len;
CError_ASSERT(435, object);
if (gClassData.data && startOffset > 0 && endOffset >= startOffset && object->datatype == DDATA) {
if (tk == ';')
endOffset++;
AppendGListByte(&gClassData, memberData);
AppendGListByte(&gClassData, gFromAccessType[object->access]);
AppendGListLong(&gClassData, kStatic);
AppendGListLong(&gClassData, startOffset - 1);
AppendGListLong(&gClassData, endOffset - 1);
len = strlen(object->name->name);
AppendGListWord(&gClassData, len);
AppendGListData(&gClassData, object->name->name, len + 1);
}
}
void CBrowse_EndClass(SInt32 offset, GList *gl) {
CError_ASSERT(453, gl);
if (gClassData.data) {
if (gClassData.size > 0) {
if (tk == ';')
offset++;
memcpy(*gClassData.data + 9, &offset, 4);
AppendGList(&gBrowseData, &gClassData);
AppendGListByte(&gBrowseData, memberEnd);
}
FreeGList(&gClassData);
}
gClassData = *gl;
}
void CBrowse_BeginStruct(DeclInfo *di, TypeStruct *tstruct, GList *gl) {
HashNameNode *name;
CError_ASSERT(480, di && gl);
*gl = gClassData;
if (
!di->file ||
!di->file->fileID ||
!di->file->recordbrowseinfo ||
!di->file2 ||
!di->file2->fileID ||
di->x60 <= 0
)
{
memclrw(&gClassData, sizeof(gClassData));
return;
}
name = tstruct->name;
if (!name || IsTempName(name)) {
memclrw(&gClassData, sizeof(gClassData));
return;
}
InitGList(&gClassData, 0x4000);
AppendGListByte(&gClassData, browseClass);
AppendGListWord(&gClassData, di->file->fileID);
AppendGListWord(&gClassData, di->file2->fileID);
AppendGListLong(&gClassData, di->x60 - 1);
CError_ASSERT(521, gClassData.size == 9);
AppendGListLong(&gClassData, di->x60 - 1);
AppendGListLong(&gClassData, 0);
RecordName(&gClassData, name->name, name->id);
AppendGListWord(&gClassData, 0);
AppendGListLong(&gClassData, 0);
AppendGListByte(&gClassData, 0);
}
void CBrowse_AddStructMember(StructMember *member, SInt32 startOffset, SInt32 endOffset) {
short len;
if (tk == ';')
endOffset++;
if (gClassData.data && member && startOffset > 0 && endOffset >= startOffset) {
AppendGListByte(&gClassData, memberData);
AppendGListByte(&gClassData, accessPublic);
AppendGListLong(&gClassData, 0);
AppendGListLong(&gClassData, startOffset - 1);
AppendGListLong(&gClassData, endOffset - 1);
len = strlen(member->name->name);
AppendGListWord(&gClassData, len);
AppendGListData(&gClassData, member->name->name, len + 1);
}
}
void CBrowse_EndStruct(SInt32 offset, GList *gl) {
CError_ASSERT(558, gl);
if (gClassData.data) {
if (offset > 0 && gClassData.size > 0) {
memcpy(*gClassData.data + 9, &offset, 4);
AppendGList(&gBrowseData, &gClassData);
AppendGListByte(&gBrowseData, memberEnd);
}
FreeGList(&gClassData);
}
gClassData = *gl;
}
static void EmitStandardData(int item, int fileID1, int fileID2, SInt32 startOffset, SInt32 endOffset, const char *str, SInt32 id, const char *str2, SInt32 id2) {
CError_ASSERT(584, str);
AppendGListByte(&gBrowseData, item);
AppendGListWord(&gBrowseData, fileID1);
AppendGListWord(&gBrowseData, fileID2);
AppendGListLong(&gBrowseData, startOffset - 1);
AppendGListLong(&gBrowseData, endOffset - 1);
AppendGListLong(&gBrowseData, 0);
RecordName(&gBrowseData, str, id);
if (str2 && str2 != str)
RecordName(&gBrowseData, str2, id2);
else
AppendGListWord(&gBrowseData, 0);
}
void CBrowse_NewTypedef(NameSpace *nspace, HashNameNode *name, CPrepFileInfo *file1, CPrepFileInfo *file2, SInt32 startOffset, SInt32 endOffset) {
CError_ASSERT(618, file1 && file1->recordbrowseinfo);
if (file2 && file2->fileID && startOffset > 0 && endOffset >= startOffset) {
EmitStandardData(browseTypedef,
file1->fileID, file2->fileID,
startOffset, endOffset,
name->name, name->id,
CError_GetQualifiedName(nspace, name), -1);
}
}
void CBrowse_NewEnum(NameSpace *nspace, HashNameNode *name, CPrepFileInfo *file1, CPrepFileInfo *file2, SInt32 startOffset, SInt32 endOffset) {
CError_ASSERT(632, file1 && file1->recordbrowseinfo);
if (file2 && file2->fileID && startOffset > 0 && endOffset >= startOffset) {
EmitStandardData(browseEnum,
file1->fileID, file2->fileID,
startOffset, endOffset,
name->name, name->id,
CError_GetQualifiedName(nspace, name), -1);
}
}
void CBrowse_NewEnumConstant(NameSpace *nspace, HashNameNode *name, CPrepFileInfo *file1, CPrepFileInfo *file2, SInt32 startOffset, SInt32 endOffset) {
CError_ASSERT(646, file1 && file1->recordbrowseinfo);
if (tk == ',')
endOffset++;
if (file2 && file2->fileID && startOffset > 0 && endOffset >= startOffset) {
EmitStandardData(browseConstant,
file1->fileID, file2->fileID,
startOffset, endOffset,
name->name, name->id,
CError_GetQualifiedName(nspace, name), -1);
}
}
static HashNameNode *CBrowse_GetLinkName(Object *object) {
return CMangler_GetLinkName(object);
}
static void RecordFunction(Object *object, int fileID1, int fileID2, SInt32 startOffset, SInt32 endOffset) {
TypeFunc *tfunc;
char *tmp;
Boolean flag;
char *str29;
HashNameNode *linkname;
SInt32 flags;
char *namestr;
SInt32 nameid;
char *namestr2;
SInt32 nameid2;
int funcid;
char buf[2048];
char buf2[256];
CError_ASSERT(740, object->type && IS_TYPE_FUNC(object->type));
if (IsTempName(object->name))
return;
tfunc = TYPE_FUNC(object->type);
if ((tfunc->flags & (FUNC_FLAGS_100 | FUNC_FLAGS_200)) && (!fileID2 || startOffset < 0))
return;
linkname = object->name;
tmp = linkname->name;
if (!(linkname->name[0] == '_' && linkname->name[1] == '_')) {
namestr = tmp;
nameid = linkname->id;
switch (tmp[0]) {
case '.':
nameid = -1;
namestr += 1;
break;
case '_':
switch (tmp[1]) {
case '#':
case '%':
case '@':
nameid = -1;
namestr += 2;
break;
}
break;
}
} else {
flag = 1;
if (tfunc->flags & (FUNC_FLAGS_1000 | FUNC_FLAGS_2000)) {
tmp = TYPE_METHOD(tfunc)->theclass->classname->name;
while (*tmp >= '0' && *tmp <= '9')
tmp++;
MWUnmangleClassName(tmp, buf, sizeof(buf));
str29 = buf;
if ((tmp = strrchr(str29, ':')))
str29 = tmp + 1;
if (tfunc->flags & FUNC_FLAGS_2000) {
buf2[0] = '~';
strncpy(&buf2[1], str29, sizeof(buf2) - 1);
namestr = buf2;
} else {
namestr = str29;
}
flag = 0;
}
if (flag) {
MWUnmangle(object->name->name, buf, sizeof(buf));
namestr = buf;
}
nameid = -1;
}
while (*namestr >= '0' && *namestr <= '9') {
nameid = -1;
namestr++;
}
namestr2 = NULL;
nameid2 = -1;
linkname = CBrowse_GetLinkName(object);
if (object->name != linkname) {
namestr2 = linkname->name;
if (linkname->name[0] == '.')
namestr2++;
else
nameid2 = linkname->id;
}
EmitStandardData(browseFunction, fileID1, fileID2, startOffset, endOffset, namestr, nameid, namestr2, nameid2);
flags = 0;
if (object->qual & Q_INLINE)
flags |= kInline;
if (object->qual & Q_PASCAL)
flags |= kPascal;
if (object->qual & Q_ASM)
flags |= kAsm;
if (object->sclass == TK_STATIC)
flags |= kStatic;
if (tfunc->flags & FUNC_FLAGS_METHOD)
flags |= kMember;
AppendGListLong(&gBrowseData, flags);
funcid = 0;
if (tfunc->flags & FUNC_FLAGS_METHOD) {
funcid = TYPE_METHOD(tfunc)->x22;
if (funcid <= 0) {
TYPE_METHOD(tfunc)->x22 = funcid = gNextMemberFuncID++;
}
}
AppendGListLong(&gBrowseData, funcid);
}
void CBrowse_NewFunction(Object *object, CPrepFileInfo *file1, CPrepFileInfo *file2, SInt32 startOffset, SInt32 endOffset) {
CError_ASSERT(890, file1 && file1->recordbrowseinfo);
if (file2 && file2->fileID && startOffset > 0 && (endOffset + 1) >= startOffset)
RecordFunction(object, file1->fileID, file2->fileID, startOffset, endOffset + 1);
}
void CBrowse_NewData(Object *object, CPrepFileInfo *file1, CPrepFileInfo *file2, SInt32 startOffset, SInt32 endOffset) {
char *namestr = NULL;
SInt32 flags = 0;
Boolean is_const = is_const_object(object);
CError_ASSERT(912, file1 && file1->recordbrowseinfo);
CError_ASSERT(913, object);
if (tk == ';')
endOffset++;
if (file2 && file2->fileID && startOffset > 0 && endOffset >= startOffset) {
HashNameNode *name = CBrowse_GetLinkName(object);
if (object->name != name)
namestr = name->name;
EmitStandardData(
is_const ? browseConstant : browseGlobal,
file1->fileID, file2->fileID,
startOffset, endOffset,
object->name->name, object->name->id,
namestr, name->id
);
if (!is_const) {
if (object->sclass == TK_STATIC)
flags |= kStatic;
AppendGListLong(&gBrowseData, flags);
}
}
}
void CBrowse_NewMacro(Macro *macro, CPrepFileInfo *file, SInt32 startOffset, SInt32 endOffset) {
CError_ASSERT(951, !file || (file->recordbrowseinfo && !macro->is_special));
if (file && file->fileID && startOffset > 0 && endOffset >= startOffset)
EmitStandardData(
browseMacro,
file->fileID, file->fileID,
startOffset, endOffset,
macro->name->name, macro->name->id,
NULL, -1
);
}
void CBrowse_NewTemplateClass(TemplClass *tmclass, CPrepFileInfo *file, SInt32 startOffset, SInt32 endOffset) {
CError_ASSERT(965, !file || file->recordbrowseinfo);
if (file && file->fileID && startOffset > 0 && endOffset >= startOffset) {
EmitStandardData(
browseTemplate,
file->fileID, file->fileID,
startOffset, endOffset,
tmclass->theclass.classname->name, tmclass->theclass.classname->id,
NULL, -1
);
AppendGListByte(&gBrowseData, templateClass);
}
}
void CBrowse_NewTemplateFunc(TemplateFunction *tmfunc) {
CError_ASSERT(979, !tmfunc->srcfile || tmfunc->srcfile->recordbrowseinfo);
if (tmfunc->srcfile && tmfunc->srcfile->fileID && tmfunc->startoffset > 0 && tmfunc->endoffset >= tmfunc->startoffset) {
EmitStandardData(
browseTemplate,
tmfunc->srcfile->fileID, tmfunc->srcfile->fileID,
tmfunc->startoffset, tmfunc->endoffset,
tmfunc->name->name, tmfunc->name->id,
NULL, -1
);
AppendGListByte(&gBrowseData, templateFunction);
}
}
static void RecordUndefinedMemberFunctions(void) {
int i;
int count;
Object **array;
COS_LockHandleHi(gMemberFuncList.data);
count = gMemberFuncList.size / sizeof(Object *);
array = (Object **) *gMemberFuncList.data;
for (i = 0; i < count; i++, array++) {
if (IS_TYPE_FUNC((*array)->type) && !(TYPE_FUNC((*array)->type)->flags & FUNC_FLAGS_2))
RecordFunction(*array, 0, 0, -1, -1);
}
COS_UnlockHandle(gMemberFuncList.data);
}
Reference in New Issue View Git Blame Copy Permalink