void asCBuilder::ParseScripts()
{
asCArray<asCParser*> parsers;
// Parse all the files as if they were one
asUINT n = 0;
for( n = 0; n < scripts.GetLength(); n++ )
{
asCParser *parser = new asCParser(this);
parsers.PushLast(parser);
// Parse the script file
parser->ParseScript(scripts[n]);
}
if( numErrors == 0 )
{
// Find all type declarations
for( n = 0; n < scripts.GetLength(); n++ )
{
asCScriptNode *node = parsers[n]->GetScriptNode();
// Find structure definitions first
node = node->firstChild;
while( node )
{
asCScriptNode *next = node->next;
if( node->nodeType == snClass )
{
node->DisconnectParent();
RegisterClass(node, scripts[n]);
}
else if( node->nodeType == snInterface )
{
node->DisconnectParent();
RegisterInterface(node, scripts[n]);
}
node = next;
}
}
// Register script methods found in the structures
for( n = 0; n < classDeclarations.GetLength(); n++ )
{
sClassDeclaration *decl = classDeclarations[n];
asCScriptNode *node = decl->node->firstChild->next;
// Skip list of classes and interfaces
while( node && node->nodeType == snIdentifier )
node = node->next;
while( node )
{
asCScriptNode *next = node->next;
if( node->nodeType == snFunction )
{
node->DisconnectParent();
RegisterScriptFunction(module->GetNextFunctionId(), node, decl->script, decl->objType);
}
node = next;
}
// Make sure the default constructor exists for classes
if( decl->objType->beh.construct == engine->scriptTypeBehaviours.beh.construct )
{
AddDefaultConstructor(decl->objType, decl->script);
}
}
// Register script methods found in the interfaces
for( n = 0; n < interfaceDeclarations.GetLength(); n++ )
{
sClassDeclaration *decl = interfaceDeclarations[n];
asCScriptNode *node = decl->node->firstChild->next;
while( node )
{
asCScriptNode *next = node->next;
if( node->nodeType == snFunction )
{
node->DisconnectParent();
RegisterScriptFunction(module->GetNextFunctionId(), node, decl->script, decl->objType, true);
}
node = next;
}
}
// Find other global nodes
for( n = 0; n < scripts.GetLength(); n++ )
{
// Find other global nodes
asCScriptNode *node = parsers[n]->GetScriptNode();
node = node->firstChild;
while( node )
{
asCScriptNode *next = node->next;
node->DisconnectParent();
if( node->nodeType == snFunction )
{
RegisterScriptFunction(module->GetNextFunctionId(), node, scripts[n]);
}
else if( node->nodeType == snGlobalVar )
{
RegisterGlobalVar(node, scripts[n]);
}
else if( node->nodeType == snImport )
{
RegisterImportedFunction(module->GetNextImportedFunctionId(), node, scripts[n]);
}
else
{
// Unused script node
int r, c;
scripts[n]->ConvertPosToRowCol(node->tokenPos, &r, &c);
WriteWarning(scripts[n]->name.AddressOf(), TXT_UNUSED_SCRIPT_NODE, r, c);
delete node;
}
node = next;
}
}
}
for( n = 0; n < parsers.GetLength(); n++ )
delete parsers[n];
}
void ILGenMakeLibrary(ILGenInfo *info)
{
ILImage *image = info->libImage;
ILProgramItem *scope = ILClassGlobalScope(image);
ILClass *objectClass;
ILClass *stringClass;
ILClass *typeClass;
ILClass *valueTypeClass;
ILClass *enumClass;
ILClass *voidClass;
ILClass *intPtrClass;
ILClass *uintPtrClass;
ILClass *typedRefClass;
ILClass *argIterClass;
ILClass *argHandleClass;
ILClass *attributeClass;
ILClass *paramAttributeClass;
ILClass *defMemberAttributeClass;
ILClass *decimalConstantClass;
ILClass *exceptionClass;
ILClass *disposableInterface;
ILClass *asyncResultInterface;
ILClass *collectionInterface;
ILClass *enumeratorInterface;
ILClass *isVolatileClass;
ILClass *delegateClass;
ILClass *multicastDelegateClass;
ILClass *asyncCallbackClass;
int constructorOK;
ILMethod *method;
ILProperty *property;
ILType *signature;
/* Create the "System.Object" class */
ABORT_IF(objectClass, ILClassCreate(scope, 0, "Object", "System", 0));
ILClassSetAttrs(objectClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SERIALIZABLE);
ABORT_IF(constructorOK, AddDefaultConstructor(objectClass));
/* Create the "System.String" class */
ABORT_IF(stringClass,
ILClassCreate(scope, 0, "String", "System", objectClass));
ILClassSetAttrs(stringClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SEALED);
/* Create the "System.Type" class */
ABORT_IF(typeClass,
ILClassCreate(scope, 0, "Type", "System", objectClass));
ILClassSetAttrs(typeClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_ABSTRACT);
ABORT_IF(constructorOK, AddDefaultConstructor(typeClass));
/* Add the "ToString" and "GetType" methods to the "System.Object" class */
if(!AddMethod(objectClass, "ToString",
ILType_FromClass(stringClass), ILType_Void, ILType_Void,
IL_META_METHODDEF_VIRTUAL | IL_META_METHODDEF_NEW_SLOT))
{
ILGenOutOfMemory(info);
}
if(!AddMethod(objectClass, "GetType",
ILType_FromClass(typeClass),
ILType_Void, ILType_Void, 0))
{
ILGenOutOfMemory(info);
}
/* Add the "==" and "!=" operators to the "System.String" class */
if(!AddMethod(stringClass, "op_Equality",
ILType_Boolean, ILType_FromClass(stringClass),
ILType_FromClass(stringClass),
IL_META_METHODDEF_STATIC | IL_META_METHODDEF_SPECIAL_NAME))
{
ILGenOutOfMemory(info);
}
if(!AddMethod(stringClass, "op_Inequality",
ILType_Boolean, ILType_FromClass(stringClass),
ILType_FromClass(stringClass),
IL_META_METHODDEF_STATIC | IL_META_METHODDEF_SPECIAL_NAME))
{
ILGenOutOfMemory(info);
}
/* Create the "System.ValueType" class */
ABORT_IF(valueTypeClass,
ILClassCreate(scope, 0, "ValueType", "System", objectClass));
ILClassSetAttrs(valueTypeClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SERIALIZABLE);
ABORT_IF(constructorOK, AddDefaultConstructor(valueTypeClass));
/* Create the "System.Enum" class */
ABORT_IF(enumClass,
ILClassCreate(scope, 0, "Enum", "System", valueTypeClass));
ILClassSetAttrs(enumClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_ABSTRACT |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SERIALIZABLE);
ABORT_IF(constructorOK, AddDefaultConstructor(enumClass));
/* Create the "System.Void" class */
ABORT_IF(voidClass,
ILClassCreate(scope, 0, "Void", "System", valueTypeClass));
ILClassSetAttrs(voidClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_VALUE_TYPE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SEALED);
/* Create the numeric value types */
MakeValueType(info, image, "SByte", valueTypeClass, stringClass);
MakeValueType(info, image, "Byte", valueTypeClass, stringClass);
MakeValueType(info, image, "Int16", valueTypeClass, stringClass);
MakeValueType(info, image, "UInt16", valueTypeClass, stringClass);
MakeValueType(info, image, "Int32", valueTypeClass, stringClass);
MakeValueType(info, image, "UInt32", valueTypeClass, stringClass);
MakeValueType(info, image, "Int64", valueTypeClass, stringClass);
MakeValueType(info, image, "UInt64", valueTypeClass, stringClass);
MakeValueType(info, image, "Single", valueTypeClass, stringClass);
MakeValueType(info, image, "Double", valueTypeClass, stringClass);
MakeValueType(info, image, "Decimal", valueTypeClass, stringClass);
/* Create the "System.IntPtr" class */
ABORT_IF(intPtrClass,
ILClassCreate(scope, 0, "IntPtr", "System", valueTypeClass));
ILClassSetAttrs(intPtrClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_VALUE_TYPE |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SEALED);
/* Create the "System.UIntPtr" class */
ABORT_IF(uintPtrClass,
ILClassCreate(scope, 0, "UIntPtr", "System", valueTypeClass));
ILClassSetAttrs(uintPtrClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_VALUE_TYPE |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SEALED);
/* Create the "System.TypedReference" class */
ABORT_IF(typedRefClass,
ILClassCreate(scope, 0, "TypedReference", "System",
valueTypeClass));
ILClassSetAttrs(typedRefClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_VALUE_TYPE |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SEALED);
/* Create the "System.ArgIterator" class */
ABORT_IF(argIterClass,
ILClassCreate(scope, 0, "ArgIterator", "System",
valueTypeClass));
ILClassSetAttrs(argIterClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_VALUE_TYPE |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SEALED);
/* Create the "System.RuntimeArgumentHandle" class */
ABORT_IF(argHandleClass,
ILClassCreate(scope, 0, "RuntimeArgumentHandle", "System",
valueTypeClass));
ILClassSetAttrs(argHandleClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_VALUE_TYPE |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SEALED);
/* Create the "System.Attribute" class */
ABORT_IF(attributeClass,
ILClassCreate(scope, 0, "Attribute", "System",
objectClass));
ILClassSetAttrs(attributeClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_ABSTRACT);
/* Create the "System.ParamArrayAttribute" class */
ABORT_IF(paramAttributeClass,
ILClassCreate(scope, 0, "ParamArrayAttribute", "System",
attributeClass));
ILClassSetAttrs(paramAttributeClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SEALED);
ABORT_IF(constructorOK, AddDefaultConstructor(paramAttributeClass));
/* Create the "System.Reflection.DefaultMemberAttribute" class */
ABORT_IF(defMemberAttributeClass,
ILClassCreate(scope, 0, "DefaultMemberAttribute",
"System.Reflection", attributeClass));
ILClassSetAttrs(defMemberAttributeClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SEALED);
ABORT_IF(constructorOK,
AddParamConstructor(defMemberAttributeClass,
ILType_FromClass(stringClass), ILType_Void));
/* Create "System.Runtime.CompilerServices.DecimalConstantAttribute" */
ABORT_IF(decimalConstantClass,
ILClassCreate(scope, 0, "DecimalConstantAttribute",
"System.Runtime.CompilerServices",
attributeClass));
ILClassSetAttrs(decimalConstantClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_SEALED);
ABORT_IF(constructorOK, AddDecimalConstructor(decimalConstantClass));
/* Create the "System.Exception" class */
ABORT_IF(exceptionClass,
ILClassCreate(scope, 0, "Exception", "System",
objectClass));
ILClassSetAttrs(exceptionClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT);
ABORT_IF(constructorOK, AddDefaultConstructor(exceptionClass));
/* Create the "System.IDisposable" interface */
ABORT_IF(disposableInterface,
ILClassCreate(scope, 0, "IDisposable", "System", 0));
ILClassSetAttrs(disposableInterface, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_INTERFACE |
IL_META_TYPEDEF_ABSTRACT);
/* Create the "System.IAsyncResult" interface */
ABORT_IF(asyncResultInterface,
ILClassCreate(scope, 0, "IAsyncResult", "System", 0));
ILClassSetAttrs(asyncResultInterface, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_INTERFACE |
IL_META_TYPEDEF_ABSTRACT);
/* Create the "System.Collections.ICollection" interface */
ABORT_IF(collectionInterface,
ILClassCreate(scope, 0, "ICollection", "System.Collections", 0));
ILClassSetAttrs(collectionInterface, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_INTERFACE |
IL_META_TYPEDEF_ABSTRACT);
/* Create the "System.Collections.IEnumerator" interface */
ABORT_IF(enumeratorInterface,
ILClassCreate(scope, 0, "IEnumerator", "System.Collections", 0));
ILClassSetAttrs(enumeratorInterface, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_INTERFACE |
IL_META_TYPEDEF_ABSTRACT);
/* Add the "GetEnumerator" method to the "ICollection" interface */
ABORT_IF(method, AddAbstractMethod(collectionInterface, "GetEnumerator",
ILType_FromClass(enumeratorInterface),
ILType_Void));
/* Add the "MoveNext" and "Reset" methods to "IEnumerator" */
ABORT_IF(method, AddAbstractMethod(enumeratorInterface, "MoveNext",
ILType_Boolean, ILType_Void));
ABORT_IF(method, AddAbstractMethod(enumeratorInterface, "Reset",
ILType_Void, ILType_Void));
/* Add the "Current" property to "IEnumerator" */
ABORT_IF(method, AddAbstractMethod(enumeratorInterface, "get_Current",
ILType_FromClass(objectClass),
ILType_Void));
ABORT_IF(signature, ILTypeCreateProperty(info->context,
ILType_FromClass(objectClass)));
ILTypeSetCallConv(signature, IL_META_CALLCONV_HASTHIS);
ABORT_IF(property, ILPropertyCreate(enumeratorInterface, 0, "Current",
0, signature));
if(!ILMethodSemCreate((ILProgramItem *)property, 0,
IL_META_METHODSEM_GETTER, method))
{
ILGenOutOfMemory(info);
}
/* Create the "System.Runtime.CompilerServices.IsVolatile" class */
ABORT_IF(isVolatileClass,
ILClassCreate(scope, 0, "IsVolatile",
"System.Runtime.CompilerServices",
objectClass));
ILClassSetAttrs(isVolatileClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SEALED |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT);
ABORT_IF(constructorOK, AddDefaultConstructor(isVolatileClass));
/* Create the "System.Delegate" class */
ABORT_IF(delegateClass,
ILClassCreate(scope, 0, "Delegate", "System", objectClass));
ILClassSetAttrs(delegateClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_ABSTRACT);
if(!AddMethod(delegateClass, "op_Equality", ILType_Boolean,
ILType_FromClass(delegateClass),
ILType_FromClass(delegateClass),
IL_META_METHODDEF_SPECIAL_NAME | IL_META_METHODDEF_STATIC))
{
ILGenOutOfMemory(info);
}
if(!AddMethod(delegateClass, "op_Inequality", ILType_Boolean,
ILType_FromClass(delegateClass),
ILType_FromClass(delegateClass),
IL_META_METHODDEF_SPECIAL_NAME | IL_META_METHODDEF_STATIC))
{
ILGenOutOfMemory(info);
}
/* Create the "System.MulticastDelegate" class */
ABORT_IF(multicastDelegateClass,
ILClassCreate(scope, 0, "MulticastDelegate", "System",
delegateClass));
ILClassSetAttrs(multicastDelegateClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_ABSTRACT);
if(!AddMethod(multicastDelegateClass, "op_Equality", ILType_Boolean,
ILType_FromClass(multicastDelegateClass),
ILType_FromClass(multicastDelegateClass),
IL_META_METHODDEF_SPECIAL_NAME | IL_META_METHODDEF_STATIC))
{
ILGenOutOfMemory(info);
}
if(!AddMethod(multicastDelegateClass, "op_Inequality", ILType_Boolean,
ILType_FromClass(multicastDelegateClass),
ILType_FromClass(multicastDelegateClass),
IL_META_METHODDEF_SPECIAL_NAME | IL_META_METHODDEF_STATIC))
{
ILGenOutOfMemory(info);
}
/* Create the "AsyncCallback" delegate class */
ABORT_IF(asyncCallbackClass,
ILClassCreate(scope, 0, "AsyncCallback", "System",
multicastDelegateClass));
ILClassSetAttrs(asyncCallbackClass, ~0,
IL_META_TYPEDEF_PUBLIC |
IL_META_TYPEDEF_SERIALIZABLE |
IL_META_TYPEDEF_BEFORE_FIELD_INIT |
IL_META_TYPEDEF_ABSTRACT);
}
