return { type = stringExp, string = CopyString(string), loc = yylloc };
}
+Expression MkExpWideString(const char * string)
+{
+ return { type = stringExp, string = CopyString(string), loc = yylloc, wideString = true };
+}
+
// TODO: String is case sensitive..
// What should we do about it?
/*public class CaseSensitiveString : String
string = (inst.exp.type == identifierExp) ? CopyString(inst.exp.identifier.string) : null;
type = MkClassTypeSymbol(inst._class.symbol);
};
- symbol.idCode = symbol.id = curContext.nextID++;
if(strstr(symbol.string, "::"))
curContext.hasNameSpace = true;
if(!(curContext.templateTypesOnly ? curContext.parent : curContext).symbols.Add((BTNode)symbol))
string = CopyString(GetDeclId(d.declarator).string);
type = ProcessType(specifiers, d.declarator);
};
- type.id = type.idCode = curContext.nextID++;
if(!(curContext.templateTypesOnly ? curContext.parent : curContext).types.Add((BTNode)type))
excludedSymbols->Add(type);
if(s)
{
Symbol type { string = CopyString(s), type = ProcessType(specifiers, null) };
- type.id = type.idCode = curContext.nextID++;
decl.symbol = type;
decl.declarators = initDeclarators = MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(s)), null));
specifiers.Remove(spec);
symbol.type.freeExp = true;
}
}
- symbol.id = symbol.idCode = curContext.nextID++;
}
decl.symbol = d.declarator.symbol = symbol;
}
else
{
decl.symbol = Symbol { };
- decl.symbol.id = decl.symbol.idCode = curContext.nextID++;
excludedSymbols->Add(decl.symbol);
}
return decl;
if(!context.symbols.Add((BTNode)symbol))
excludedSymbols->Add(symbol);
- // TODO: Fix this, the parameters' IDs should really be smaller...
- symbol.id = context.nextID++;
param.declarator.symbol = symbol;
}
}
id.string = CopyString(name);
}
symbol = Symbol { string = CopyString(id.string), type = ProcessType(func.specifiers, declarator) };
- symbol.idCode = symbol.id = globalContext.nextID++;
if(strstr(symbol.string, "::"))
globalContext.hasNameSpace = true;
if(!globalContext.symbols.Add((BTNode)symbol))
if(!symbol && spec.symbol)
{
// If class was only decl'ed, invoke DeclClass on this templated class as well
- symbol = _DeclClass(MAXINT, templateString);
+ symbol = _DeclClass(null, templateString);
+ symbol.notYetDeclared = true;
}
// Add a reference to all templated class to the basic class
if(spec.symbol)
}
}
else if(symbol)
+ {
+ char nameSpace[1024];
+ char * c = strstr(name, symbol.string);
spec.name = CopyString(symbol.string);
+ if(c && c >= name + 2 && c[-1] == ':' && c[-2] == ':')
+ {
+ if(c > name + 2)
+ {
+ memcpy(nameSpace, name, c - name - 2);
+ nameSpace[c-name] = 0;
+ spec.nsSpec = _MkSpecifierName(nameSpace, null, null);
+ }
+ else
+ spec.nsSpec = _MkSpecifierName(null, null, null);
+ }
+ }
else
spec.name = CopyString(name);
spec.symbol = symbol;
isParam = true;
};
- // TODO: Fix this, the parameters' IDs should really be smaller...
- symbol.idCode = symbol.id = context.nextID++;
if(!context.symbols.Add((BTNode)symbol))
excludedSymbols->Add(symbol);
symbolSpecs->Add(CopySpecifier(spec));
}
symbol.type = ProcessType(symbolSpecs, decl);
- symbol.idCode = symbol.id = globalContext.nextID++;
decl.symbol = symbol;
excludedSymbols->Add(symbol);
return def;
}
-Symbol DeclClassAddNameSpace(int symbolID, const char * className)
+Symbol DeclClassAddNameSpace(Specifier _class, const char * className)
{
char name[1024];
int len = 0, stringLen;
name[0] = '\0';
- if((currentNameSpace || defaultNameSpace) && declMode != defaultAccess && defaultDeclMode != defaultAccess)
+ if(className[0] != ':' && (currentNameSpace || defaultNameSpace) && declMode != defaultAccess && defaultDeclMode != defaultAccess && (!_class || _class.name))
{
if(defaultNameSpace)
{
memcpy(name + len, className, stringLen);
len += stringLen;
name[len] = 0;
- return _DeclClass(symbolID, name);
+ return _DeclClass(_class, name);
}
-Symbol DeclClass(int symbolID, const char * name)
+Symbol DeclClass(Specifier _class, const char * name)
{
- if(strchr(name, ':'))
- return _DeclClass(symbolID, name);
+ if(_class || strchr(name, ':'))
+ return _DeclClass(_class, name);
else
- return DeclClassAddNameSpace(symbolID, name);
+ return DeclClassAddNameSpace(_class, name);
}
-Symbol _DeclClass(int symbolID, const char * name)
+Symbol _DeclClass(Specifier _class, const char * name)
{
- Symbol symbol = FindClass(name);
+ Symbol symbol;
+ char nameBuffer[1024];
+ if(_class)
+ {
+ strcpy(nameBuffer, _class.name ? _class.name : "");
+ strcat(nameBuffer, "::");
+ strcat(nameBuffer, name);
+ name = nameBuffer;
+ }
+
+ symbol = FindClass(name);
if(!symbol)
{
/*
symbol = Symbol
{
string = CopyString(name);
- idCode = symbolID, id = symbolID;
+ notYetDeclared = true;
};
if(!globalContext.classes.Add((BTNode)symbol))
excludedSymbols->Add(symbol);
symbol.shortName = CopyString(name + start);
}
}
- if(symbolID)
- symbol.idCode = symbol.id = symbolID;
return symbol;
}
delete symbol.ctx;
}
symbol.ctx = curContext;
- classDef = { symbol = symbol, _class = MkSpecifierName /*MkClassName*/(symbol.string), baseSpecs = baseSpecs, definitions = definitions, nameLoc = symbol.nameLoc };
+ classDef = { symbol = symbol, _class = MkSpecifierName(symbol.string), baseSpecs = baseSpecs, definitions = definitions, nameLoc = symbol.nameLoc };
curContext.classDef = classDef;
return classDef;
}
string = CopyString(id.string);
type = type;
};
- symbol.idCode = symbol.id = globalContext.nextID++;
excludedSymbols->Add(symbol);
- globalContext.nextID++;
- globalContext.nextID++;
prop.symbol = symbol;
return prop;
}
Symbol FindType(Context ctx, const char * name)
{
Symbol type = null;
- if(curContext)
+ if(ctx)
{
//char output[8192];
type = (Symbol)ctx.types.FindString(name);
return type;
}
+Symbol FindStruct(Context ctx, const char * name)
+{
+ Symbol type = null;
+ if(ctx)
+ {
+ type = (Symbol)ctx.structSymbols.FindString(name);
+ if(!type && ctx.parent)
+ type = FindStruct(ctx.parent, name);
+ }
+ return type;
+}
+
TemplatedType FindTemplateTypeParameter(Context ctx, const char * name)
{
TemplatedType templatedType = null;
{
string = CopyString(name);
registered = _class;
- id = MAXINT;
- idCode = MAXINT;
+ notYetDeclared = true;
imported = true;
};
_class.symbol = cl;
{
type = *src;
type.name = CopyString(src.name);
+ type.typeName = CopyString(src.typeName);
type.refCount = 1;
if(src.kind == enumType)
if(type.arraySizeExp)
type.arraySizeExp = CopyExpression(type.arraySizeExp);
}
-
}
}
sprintf(idString, "%d", id);
strcpy(className, "__ecereClass_");
FullClassNameCat(className, _class.fullName, true);
- //MangleClassName(className);
- DeclareClass(FindClass(_class.fullName), className);
+ DeclareClass(curExternal, FindClass(_class.fullName), className);
argExp = MkExpIndex((/*pointer ? MkExpPointer : */MkExpMember)
(MkExpMember(MkExpIdentifier(MkIdentifier("this")), MkIdentifier("_class")) /*MkExpIdentifier(MkIdentifier(className))*/,
{
const char * filePrefix = "";
if(!(srcFile[0] && (srcFile[1] == ':' || srcFile[0] == '/')))
- filePrefix = "./"; //(GetRuntimePlatform() == win32) ? ".\\" : "./";
+ filePrefix = "./"; //(__runtimePlatform == win32) ? ".\\" : "./";
// GetSystemPathBuffer(srcFileFixed, srcFile);
GetSlashPathBuffer(srcFileFixed, srcFile);