public void SetStrictNameSpaces(bool b) { strictNameSpaces = b; }
AccessMode declMode = privateAccess;
-public void SetDeclMode(AccessMode accessMode) { declMode = accessMode; }
+AccessMode structDeclMode = privateAccess;
+
+public void SetDeclMode(AccessMode accessMode) { structDeclMode = declMode = accessMode; }
AccessMode defaultDeclMode = privateAccess;
public void SetDefaultDeclMode(AccessMode accessMode) { defaultDeclMode = accessMode; }
{
Identifier id { };
int c;
-
+
id._class = null; // Default class...
if(string)
else
id.string = CopyString(string);
}
- }
+ }
}
else if(gotColon)
{
}
};
-Map<ContextStringPair, List<Location> > intlStrings { };
+Map<ContextStringPair, List<Location>> intlStrings { };
Expression MkExpIntlString(char * string, char * context)
{
}
list.Add(yylloc);
}
- ListAdd(list, QMkExpId("__thisModule"));
+ //ListAdd(list, QMkExpId("__thisModule"));
+ ListAdd(list, MkExpString(QMkString(i18nModuleName ? i18nModuleName : "")));
ListAdd(list, MkExpString(string));
if(context)
{
Specifier MkSpecifier(int specifier)
{
- return { type = baseSpecifier, specifier = specifier };
+ if(specifier == _BOOL && (declMode != defaultAccess && defaultDeclMode != defaultAccess))
+ return MkSpecifierName("bool");
+ else if(specifier == _BOOL || specifier == BOOL)
+ return { type = baseSpecifier, specifier = specifier };
+ else
+ return { type = baseSpecifier, specifier = specifier };
}
Specifier MkSpecifierTypeOf(Expression expression)
Specifier MkEnum(Identifier id, OldList list)
{
- Specifier spec
+ Specifier spec
{
type = enumSpecifier;
id = id;
{
Specifier spec { type = type, id = id };
if(id && FindType(curContext, id.string))
- declMode = defaultAccess;
+ structDeclMode = defaultAccess;
spec.definitions = definitions;
- if(definitions && id && !declMode)
+ if(definitions && id && structDeclMode == defaultAccess)
{
OldList specs { };
Symbol symbol;
{
Declaration decl { type = initDeclaration, declarators = initDeclarators, specifiers = specifiers, loc = yylloc };
bool variable = true;
-
+
if(specifiers != null)
{
bool gotType = false;
if(initDeclarators != null)
{
InitDeclarator d;
-
+
for(d = initDeclarators.first; d; d = d.next)
{
if(GetDeclId(d.declarator).string)
variable = false;
break;
}
- else if(spec.type == baseSpecifier &&
+ else if(spec.type == baseSpecifier &&
(spec.specifier == STRUCT || spec.specifier == UNION))
variable = false;
else
delete id.string;
id.string = CopyString(name);
}
-
+
// Avoid memory leaks on duplicated symbols (BinaryTree::Add Would Fail)
symbol = (Symbol)(curContext.templateTypesOnly ? curContext.parent : curContext).symbols.FindString(id.string);
if(!symbol)
}
if(s)
{
- decl.declarators = declarators = MkListOne(MkDeclaratorIdentifier(MkIdentifier(s)));
+ decl.declarators = declarators = MkListOne(MkStructDeclarator(MkDeclaratorIdentifier(MkIdentifier(s)), null));
specifiers.Remove(spec);
FreeSpecifier(spec);
spec = null;
for(spec = function.specifiers->first; spec; spec = spec.next)
if(spec.type == baseSpecifier && spec.specifier == STATIC)
{
- declMode = staticAccess;
+ structDeclMode = declMode = staticAccess;
break;
}
}
for(spec = declaration.specifiers->first; spec; spec = spec.next)
if(spec.type == baseSpecifier && spec.specifier == TYPEDEF)
{
- declMode = defaultAccess;
+ structDeclMode = declMode = defaultAccess;
break;
}
else if(spec.type == baseSpecifier && spec.specifier == STATIC)
{
- declMode = staticAccess;
+ structDeclMode = declMode = staticAccess;
break;
}
}
fileInput = backFileInput;
if(fileInput)
{
- fileInput.Seek(yylloc.start.pos, start);
+ fileInput.Seek(yylloc.start.pos, start);
resetScannerPos(&yylloc.start);
yychar = -2;
}
}
}
else if(symbol)
- spec.name = CopyString(symbol.string);
+ spec.name = CopyString(symbol.string);
else
spec.name = CopyString(name);
spec.symbol = symbol;
symbol = Symbol
{
-
+
};
{
}
FreeList(specs, FreeSpecifier);
-
+
if(!spec)
{
Compiler_Error($"Expecting class specifier\n");
for(classContext = curContext; classContext && !classContext.classDef; classContext = classContext.parent);
if(classContext)
{
-
+
}
*/
if(name[0] == ':' && name[1] == ':')
strcpy(name, ((Specifier)baseSpecs.first).name);
tpl = strchr(name, '<');
if(tpl) *tpl = 0;
-
+
baseClass = FindClass(name);
- if(baseClass.ctx)
+ if(baseClass && baseClass.ctx)
{
TemplatedType copy;
for(copy = (TemplatedType)baseClass.ctx.templateTypes.first; copy; copy = (TemplatedType)copy.next)
delete type;
}
}
- else if(baseClass.registered)
+ else if(baseClass && baseClass.registered)
{
Class sClass;
for(sClass = baseClass.registered; sClass; sClass = sClass.base)
{
p.param = param = TemplateParameter
{
- identifier = MkIdentifier(p.name), type = p.type,
+ identifier = MkIdentifier(p.name), type = p.type,
dataTypeString = p.dataTypeString /*, dataType = { specs, decl }*/
};
}
bool ModuleAccess(Module searchIn, Module searchFor)
{
SubModule subModule;
-
+
if(searchFor == searchIn)
return true;
break;
if(!module)
{
- module = ModuleImport
- {
+ module = ModuleImport
+ {
name = CopyString(moduleToFind.name), importType = moduleToFind.importType,
importAccess = ModuleAccess(privateModule, moduleToFind) ? publicAccess : privateAccess
};
{
GetFullClassNameSpace(ns->parent, name);
strcat(name, ns->name);
- strcat(name, "::");
+ strcat(name, "::");
}
}
}
*/
if(cl.shortName && !strcmp(cl.shortName, name))
- break;
+ break;
}
#ifdef _TIMINGS
findClassIgnoreNSTotalTime += GetTime() - startTime;
else if(spec.specifier == VOID) specType.kind = voidType;
else if(spec.specifier == CHAR) specType.kind = charType;
else if(spec.specifier == INT) { if(specType.kind != shortType && specType.kind != longType && !isLong) specType.kind = intType; }
+ else if(spec.specifier == _BOOL || spec.specifier == BOOL)
+ specType.kind = _BoolType;
else if(spec.specifier == UINT) { if(specType.kind != shortType && specType.kind != longType) specType.kind = intType; specType.isSigned = false; }
else if(spec.specifier == INT64) specType.kind = int64Type;
- else if(spec.specifier == VALIST)
+ else if(spec.specifier == VALIST)
specType.kind = vaListType;
else if(spec.specifier == SHORT) specType.kind = shortType;
- else if(spec.specifier == LONG)
+ else if(spec.specifier == LONG)
{
if(isLong || (targetBits == 64 && targetPlatform != win32))
specType.kind = int64Type;
else if(spec.specifier == CONST)
specType.constant = true;
else if(spec.specifier == TYPED_OBJECT || spec.specifier == ANY_OBJECT || spec.specifier == CLASS)
- {
+ {
switch(spec.specifier)
{
case TYPED_OBJECT: specType.classObjectType = typedObject; break;
Symbol _class = spec.id ? FindClass(spec.id.string) : null;
if(_class)
{
+ specType.declaredWithStruct = true;
if(!_class.registered || _class.registered.type != structClass)
- specType.directClassAccess = true;
+ specType.directClassAccess = true; // TODO: Need to clarify what 'directClassAccess' is about
specType._class = _class;
specType.kind = classType;
break;
}
+ specType.members.Clear();
if(spec.type == structSpecifier)
specType.kind = structType;
else if(spec.type == unionSpecifier)
specType.kind = unionType;
if(spec.id)
{
- // TESTING THIS HERE... Had 0 type size
+ // TESTING THIS HERE... Had 0 type size
if(!spec.definitions && !isTypedef)
{
Symbol symbol = spec.id.string ? FindSymbol(spec.id.string, curContext, globalContext, true, false) : null;
}
else if(assumeEllipsis)
specType.kind = ellipsisType;
- return specType;
+ return specType;
}
static Type ProcessTypeDecls(OldList specs, Declarator decl, Type parentType)
{
type = { refCount = 1, kind = arrayType, arraySizeExp = CopyExpression(decl.array.exp), freeExp = true, type = type, dllExport = type.dllExport, attrStdcall = type.attrStdcall };
if(decl.array.enumClass)
- type.enumClass = decl.array.enumClass.symbol;
+ type.enumClass = decl.array.enumClass.symbol;
break;
}
case pointerDeclarator:
return null;
}
-AsmField MkAsmField(char * command, Expression expression)
+AsmField MkAsmField(char * command, Expression expression, Identifier symbolic)
{
- return { command = command, expression = expression };
+ return { command = command, expression = expression, symbolic = symbolic };
}
Statement MkAsmStmt(Specifier spec, char * statements, OldList inputFields, OldList outputFields, OldList clobberedFields)
{
- return { type = asmStmt, asmStmt.spec = spec, asmStmt.statements = statements,
- asmStmt.inputFields = inputFields, asmStmt.outputFields = outputFields,
+ return { type = asmStmt, asmStmt.spec = spec, asmStmt.statements = statements,
+ asmStmt.inputFields = inputFields, asmStmt.outputFields = outputFields,
asmStmt.clobberedFields = clobberedFields };
}
char idString[32];
char className[1024];
Expression classExp;
-
+
sprintf(idString, "%d", id);
strcpy(className, "__ecereClass_");
FullClassNameCat(className, _class.fullName, true);
DeclareClass(FindClass(_class.fullName), className);
argExp = MkExpIndex((/*pointer ? MkExpPointer : */MkExpMember)
- (MkExpMember(MkExpIdentifier(MkIdentifier("this")), MkIdentifier("_class")) /*MkExpIdentifier(MkIdentifier(className))*/,
+ (MkExpMember(MkExpIdentifier(MkIdentifier("this")), MkIdentifier("_class")) /*MkExpIdentifier(MkIdentifier(className))*/,
MkIdentifier("templateArgs")), MkListOne(MkExpConstant(idString)));
}
}
- return argExp;
+ return argExp;
}
Expression GetTemplateArgExp(TemplateParameter param, Class curClass, bool pointer)
default extern OldList * ast;
default extern int yyparse ();
+default extern int yylex ();
public void SetAST(OldList * list) { ast = list; }
public OldList * GetAST() { return ast; }
{
yyparse();
}
+
+public int LexEc()
+{
+ return yylex();
+}
+
+public const char * GetYYText()
+{
+ return yytext;
+}