wxString Token::DisplayName() const
{
wxString result;
if (m_TokenKind == tkClass)
return result << _T("class ") << m_Name << m_BaseArgs << _T(" {...}");
else if (m_TokenKind == tkNamespace)
return result << _T("namespace ") << m_Name << _T(" {...}");
else if (m_TokenKind == tkEnum)
return result << _T("enum ") << m_Name << _T(" {...}");
else if (m_TokenKind == tkTypedef)
{
result << _T("typedef");
if (!m_FullType.IsEmpty())
result << _T(" ") << m_FullType;
// we support 2 cases of typedef'd function pointers, and in each case the type is stored
// as below:
// typedef void (*dMessageFunction)(int errnum, const char *msg, va_list ap);
// --> type is stored as: (*)
// typedef void (MyClass::*Function)(int);
// --> type is stored as: (MyClass::*)
// so, ensure we really have ')' as the last char.
if (result.Find('*', true) != wxNOT_FOUND && result.Last() == ')')
{
result.RemoveLast();
return result << m_Name << _T(")") << GetFormattedArgs();
}
if (!m_TemplateArgument.IsEmpty())
result << m_TemplateArgument;
return result << _T(" ") << m_Name;
}
else if (m_TokenKind == tkMacroDef)
{
result << _T("#define ") << m_Name << GetFormattedArgs();
if (!m_FullType.IsEmpty())
result << _T(" ") << m_FullType;
return result;
}
// else
if (!m_FullType.IsEmpty())
result << m_FullType << m_TemplateArgument << _T(" ");
if (m_TokenKind == tkEnumerator)
return result << GetNamespace() << m_Name << _T("=") << GetFormattedArgs();
return result << GetNamespace() << m_Name << GetStrippedArgs();
}
XMLNode XMLNode::NewChild(const XMLNode& node, int n, bool global_order) {
if (node_ == NULL)
return XMLNode();
if (node.node_ == NULL)
return XMLNode();
if (node_->type != XML_ELEMENT_NODE)
return XMLNode();
// TODO: Add new attribute if 'node' is attribute
if (node.node_->type != XML_ELEMENT_NODE)
return XMLNode();
xmlNodePtr new_node = xmlDocCopyNode(node.node_, node_->doc, 1);
if (new_node == NULL)
return XMLNode();
if (n < 0)
return XMLNode(xmlAddChild(node_, new_node));
std::string name;
xmlNsPtr ns = GetNamespace(new_node);
if (ns != NULL) {
if (ns->prefix != NULL)
name = (char*)ns->prefix;
name += ":";
}
if (new_node->name)
name += (char*)(new_node->name);
XMLNode old_node = global_order ? Child(n) : operator[](name)[n];
if (!old_node)
// TODO: find last old_node
return XMLNode(xmlAddChild(node_, new_node));
if (old_node)
return XMLNode(xmlAddPrevSibling(old_node.node_, new_node));
return XMLNode(xmlAddChild(node_, new_node));
}
Namespace *SKS::GetNamespace(Position &pos, bool noName)
{
Namespace *name = new Namespace();
if(!noName)
name->SetName(GetName(pos));
while(true)
{
if(islineEndOfFile(pos))
{
break;
}
SkipComment(pos);
if(isLineNamespaceEnd(pos))
{
ExitNamespace(pos);
break;
}
else if(isLineNamespace(pos))
{
name->AddNamespace(GetNamespace(pos));
}
else if(isLineKeyValue(pos))
{
name->AddKeyValue(GetKeyValue(pos));
}
else
break;
}
return name;
}
/*RemoveAttribute - remove attribute from element
attname - name of attribute to remove
returns False on error
*/
Bool CXMLElement::RemoveAttribute(char *attname)
{
if (!isinited())
return False;
// OK-2009-01-06: [[Bug 7586]] - Remove the namespace if that is the name of the attribute.
// Not sure how reliable this is, it seems to work ok. The revXMLRemoveAttribute is not currently
// documented.
if (strcasecmp(attname, "xmlns") == 0)
{
xmlNsPtr t_namespace;
t_namespace = NULL;
GetNamespace(t_namespace);
if (t_namespace != NULL)
xmlFreeNs(t_namespace);
element -> ns = NULL;
element -> nsDef = NULL;
return True;
}
else
{
int res = xmlUnsetProp (element, (xmlChar *)attname);
return res == 0;
}
}
int litlist(ENODE *node)
{
struct slit *lp;
ENODE *ep;
lp = strtab;
while (lp) {
if (lp->isString)
continue;
ep = (ENODE *)lp->str;
if (node->IsEqual(node, ep)) {
return (lp->label);
}
lp = lp->next;
}
lp = (struct slit *)allocx(sizeof(struct slit));
lp->label = nextlabel++;
lp->str = (char *)node;
lp->nmspace = my_strdup(GetNamespace());
if (strtab == nullptr) {
strtab = lp;
strtab->tail = lp;
}
else {
strtab->tail->next = lp;
strtab->tail = lp;
}
lp->isString = false;
lp->pass = pass;
return (lp->label);
}
//
// Output all code and labels in the peep list.
//
void PeepList::flush()
{
static bool first = true;
txtoStream* oofs;
OCODE *ip;
/*
if (pass == 2) {
if (first) {
compiler.storeTables();
first = false;
}
oofs = new txtoStream();
oofs->open(irfile, std::ios::out | std::ios::app);
currentFn->pl.storeHex(*oofs);
oofs->close();
delete oofs;
}
*/
for (ip = head; ip; ip = ip->fwd)
{
if (ip->opcode == op_label)
put_label((int)ip->oper1, "", GetNamespace(), 'C');
else
ip->store(ofs);
}
}
std::string XMLNode::Namespace(void) const {
if (!node_)
return "";
xmlNsPtr ns = GetNamespace(node_);
if (!ns)
return "";
if (!(ns->href))
return "";
return (const char*)(ns->href);
}
wxString Token::DisplayName() const
{
// wxString result(_T(""));
// wxString parentname = GetParentName();
// if (!parentname.IsEmpty())
// result << parentname << _T("::");
wxString result = GetNamespace();
result << m_Name << m_Args;
if (!m_Type.IsEmpty())
result << _T(" : ") << m_Type;
return result;
}
/*
* output all code and labels in the peep list.
*/
void flush_peep()
{
if (opt_nopeep==FALSE)
opt_peep(); /* do the peephole optimizations */
while( peep_head != NULL )
{
if( peep_head->opcode == op_label )
put_label((int64_t)peep_head->oper1,"",GetNamespace(),'C');
else
put_ocode(peep_head);
peep_head = peep_head->fwd;
}
}
cc_string Token::DisplayName() const
{
cc_string result;
if (m_TokenKind == tkClass)
return result << cc_text("class ") << m_Name << m_RealArgs << cc_text(" {...}");
else if (m_TokenKind == tkNamespace)
return result << cc_text("namespace ") << m_Name << cc_text(" {...}");
else if (m_TokenKind == tkEnum)
return result << cc_text("enum ") << m_Name << cc_text(" {...}");
else if (m_TokenKind == tkTypedef)
{
result << cc_text("typedef");
if (!m_Type.empty())
result << cc_text(" ") << m_Type;
if (result.rfind('*') != cc_string::npos)
{
result.erase(result.end()-1,result.end());
return result << m_Name << cc_text(")") << m_Args;
}
return result << cc_text(" ") << m_Name;
}
else if (m_TokenKind == tkMacroDefine)
{
result << cc_text("#define ") << m_Name << m_Args;
if (!m_Type.empty())
return result << cc_text(" ") << m_Type;
}
// else
if (!m_Type.empty())
result << m_Type << cc_text(" ");
if (m_TokenKind == tkEnumerator)
return result << GetNamespace() << m_Name << cc_text("=") << m_Args;
return result << GetNamespace() << m_Name << m_Args;
}
void GenerateLabelReference(int n, int64_t offset)
{
char buf[200];
if( gentype == longgen && outcol < 58) {
if (offset==0)
sprintf_s(buf, sizeof(buf), ",%s_%d", GetNamespace(), n);
else
sprintf_s(buf, sizeof(buf), ",%s_%d+%lld", GetNamespace(), n, offset);
ofs.printf(buf);
outcol += 6;
}
else {
nl();
if (offset == 0)
sprintf_s(buf, sizeof(buf), "\tdw\t%s_%d", GetNamespace(), n);
else
sprintf_s(buf, sizeof(buf), "\tdw\t%s_%d+%lld", GetNamespace(), n, offset);
ofs.printf(buf);
outcol = 22;
gentype = longgen;
}
}
void doinit(SYM *sp)
{
char lbl[200];
lbl[0] = 0;
if (sp->storage_class == sc_thread) {
seg(tlsseg);
nl();
}
else if (sp->storage_class == sc_static || lastst==assign) {
seg(dataseg); /* initialize into data segment */
nl(); /* start a new line in object */
}
else {
seg(bssseg); /* initialize into data segment */
nl(); /* start a new line in object */
}
if(sp->storage_class == sc_static || sp->storage_class == sc_thread) {
put_label(sp->value.i, sp->name, GetNamespace(), 'D');
}
else {
if (sp->storage_class == sc_global) {
strcpy(lbl, "public ");
if (curseg==dataseg)
strcat(lbl, "data ");
else if (curseg==bssseg)
strcat(lbl, "bss ");
else if (curseg==tlsseg)
strcat(lbl, "tls ");
}
strcat(lbl, sp->name);
gen_strlab(lbl);
}
if( lastst != assign) {
genstorage(sp->tp->size);
}
else {
NextToken();
InitializeType(sp->tp);
}
endinit();
if (sp->storage_class == sc_global)
fprintf(output,"\nendpublic\n");
}
Namespace *SKS::GetNamespaceFromFile(const char *fileName)
{
// Creates a stream to read the file from
fstream sksFile(fileName, ios::in);
// Breaks of the file couldn't be open
if(sksFile.fail())
return NULL;
// Seek end of file
sksFile.seekg(0, ios::end);
// saves length of file
m_lengthOfFile = (unsigned int)sksFile.tellg();
// Seeks the beginning of the file
sksFile.seekg(0, ios::beg);
// Allocates memory for the file in memory
m_fileContents = new char [m_lengthOfFile];
// Reads the entire file
sksFile.read(m_fileContents, m_lengthOfFile);
sksFile.close();
// Currents position in the file
Position curPosition;
// Creates the namespace that gets filled with the info from the file
Namespace *topLevel;
// Adds sets the namespace without a name
topLevel = GetNamespace(curPosition, true);
// Sorts the names for a faster search
topLevel->SortIndexes();
// Deletes the character buffer
delete []m_fileContents;
m_fileContents = NULL;
return topLevel;
}
/*
* make s a string literal and return it's label number.
*/
int stringlit(char *s)
{
struct slit *lp;
lp = (struct slit *)allocx(sizeof(struct slit));
lp->label = nextlabel++;
lp->str = my_strdup(s);
lp->nmspace = my_strdup(GetNamespace());
if (strtab == nullptr) {
strtab = lp;
strtab->tail = lp;
}
else {
strtab->tail->next = lp;
strtab->tail = lp;
}
lp->isString = true;
lp->pass = pass;
return (lp->label);
}
int caselit(struct scase *cases, int64_t num)
{
struct c**t *lp;
lp = casetab;
while (lp) {
if (memcmp(lp->cases, cases, num * sizeof(struct scase)) == 0)
return (lp->label);
lp = lp->next;
}
lp = (struct c**t *)allocx(sizeof(struct c**t));
lp->label = nextlabel++;
lp->nmspace = my_strdup(GetNamespace());
lp->cases = (struct scase *)allocx(sizeof(struct scase)*(int)num);
lp->num = (int)num;
lp->pass = pass;
memcpy(lp->cases, cases, (int)num * sizeof(struct scase));
lp->next = casetab;
casetab = lp;
return lp->label;
}
int quadlit(Float128 *f128)
{
Float128 *lp;
lp = quadtab;
// First search for the same literal constant and it's label if found.
while(lp) {
if (Float128::IsEqual(f128,Float128::Zero())) {
if (Float128::IsEqualNZ(lp,f128))
return (lp->label);
}
else if (Float128::IsEqual(lp,f128))
return (lp->label);
lp = lp->next;
}
lp = (Float128 *)allocx(sizeof(Float128));
lp->label = nextlabel++;
Float128::Assign(lp,f128);
lp->nmspace = my_strdup(GetNamespace());
lp->next = quadtab;
quadtab = lp;
return (lp->label);
}
/*SetAttribute - set attribute value in element
attname-attribute name
tdata - new value
returns False on error
*/
Bool CXMLElement::SetAttribute(char *attname,char *tdata)
{
if (!isinited())
return False;
// OK-2009-01-06: [[Bug 7586]] - When setting attributes, check to see if the user is trying to set the namespace.
// If they are, then either create a namespace, or modify the existing one. Note that this doesn't support multiple
// namespaces, not sure if this is a problem or not.
xmlAttrPtr tatt;
if (strcasecmp(attname, "xmlns") == 0)
{
xmlNs *t_namespace;
t_namespace = NULL;
GetNamespace(t_namespace);
if (t_namespace != NULL && t_namespace -> href != NULL)
{
// Free the old href buffer, and replace it with a new one
xmlFree((xmlChar* )t_namespace -> href);
t_namespace -> href = xmlStrdup((xmlChar *)tdata);
// Replace the existing namespace with the modified one
xmlSetNs(element, t_namespace);
}
else
{
// No namespace exists, so we just create one.
t_namespace = xmlNewNs(element, (xmlChar *)tdata, NULL);
}
return True;
}
else
{
tatt = xmlSetProp(element, (xmlChar *)attname, (xmlChar *)tdata);
return tatt != NULL;
}
}
/*GetAttribute - returns value of specified attribute
attname - name of attribute to look for
isbuffered - if true returns copy of attribute value (must be freed by caller).
returns NULL if specified attribute not found
*/
char *CXMLElement::GetAttributeValue(char *attname, Bool isbuffered)
{
if (!isinited())
return NULL;
// OK-2009-01-05: [[Bug 7586]] - Some elements may have a "namespace". This is not regarded by libXML
// as one of the elements' attributes, but is stored separately. If the required attribute is called
// "xmlns", then we retreive the namespace instead of using GetAttributeValue.
if (strcasecmp(attname, "xmlns") == 0)
{
xmlNs *t_namespace;
t_namespace = NULL;
GetNamespace(t_namespace);
if (t_namespace != NULL && t_namespace -> href != NULL)
{
return strdup((char *)t_namespace -> href);
}
}
if (isbuffered)
{
CXMLAttribute tattribute;
if (GetFirstAttribute(&tattribute))
{
int attributecount = 1;
do
{
if (!attname || util_strnicmp(tattribute.GetName(), attname, strlen(attname)) == 0)
return tattribute.GetContent();
} while (tattribute.GoNext());
}
}
else
return (char *)xmlGetProp(element, (xmlChar *)attname);
return NULL;
}
// Check for any problems with WeakPtrFactory class members. This currently
// only checks that any WeakPtrFactory<T> member of T appears as the last
// data member in T. We could consider checking for bad uses of
// WeakPtrFactory to refer to other data members, but that would require
// looking at the initializer list in constructors to see what the factory
// points to.
// Note, if we later add other unrelated checks of data members, we should
// consider collapsing them in to one loop to avoid iterating over the data
// members more than once.
void FindBadConstructsConsumer::CheckWeakPtrFactoryMembers(
SourceLocation record_location,
CXXRecordDecl* record) {
// Skip anonymous structs.
if (record->getIdentifier() == NULL)
return;
// Iterate through members of the class.
RecordDecl::field_iterator iter(record->field_begin()),
the_end(record->field_end());
SourceLocation weak_ptr_factory_location; // Invalid initially.
for (; iter != the_end; ++iter) {
// If we enter the loop but have already seen a matching WeakPtrFactory,
// it means there is at least one member after the factory.
if (weak_ptr_factory_location.isValid()) {
diagnostic().Report(weak_ptr_factory_location,
diag_weak_ptr_factory_order_);
}
const TemplateSpecializationType* template_spec_type =
iter->getType().getTypePtr()->getAs<TemplateSpecializationType>();
if (template_spec_type) {
const TemplateDecl* template_decl =
template_spec_type->getTemplateName().getAsTemplateDecl();
if (template_decl && template_spec_type->getNumArgs() >= 1) {
if (template_decl->getNameAsString().compare("WeakPtrFactory") == 0 &&
GetNamespace(template_decl) == "base") {
const TemplateArgument& arg = template_spec_type->getArg(0);
if (arg.getAsType().getTypePtr()->getAsCXXRecordDecl() ==
record->getTypeForDecl()->getAsCXXRecordDecl()) {
weak_ptr_factory_location = iter->getLocation();
}
}
}
}
}
}
void ParseFunctionBody(SYM *sp)
{
char lbl[200];
needpunc(begin);
ParseAutoDeclarations();
cseg();
if (sp->storage_class == sc_static)
{
strcpy(lbl,GetNamespace());
strcat(lbl,"_");
strcat(lbl,sp->name);
gen_strlab(lbl);
}
// put_label((unsigned int) sp->value.i);
else
gen_strlab(sp->name);
currentFn = sp;
currentFn->IsLeaf = TRUE;
currentFn->DoesThrow = FALSE;
GenerateFunction(sp, ParseCompoundStatement());
// if (optimize)
flush_peep();
}
bool FindBadConstructsConsumer::InTestingNamespace(const Decl* record) {
return GetNamespace(record).find("testing") != std::string::npos;
}
void doinit(SYM *sp)
{
char lbl[200];
int algn;
enum e_sg oseg;
oseg = noseg;
lbl[0] = 0;
// Initialize constants into read-only data segment. Constants may be placed
// in ROM along with code.
if (sp->isConst) {
oseg = rodataseg;
}
if (sp->storage_class == sc_thread) {
if (sp->tp->type==bt_struct || sp->tp->type==bt_union)
algn = imax(sp->tp->alignment,2);
else if (sp->tp->type==bt_pointer && sp->tp->val_flag)
algn = imax(sp->tp->GetBtp()->alignment,2);
else
algn = 2;
seg(oseg==noseg ? tlsseg : oseg,algn);
nl();
}
else if (sp->storage_class == sc_static || lastst==assign) {
if (sp->tp->type==bt_struct || sp->tp->type==bt_union)
algn = imax(sp->tp->alignment,2);
else if (sp->tp->type==bt_pointer && sp->tp->val_flag)
algn = imax(sp->tp->GetBtp()->alignment,2);
else
algn = 2;
seg(oseg==noseg ? dataseg : oseg,algn); /* initialize into data segment */
nl(); /* start a new line in object */
}
else {
if (sp->tp->type==bt_struct || sp->tp->type==bt_union)
algn = imax(sp->tp->alignment,2);
else if (sp->tp->type==bt_pointer && sp->tp->val_flag)
algn = imax(sp->tp->GetBtp()->alignment,2);
else
algn = 2;
seg(oseg==noseg ? bssseg : oseg,algn); /* initialize into data segment */
nl(); /* start a new line in object */
}
if(sp->storage_class == sc_static || sp->storage_class == sc_thread) {
sp->realname = my_strdup(put_label(sp->value.i, (char *)sp->name->c_str(), GetNamespace(), 'D'));
}
else {
if (sp->storage_class == sc_global) {
strcpy_s(lbl, sizeof(lbl), "public ");
if (curseg==dataseg)
strcat_s(lbl, sizeof(lbl), "data ");
else if (curseg==bssseg)
strcat_s(lbl, sizeof(lbl), "bss ");
else if (curseg==tlsseg)
strcat_s(lbl, sizeof(lbl), "tls ");
}
strcat_s(lbl, sizeof(lbl), sp->name->c_str());
gen_strlab(lbl);
}
if (lastst == kw_firstcall) {
GenerateByte(1);
return;
}
else if( lastst != assign) {
genstorage(sp->tp->size);
}
else {
NextToken();
InitializeType(sp->tp);
}
endinit();
if (sp->storage_class == sc_global)
ofs.printf("\nendpublic\n");
}
void GenerateReference(SYM *sp,int64_t offset)
{
char sign;
if( offset < 0) {
sign = '-';
offset = -offset;
}
else
sign = '+';
if( gentype == longgen && outcol < 55 - (int)sp->name->length()) {
if( sp->storage_class == sc_static) {
ofs.printf(",");
ofs.printf(GetNamespace());
ofs.printf("_%lld", sp->value.i);
ofs.putch(sign);
ofs.printf("%lld", offset);
// fprintf(output,",%s_%ld%c%d",GetNamespace(),sp->value.i,sign,offset);
}
else if( sp->storage_class == sc_thread) {
ofs.printf(",");
ofs.printf(GetNamespace());
ofs.printf("_%lld", sp->value.i);
ofs.putch(sign);
ofs.printf("%lld", offset);
// fprintf(output,",%s_%ld%c%d",GetNamespace(),sp->value.i,sign,offset);
}
else {
if (offset==0) {
ofs.printf(",%s",(char *)sp->name->c_str());
}
else {
ofs.printf(",%s",(char *)sp->name->c_str());
ofs.putch(sign);
ofs.printf("%lld",offset);
}
}
outcol += (11 + sp->name->length());
}
else {
nl();
if(sp->storage_class == sc_static) {
ofs.printf("\tdw\t%s",GetNamespace());
ofs.printf("_%lld",sp->value.i);
ofs.putch(sign);
ofs.printf("%lld",offset);
// fprintf(output,"\tdw\t%s_%ld%c%d",GetNamespace(),sp->value.i,sign,offset);
}
else if(sp->storage_class == sc_thread) {
// fprintf(output,"\tdw\t%s_%ld%c%d",GetNamespace(),sp->value.i,sign,offset);
ofs.printf("\tdw\t%s",GetNamespace());
ofs.printf("_%lld",sp->value.i);
ofs.putch(sign);
ofs.printf("%lld",offset);
}
else {
if (offset==0) {
ofs.printf("\tdw\t%s",(char *)sp->name->c_str());
}
else {
ofs.printf("\tdw\t%s",(char *)sp->name->c_str());
ofs.putch(sign);
ofs.printf("%lld", offset);
// fprintf(output,"\tdw\t%s%c%d",sp->name,sign,offset);
}
}
outcol = 26 + sp->name->length();
gentype = longgen;
}
}
void doinit(SYM *sp)
{
static bool first = true;
char lbl[200];
int algn;
enum e_sg oseg;
char buf[500];
std::streampos endpoint;
TYP *tp;
hasPointer = false;
if (first) {
firstPrim = true;
first = false;
}
oseg = noseg;
lbl[0] = 0;
// Initialize constants into read-only data segment. Constants may be placed
// in ROM along with code.
if (sp->isConst) {
oseg = rodataseg;
}
if (sp->storage_class == sc_thread) {
if (sp->tp->type==bt_struct || sp->tp->type==bt_union)
algn = imax(sp->tp->alignment,8);
else if (sp->tp->type==bt_pointer)// && sp->tp->val_flag)
algn = imax(sp->tp->GetBtp()->alignment,8);
else
algn = 2;
seg(oseg==noseg ? tlsseg : oseg,algn);
nl();
}
else if (sp->storage_class == sc_static || lastst==assign) {
if (sp->tp->type==bt_struct || sp->tp->type==bt_union)
algn = imax(sp->tp->alignment,8);
else if (sp->tp->type==bt_pointer)// && sp->tp->val_flag)
algn = imax(sp->tp->GetBtp()->alignment,8);
else
algn = 2;
seg(oseg==noseg ? dataseg : oseg,algn); /* initialize into data segment */
nl(); /* start a new line in object */
}
else {
if (sp->tp->type==bt_struct || sp->tp->type==bt_union)
algn = imax(sp->tp->alignment,8);
else if (sp->tp->type==bt_pointer)// && sp->tp->val_flag)
algn = imax(sp->tp->GetBtp()->alignment,8);
else
algn = 2;
seg(oseg==noseg ? (lastst==assign ? dataseg : bssseg) : oseg,algn); /* initialize into data segment */
nl(); /* start a new line in object */
}
if (sp->storage_class == sc_static || sp->storage_class == sc_thread) {
//strcpy_s(glbl, sizeof(glbl), gen_label((int)sp->value.i, (char *)sp->name->c_str(), GetNamespace(), 'D'));
if (sp->tp->IsSkippable()) {
patchpoint = ofs.tellp();
sprintf_s(buf, sizeof(buf), "\talign\t8\n\tdw\t$FFF0200000000001\n");
ofs.printf(buf);
}
sp->realname = my_strdup(put_label((int)sp->value.i, (char *)sp->name->c_str(), GetNamespace(), 'D'));
strcpy_s(glbl2, sizeof(glbl2), gen_label((int)sp->value.i, (char *)sp->name->c_str(), GetNamespace(), 'D'));
}
else {
if (sp->storage_class == sc_global) {
strcpy_s(lbl, sizeof(lbl), "public ");
if (curseg==dataseg)
strcat_s(lbl, sizeof(lbl), "data ");
else if (curseg==bssseg)
strcat_s(lbl, sizeof(lbl), "bss ");
else if (curseg==tlsseg)
strcat_s(lbl, sizeof(lbl), "tls ");
}
strcat_s(lbl, sizeof(lbl), sp->name->c_str());
if (sp->tp->IsSkippable()) {
patchpoint = ofs.tellp();
sprintf_s(buf, sizeof(buf), "\talign\t8\n\tdw\t$FFF0200000000001\n");
ofs.printf(buf);
}
strcpy_s(glbl2, sizeof(glbl2), sp->name->c_str());
gen_strlab(lbl);
}
if (lastst == kw_firstcall) {
GenerateByte(1);
return;
}
else if( lastst != assign) {
hasPointer = sp->tp->FindPointer();
genstorage(sp->tp->size);
}
else {
NextToken();
hasPointer = sp->tp->FindPointer();
typ_sp = 0;
tp = sp->tp;
push_typ(tp);
while (tp = tp->GetBtp()) {
push_typ(tp);
}
brace_level = 0;
sp->tp->Initialize(nullptr);
if (sp->tp->numele == 0) {
if (sp->tp->GetBtp()) {
if (sp->tp->GetBtp()->type == bt_char || sp->tp->GetBtp()->type == bt_uchar
|| sp->tp->GetBtp()->type == bt_ichar || sp->tp->GetBtp()->type == bt_iuchar
) {
sp->tp->numele = laststrlen;
sp->tp->size = laststrlen;
}
}
}
}
if (!hasPointer && sp->tp->IsSkippable()) {
endpoint = ofs.tellp();
ofs.seekp(patchpoint);
sprintf_s(buf, sizeof(buf), "\talign\t8\n\tdw\t$%I64X\n", ((genst_cumulative + 7LL) >> 3LL) | 0xFFF0200000000000LL);
ofs.printf(buf);
ofs.seekp(endpoint);
genst_cumulative = 0;
}
