_int = INT,
_uint = UINT,
_int64 = INT64,
+ _int128 = INT128,
_long = LONG,
_signed = SIGNED,
_unsigned = UNSIGNED,
_default = DEFAULT,
_if = IF,
_switch = SWITCH,
- _whilte = WHILE,
+ _while = WHILE,
_do = DO,
_for = FOR,
_goto = GOTO,
bool inCompiler = false;
public void SetInCompiler(bool b) { inCompiler = b; }
+bool inDebugger = false;
+public void SetInDebugger(bool b) { inDebugger = b; }
+
Context curContext;
Context globalContext;
OldList * excludedSymbols;
// todo support %var% variables for windows and $var for linux?
public char * PassArg(char * output, const char * input)
{
-#ifdef __WIN32__
-//define windowsFileNameCharsNeedEscaping = " !%&'()+,;=[]^`{}~"; // "#$-.@_" are ok
- const char * escChars = " !\"%&'()+,;=[]^`{}~"; // windowsFileNameCharsNeedEscaping;
- const char * escCharsQuoted = "\"";
-#else
-//define linuxFileNameCharsNeedEscaping = " !\"$&'()*:;<=>?[\\`{|"; // "#%+,-.@]^_}~" are ok
- const char * escChars = " !\"$&'()*:;<=>?[\\`{|"; // linuxFileNameCharsNeedEscaping;
- const char * escCharsQuoted = "\"()$";
-#endif
+ const char * escChars, * escCharsQuoted;
bool quoting = false;
char *o = output;
const char *i = input, *l = input;
-#ifdef __WIN32__
- while(*l && !strchr(escChars, *l)) l++;
- if(*l) quoting = true;
-#else
- if(*i == '-')
+ if(__runtimePlatform == win32)
{
- l++;
+//define windowsFileNameCharsNeedEscaping = " !%&'()+,;=[]^`{}~"; // "#$-.@_" are ok
+ escChars = " !\"%&'()+,;=[]^`{}~"; // windowsFileNameCharsNeedEscaping;
+ escCharsQuoted = "\"";
while(*l && !strchr(escChars, *l)) l++;
if(*l) quoting = true;
- *o++ = *i++;
}
-#endif
+//define linuxFileNameCharsNeedEscaping = " !\"$&'()*:;<=>?[\\`{|"; // "#%+,-.@]^_}~" are ok
+ else
+ {
+ escChars = " !\"$&'()*:;<=>?[\\`{|"; // linuxFileNameCharsNeedEscaping;
+ escCharsQuoted = "\"()$";
+ if(*i == '-')
+ {
+ l++;
+ while(*l && !strchr(escChars, *l)) l++;
+ if(*l) quoting = true;
+ *o++ = *i++;
+ }
+ }
if(quoting)
*o++ = '\"';
while(*i)
extensionCompoundExp, classExp, classDataExp, new0Exp, renew0Exp,
dbopenExp, dbfieldExp, dbtableExp, dbindexExp, extensionExpressionExp, extensionInitializerExp,
vaArgExp, arrayExp, typeAlignExp,
- memberPropertyErrorExp, functionCallErrorExp, divideBy0ErrorExp
+ memberPropertyErrorExp, functionCallErrorExp, divideBy0ErrorExp,
+ offsetOfExp
};
public enum MemberType
char * name;
Symbol symbol;
OldList/*<TemplateArgument>*/ * templateArgs;
+ Specifier nsSpec;
};
struct
{
Expression exp;
TypeName typeName;
} vaArg;
+ struct
+ {
+ TypeName typeName;
+ Identifier id;
+ } offset;
};
bool debugValue;
bool needCast;
bool thisPtr;
bool opDestType;
+ bool usedInComparison;
+ bool ambiguousUnits;
+ bool parentOpDestType;
uint needTemplateCast;
void Clear()
needCast = false;
thisPtr = false;
opDestType = false;
+ parentOpDestType = false;
+ usedInComparison = false;
needTemplateCast = 0;
}
};
Symbol symbol;
Location blockStart;
Location nameLoc;
- int endid;
AccessMode declMode;
bool deleteWatchable;
};
void * object;
};
+// An 'edge from' is a 'dependency on'
+class TopoEdge : struct
+{
+ public LinkElement<TopoEdge> in, out;
+ External from, to;
+ bool breakable;
+};
+
public enum ExternalType { functionExternal, declarationExternal, classExternal, importExternal, nameSpaceExternal, dbtableExternal };
public class External : struct
DBTableDef table;
};
ImportType importType;
+
+ // For the TopoSort
+ External fwdDecl;
+ LinkList<TopoEdge, link = out> outgoing { };
+ LinkList<TopoEdge, link = in> incoming { };
+ int nonBreakableIncoming;
+
+ void CreateUniqueEdge(External from, bool soft)
+ {
+ for(i : from.outgoing; i.to == this)
+ {
+ if(i.breakable && !soft)
+ {
+#ifdef _DEBUG
+ if(from == this)
+ PrintLn("bug: self-dependency");
+#endif
+ i.breakable = false;
+ nonBreakableIncoming++;
+ }
+ return;
+ }
+ CreateEdge(from, soft);
+ }
+
+ void CreateEdge(External from, bool soft)
+ {
+ TopoEdge e { from = from, to = this, breakable = soft };
+
+#ifdef _DEBUG
+ if(from == this && !soft)
+ PrintLn("bug: self-dependency");
+
+ /*for(i : from.outgoing)
+ {
+ if(i.to == this)
+ PrintLn("Warning: adding a duplicate edge");
+ }*/
+#endif
+
+ from.outgoing.Add(e);
+ incoming.Add(e);
+ if(!soft)
+ nonBreakableIncoming++;
+ }
+
+ External ForwardDeclare()
+ {
+ External f = null;
+ Context tmpContext = curContext;
+
+ switch(type)
+ {
+ case declarationExternal:
+ {
+ if(declaration.type == initDeclaration)
+ {
+ OldList * specs = declaration.specifiers;
+ if(specs)
+ {
+ Specifier s;
+ for(s = specs->first; s; s = s.next)
+ {
+ if(s.type == structSpecifier || s.type == unionSpecifier)
+ break;
+ }
+ if(s)
+ {
+ curContext = null;
+ f = MkExternalDeclaration(MkDeclaration(MkListOne(MkStructOrUnion(s.type, CopyIdentifier(s.id), null)), null));
+ curContext = tmpContext;
+ }
+ }
+ }
+ break;
+ }
+ case functionExternal:
+ {
+ curContext = null;
+ f = MkExternalDeclaration(MkDeclaration(CopyList(function.specifiers, CopySpecifier), MkListOne(MkInitDeclarator(CopyDeclarator(function.declarator), null))));
+ curContext = tmpContext;
+ f.symbol = symbol;
+
+ DeclareTypeForwardDeclare(f, symbol.type, false, false);
+ break;
+ }
+ }
+
+ /*
+ for(i : m.protoDepsExternal)
+ {
+ // If the edge is already added, don't bother
+ if(i.incoming.count)
+ CreateEdge(f, i.fwdDecl ? i.fwdDecl : i, i.fwdDecl ? false : true);
+ }
+ */
+
+ fwdDecl = f;
+
+ if(!f)
+ PrintLn("warning: unhandled forward declaration requested");
+ return f;
+ }
};
public class Context : struct
Property _property;
Class registered;
};
- int id, idCode;
+ bool notYetDeclared;
union
{
struct
Context ctx;
int isIterator;
Expression propCategory;
+ bool mustRegister; // Must register the class within the RegisterClass (also used to check whether this class is declared in this module)
};
// For the .imp file:
};
// For the .sym file:
+// BEWARE: Adding a value in the middle of this list has very arcane bootstrapping implications!!
public enum TypeKind
{
voidType, charType, shortType, intType, int64Type, longType, floatType,
doubleType, classType, structType, unionType, functionType, arrayType, pointerType,
ellipsisType, enumType, methodType, vaListType, /*typedObjectType, anyObjectType, classPointerType, */ dummyType,
- subClassType, templateType, thisClassType, intPtrType, intSizeType, _BoolType
+ subClassType, templateType, thisClassType, intPtrType, intSizeType, _BoolType, int128Type /* TODO! */
};
public class Type : struct
uint size;
char * name;
char * typeName;
+ Class thisClassFrom;
+ TypeKind promotedFrom;
ClassObjectType classObjectType;
int alignment;
uint offset;
int bitFieldCount;
- int count;
+ int count; // This is used to avoid outputting warnings when non-zero
+ int bitMemberSize;
bool isSigned:1;
bool constant:1;
bool declaredWithStruct:1;
bool typedByReference:1; // Originally typed by reference, regardless of class type
bool casted:1;
+ bool pointerAlignment:1; // true if the alignment is the pointer size
+ bool isLong:1; // true if this is truly a long set as a int/int64 (need to improve long support)
+ bool signedBeforePromotion:1;
+ bool isVector:1; // For __attribute__((__vector_size(..))
// bool wasThisClass:1;
// TODO: Add _Complex & _Imaginary support
// bool complex:1, imaginary:1;
}
}
+ // Used for generating calls to eClass_AddDataMember (differs slightly from 'isPointerType' below), meant to return true where ComputeTypeSize returns targetBits / 8
+ property bool isPointerTypeSize
+ {
+ get
+ {
+ bool result = false;
+ if(this)
+ {
+ switch(kind)
+ {
+ case classType:
+ {
+ Class _class = this._class ? this._class.registered : null;
+ if(!_class || (_class.type != structClass && _class.type != unitClass && _class.type != enumClass && _class.type != bitClass))
+ result = true;
+ break;
+ }
+ case pointerType:
+ case subClassType:
+ case thisClassType:
+ case intPtrType:
+ case intSizeType:
+ result = true;
+ break;
+ case templateType:
+ {
+ TemplateParameter param = templateParameter;
+ Type baseType = ProcessTemplateParameterType(param);
+ if(baseType)
+ result = baseType.isPointerTypeSize;
+ break;
+ }
+ }
+ }
+ return result;
+ }
+ }
+
property bool isPointerType
{
get
Class c = _class.registered;
if(c.type == bitClass || c.type == unitClass || c.type == enumClass || c.type == systemClass)
return false;
+ else if(c.type == structClass && !byReference)
+ return false;
}
return true;
}
Ecere Software / sdk / blobdiff