uint32_t
HashUTF8AsUTF16(const char* aUTF8, uint32_t aLength, bool* aErr)
{
uint32_t hash = 0;
const char* s = aUTF8;
const char* end = aUTF8 + aLength;
*aErr = false;
while (s < end)
{
uint32_t ucs4 = UTF8CharEnumerator::NextChar(&s, end, aErr);
if (*aErr) {
return 0;
}
if (ucs4 < PLANE1_BASE) {
hash = AddToHash(hash, ucs4);
}
else {
hash = AddToHash(hash, H_SURROGATE(ucs4), L_SURROGATE(ucs4));
}
}
return hash;
}
nsresult
nsScriptNameSpaceManager::RegisterClassName(const char *aClassName,
PRInt32 aDOMClassInfoID,
const PRUnichar **aResult)
{
if (!nsCRT::IsAscii(aClassName)) {
NS_ERROR("Trying to register a non-ASCII class name");
return NS_OK;
}
nsGlobalNameStruct *s = AddToHash(aClassName, aResult);
NS_ENSURE_TRUE(s, NS_ERROR_OUT_OF_MEMORY);
if (s->mType == nsGlobalNameStruct::eTypeClassConstructor) {
return NS_OK;
}
// If a external constructor is already defined with aClassName we
// won't overwrite it.
if (s->mType == nsGlobalNameStruct::eTypeExternalConstructor) {
return NS_OK;
}
NS_ASSERTION(s->mType == nsGlobalNameStruct::eTypeNotInitialized ||
s->mType == nsGlobalNameStruct::eTypeInterface,
"Whaaa, JS environment name clash!");
s->mType = nsGlobalNameStruct::eTypeClassConstructor;
s->mDOMClassInfoID = aDOMClassInfoID;
return NS_OK;
}
buf *getblk(int blknum){
while(&h_head[blknum % 4] != NULL){
buf *buffer = Search(blknum);
if(buffer != NULL){
assert(buffer != NULL);
if(IsStatus(buffer, STAT_LOCKED)){
//sleep();
printf("SCENARIO 5\n");
printf("Process goes to sleep\n");
AddStatus(buffer, STAT_WAITED);
return NULL;
continue;
}
//scenario 1
printf("SCENARIO 1\n");
MakeStatus(buffer, (STAT_LOCKED | STAT_VALID));
RemFromFreeList(buffer);
return buffer;
}
else{
//if(IsInFreeList(buffer)){
if(IsEmptyFree()){
//scenario 4
//sleep();
printf("SCENARIO 4\n");
printf("Process goes to sleep\n");
return buffer;
//continue;
}
//RemFromFreeList(buffer);
//RemoveFromFree()
buf *ref = ref_free_head();
if(CheckStatus(ref, STAT_DWR)){
//scenario 3
printf("SCENARIO 3\n"); //asynchronous write buffer to disk;
buf *prev = ref -> free_bp;
buf *next = ref -> free_fp;
prev -> free_fp = next;
next -> free_bp = prev;
MakeStatus(ref, STAT_LOCKED | STAT_VALID | STAT_KRDWR | STAT_OLD);
continue;
}
//scenario 2
printf("SCENARIO 2\n");
buf *additionalbuf = remove_free_head();
RemStatus(additionalbuf, STAT_VALID);
additionalbuf -> blkno = blknum;
AddToHash(additionalbuf);
printf("Kernel HDD access occuring\n");
AddStatus(additionalbuf, STAT_KRDWR);
printf("Kernel HDD access finished\n");
RemStatus(additionalbuf, STAT_KRDWR);
AddStatus(additionalbuf, STAT_VALID);
return additionalbuf;
}
}
printf("BUFFER NOT FOUND\n");
return NULL;
}
// Hash string ignore case, based on PL_HashString
static PLDHashNumber
StringHash(const void *key)
{
PLDHashNumber h = 0;
for (const char *s = reinterpret_cast<const char*>(key); *s; ++s)
h = AddToHash(h, nsCRT::ToLower(*s));
return h;
}
/* static */ HashNumber
SavedFrame::HashPolicy::hash(const Lookup &lookup)
{
return AddToHash(HashString(lookup.source->chars(), lookup.source->length()),
lookup.line,
lookup.column,
lookup.functionDisplayName,
SavedFramePtrHasher::hash(lookup.parent),
JSPrincipalsPtrHasher::hash(lookup.principals));
}
uint32_t
HashBytes(const void* bytes, size_t length)
{
uint32_t hash = 0;
const char* b = reinterpret_cast<const char*>(bytes);
/* Walk word by word. */
size_t i = 0;
for (; i < length - (length % sizeof(size_t)); i += sizeof(size_t)) {
/* Do an explicitly unaligned load of the data. */
size_t data;
memcpy(&data, b + i, sizeof(size_t));
hash = AddToHash(hash, data, sizeof(data));
}
/* Get the remaining bytes. */
for (; i < length; i++)
hash = AddToHash(hash, b[i]);
return hash;
}
/* static */ HashNumber
SavedFrame::HashPolicy::hash(const Lookup &lookup)
{
JS::AutoCheckCannotGC nogc;
// Assume that we can take line mod 2^32 without losing anything of
// interest. If that assumption changes, we'll just need to start with 0
// and add another overload of AddToHash with more arguments.
return AddToHash(lookup.line,
lookup.column,
lookup.source,
lookup.functionDisplayName,
SavedFramePtrHasher::hash(lookup.parent),
JSPrincipalsPtrHasher::hash(lookup.principals));
}
bool CTextureRefs::AddRef(unsigned fmt, unsigned x, unsigned y, unsigned width, unsigned height)
{
// Pack texture reference into bitfield
unsigned texRef = (fmt&7)<<24|(x&0x7E0)<<13|(y&0x7E0)<<7|(width&0x7E0)<<1|(height&0x7E0)>>5;
// Check if using array or hashset
if (m_size <= TEXREFS_ARRAY_SIZE)
{
// See if already held in array, if so nothing to do
for (unsigned i = 0; i < m_size; i++)
{
if (texRef == m_array[i])
return true;
}
// If not, check if array is full
if (m_size == TEXREFS_ARRAY_SIZE)
{
// If so, set initial hashset capacity to 47 to initialize it
UpdateHashCapacity(47);
// Copy array into hashset
for (unsigned i = 0; i < TEXREFS_ARRAY_SIZE; i++)
AddToHash(m_array[i]);
// Add texture reference to hashset
AddToHash(texRef);
}
else
{
// Add texture reference to array
m_array[m_size] = texRef;
m_size++;
}
return true;
}
else
// Add texture reference to hashset
return AddToHash(texRef);
}
nsresult
nsScriptNameSpaceManager::RegisterDOMCIData(const char *aName,
nsDOMClassInfoExternalConstructorFnc aConstructorFptr,
const nsIID *aProtoChainInterface,
const nsIID **aInterfaces,
PRUint32 aScriptableFlags,
bool aHasClassInterface,
const nsCID *aConstructorCID)
{
const PRUnichar* className;
nsGlobalNameStruct *s = AddToHash(&mGlobalNames, aName, &className);
NS_ENSURE_TRUE(s, NS_ERROR_OUT_OF_MEMORY);
// If an external constructor is already defined with aClassName we
// won't overwrite it.
if (s->mType == nsGlobalNameStruct::eTypeClassConstructor ||
s->mType == nsGlobalNameStruct::eTypeExternalClassInfo) {
return NS_OK;
}
// XXX Should we bail out here?
NS_ASSERTION(s->mType == nsGlobalNameStruct::eTypeNotInitialized ||
s->mType == nsGlobalNameStruct::eTypeExternalClassInfoCreator,
"Someone tries to register classinfo data for a class that isn't new or external!");
s->mData = new nsExternalDOMClassInfoData;
NS_ENSURE_TRUE(s->mData, NS_ERROR_OUT_OF_MEMORY);
s->mType = nsGlobalNameStruct::eTypeExternalClassInfo;
s->mData->mName = aName;
s->mData->mNameUTF16 = className;
if (aConstructorFptr)
s->mData->u.mExternalConstructorFptr = aConstructorFptr;
else
// null constructor will cause us to use nsDOMGenericSH::doCreate
s->mData->u.mExternalConstructorFptr = nsnull;
s->mData->mCachedClassInfo = nsnull;
s->mData->mProtoChainInterface = aProtoChainInterface;
s->mData->mInterfaces = aInterfaces;
s->mData->mScriptableFlags = aScriptableFlags;
s->mData->mHasClassInterface = aHasClassInterface;
s->mData->mConstructorCID = aConstructorCID;
return NS_OK;
}
nsresult
nsScriptNameSpaceManager::RegisterInterface(const char* aIfName,
const nsIID *aIfIID,
bool* aFoundOld)
{
*aFoundOld = false;
nsGlobalNameStruct *s = AddToHash(&mGlobalNames, aIfName);
NS_ENSURE_TRUE(s, NS_ERROR_OUT_OF_MEMORY);
if (s->mType != nsGlobalNameStruct::eTypeNotInitialized) {
*aFoundOld = true;
return NS_OK;
}
s->mType = nsGlobalNameStruct::eTypeInterface;
s->mIID = *aIfIID;
return NS_OK;
}
nsresult
nsScriptNameSpaceManager::RegisterExternalClassName(const char *aClassName,
nsCID& aCID)
{
nsGlobalNameStruct *s = AddToHash(&mGlobalNames, aClassName);
NS_ENSURE_TRUE(s, NS_ERROR_OUT_OF_MEMORY);
// If an external constructor is already defined with aClassName we
// won't overwrite it.
if (s->mType == nsGlobalNameStruct::eTypeExternalConstructor) {
return NS_OK;
}
NS_ASSERTION(s->mType == nsGlobalNameStruct::eTypeNotInitialized ||
s->mType == nsGlobalNameStruct::eTypeInterface,
"Whaaa, JS environment name clash!");
s->mType = nsGlobalNameStruct::eTypeExternalClassInfoCreator;
s->mCID = aCID;
return NS_OK;
}
nsresult
nsScriptNameSpaceManager::RegisterClassProto(const char *aClassName,
const nsIID *aConstructorProtoIID,
bool *aFoundOld)
{
NS_ENSURE_ARG_POINTER(aConstructorProtoIID);
*aFoundOld = false;
nsGlobalNameStruct *s = AddToHash(&mGlobalNames, aClassName);
NS_ENSURE_TRUE(s, NS_ERROR_OUT_OF_MEMORY);
if (s->mType != nsGlobalNameStruct::eTypeNotInitialized &&
s->mType != nsGlobalNameStruct::eTypeInterface) {
*aFoundOld = true;
return NS_OK;
}
s->mType = nsGlobalNameStruct::eTypeClassProto;
s->mIID = *aConstructorProtoIID;
return NS_OK;
}
nsresult
nsScriptNameSpaceManager::AddCategoryEntryToHash(nsICategoryManager* aCategoryManager,
const char* aCategory,
nsISupports* aEntry)
{
// Get the type from the category name.
// NOTE: we could have passed the type in FillHash() and guessed it in
// Observe() but this way, we have only one place to update and this is
// not performance sensitive.
nsGlobalNameStruct::nametype type;
if (strcmp(aCategory, JAVASCRIPT_GLOBAL_CONSTRUCTOR_CATEGORY) == 0) {
type = nsGlobalNameStruct::eTypeExternalConstructor;
} else if (strcmp(aCategory, JAVASCRIPT_GLOBAL_PROPERTY_CATEGORY) == 0 ||
strcmp(aCategory, JAVASCRIPT_GLOBAL_PRIVILEGED_PROPERTY_CATEGORY) == 0) {
type = nsGlobalNameStruct::eTypeProperty;
} else if (strcmp(aCategory, JAVASCRIPT_NAVIGATOR_PROPERTY_CATEGORY) == 0) {
type = nsGlobalNameStruct::eTypeNavigatorProperty;
} else if (strcmp(aCategory, JAVASCRIPT_GLOBAL_STATIC_NAMESET_CATEGORY) == 0) {
type = nsGlobalNameStruct::eTypeStaticNameSet;
} else if (strcmp(aCategory, JAVASCRIPT_GLOBAL_DYNAMIC_NAMESET_CATEGORY) == 0) {
type = nsGlobalNameStruct::eTypeDynamicNameSet;
} else {
return NS_OK;
}
nsCOMPtr<nsISupportsCString> strWrapper = do_QueryInterface(aEntry);
if (!strWrapper) {
NS_WARNING("Category entry not an nsISupportsCString!");
return NS_OK;
}
nsCAutoString categoryEntry;
nsresult rv = strWrapper->GetData(categoryEntry);
NS_ENSURE_SUCCESS(rv, rv);
nsXPIDLCString contractId;
rv = aCategoryManager->GetCategoryEntry(aCategory, categoryEntry.get(),
getter_Copies(contractId));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIComponentRegistrar> registrar;
rv = NS_GetComponentRegistrar(getter_AddRefs(registrar));
NS_ENSURE_SUCCESS(rv, rv);
nsCID *cidPtr;
rv = registrar->ContractIDToCID(contractId, &cidPtr);
if (NS_FAILED(rv)) {
NS_WARNING("Bad contract id registed with the script namespace manager");
return NS_OK;
}
// Copy CID onto the stack, so we can free it right away and avoid having
// to add cleanup code at every exit point from this function.
nsCID cid = *cidPtr;
nsMemory::Free(cidPtr);
if (type == nsGlobalNameStruct::eTypeExternalConstructor) {
nsXPIDLCString constructorProto;
rv = aCategoryManager->GetCategoryEntry(JAVASCRIPT_GLOBAL_CONSTRUCTOR_PROTO_ALIAS_CATEGORY,
categoryEntry.get(),
getter_Copies(constructorProto));
if (NS_SUCCEEDED(rv)) {
nsGlobalNameStruct *s = AddToHash(&mGlobalNames, categoryEntry.get());
NS_ENSURE_TRUE(s, NS_ERROR_OUT_OF_MEMORY);
if (s->mType == nsGlobalNameStruct::eTypeNotInitialized) {
s->mAlias = new nsGlobalNameStruct::ConstructorAlias;
s->mType = nsGlobalNameStruct::eTypeExternalConstructorAlias;
s->mChromeOnly = false;
s->mAlias->mCID = cid;
AppendASCIItoUTF16(constructorProto, s->mAlias->mProtoName);
s->mAlias->mProto = nsnull;
} else {
NS_WARNING("Global script name not overwritten!");
}
return NS_OK;
}
}
PLDHashTable *table;
if (type == nsGlobalNameStruct::eTypeNavigatorProperty) {
table = &mNavigatorNames;
} else {
table = &mGlobalNames;
}
nsGlobalNameStruct *s = AddToHash(table, categoryEntry.get());
NS_ENSURE_TRUE(s, NS_ERROR_OUT_OF_MEMORY);
if (s->mType == nsGlobalNameStruct::eTypeNotInitialized) {
s->mType = type;
s->mCID = cid;
s->mChromeOnly =
strcmp(aCategory, JAVASCRIPT_GLOBAL_PRIVILEGED_PROPERTY_CATEGORY) == 0;
} else {
NS_WARNING("Global script name not overwritten!");
}
return NS_OK;
}
void AActor::Serialize (FArchive &arc)
{
Super::Serialize (arc);
if (arc.IsStoring ())
{
arc << x
<< y
<< z
<< pitch
<< angle
<< roll
<< sprite
<< frame
<< effects
<< floorz
<< ceilingz
<< radius
<< height
<< momx
<< momy
<< momz
<< type
<< tics
<< state
<< flags
<< health
<< movedir
<< visdir
<< movecount
<< target->netid
<< lastenemy->netid
<< reactiontime
<< threshold
<< player
<< lastlook
<< tracer->netid
<< tid
<< goal->netid
<< (unsigned)0
<< translucency
<< waterlevel;
if (translation)
arc << (DWORD)(translation - translationtables);
else
arc << (DWORD)0xffffffff;
spawnpoint.Serialize (arc);
}
else
{
unsigned dummy;
arc >> x
>> y
>> z
>> pitch
>> angle
>> roll
>> sprite
>> frame
>> effects
>> floorz
>> ceilingz
>> radius
>> height
>> momx
>> momy
>> momz
>> type
>> tics
>> state
>> flags
>> health
>> movedir
>> visdir
>> movecount
>> target->netid
>> lastenemy->netid
>> reactiontime
>> threshold
>> player
>> lastlook
>> tracer->netid
>> tid
>> goal->netid
>> dummy
>> translucency
>> waterlevel;
DWORD trans;
arc >> trans;
if (trans == (DWORD)0xffffffff)
translation = NULL;
else
translation = translationtables + trans;
spawnpoint.Serialize (arc);
info = &mobjinfo[type];
touching_sectorlist = NULL;
LinkToWorld ();
AddToHash ();
}
}
void ContentBlockingLog::ReportLog() {
MOZ_ASSERT(NS_IsMainThread());
if (!IsReportingEnabled()) {
return;
}
LOG("ContentBlockingLog::ReportLog [this=%p]", this);
const bool testMode =
StaticPrefs::telemetry_origin_telemetry_test_mode_enabled();
OriginMetricID metricId =
testMode ? OriginMetricID::ContentBlocking_Blocked_TestOnly
: OriginMetricID::ContentBlocking_Blocked;
ReportOriginSingleHash(metricId, kDummyOriginHash);
nsTArray<HashNumber> lookupTable;
for (const auto& originEntry : mLog) {
if (!originEntry.mData) {
continue;
}
for (const auto& logEntry : Reversed(originEntry.mData->mLogs)) {
if (logEntry.mType !=
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
logEntry.mTrackingFullHashes.IsEmpty()) {
continue;
}
const bool isBlocked = logEntry.mBlocked;
Maybe<StorageAccessGrantedReason> reason = logEntry.mReason;
metricId = testMode ? OriginMetricID::ContentBlocking_Blocked_TestOnly
: OriginMetricID::ContentBlocking_Blocked;
if (!isBlocked) {
MOZ_ASSERT(reason.isSome());
switch (reason.value()) {
case StorageAccessGrantedReason::eStorageAccessAPI:
metricId =
testMode
? OriginMetricID::
ContentBlocking_StorageAccessAPIExempt_TestOnly
: OriginMetricID::ContentBlocking_StorageAccessAPIExempt;
break;
case StorageAccessGrantedReason::eOpenerAfterUserInteraction:
metricId =
testMode
? OriginMetricID::
ContentBlocking_OpenerAfterUserInteractionExempt_TestOnly
: OriginMetricID::
ContentBlocking_OpenerAfterUserInteractionExempt;
break;
case StorageAccessGrantedReason::eOpener:
metricId =
testMode ? OriginMetricID::ContentBlocking_OpenerExempt_TestOnly
: OriginMetricID::ContentBlocking_OpenerExempt;
break;
default:
MOZ_ASSERT_UNREACHABLE("Unknown StorageAccessGrantedReason");
}
}
for (const auto& hash : logEntry.mTrackingFullHashes) {
HashNumber key = AddToHash(HashString(hash.get(), hash.Length()),
static_cast<uint32_t>(metricId));
if (lookupTable.Contains(key)) {
continue;
}
lookupTable.AppendElement(key);
ReportOriginSingleHash(metricId, hash);
}
break;
}
}
}
nsresult
GeckoMediaPluginServiceParent::GetNodeId(const nsAString& aOrigin,
const nsAString& aTopLevelOrigin,
bool aInPrivateBrowsing,
nsACString& aOutId)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
LOGD(("%s::%s: (%s, %s), %s", __CLASS__, __FUNCTION__,
NS_ConvertUTF16toUTF8(aOrigin).get(),
NS_ConvertUTF16toUTF8(aTopLevelOrigin).get(),
(aInPrivateBrowsing ? "PrivateBrowsing" : "NonPrivateBrowsing")));
nsresult rv;
if (aOrigin.EqualsLiteral("null") ||
aOrigin.IsEmpty() ||
aTopLevelOrigin.EqualsLiteral("null") ||
aTopLevelOrigin.IsEmpty()) {
// At least one of the (origin, topLevelOrigin) is null or empty;
// probably a local file. Generate a random node id, and don't store
// it so that the GMP's storage is temporary and not shared.
nsAutoCString salt;
rv = GenerateRandomPathName(salt, NodeIdSaltLength);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
aOutId = salt;
mPersistentStorageAllowed.Put(salt, false);
return NS_OK;
}
const uint32_t hash = AddToHash(HashString(aOrigin),
HashString(aTopLevelOrigin));
if (aInPrivateBrowsing) {
// For PB mode, we store the node id, indexed by the origin pair,
// so that if the same origin pair is opened in this session, it gets
// the same node id.
nsCString* salt = nullptr;
if (!(salt = mTempNodeIds.Get(hash))) {
// No salt stored, generate and temporarily store some for this id.
nsAutoCString newSalt;
rv = GenerateRandomPathName(newSalt, NodeIdSaltLength);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
salt = new nsCString(newSalt);
mTempNodeIds.Put(hash, salt);
mPersistentStorageAllowed.Put(*salt, false);
}
aOutId = *salt;
return NS_OK;
}
// Otherwise, try to see if we've previously generated and stored salt
// for this origin pair.
nsCOMPtr<nsIFile> path; // $profileDir/gmp/
rv = GetStorageDir(getter_AddRefs(path));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
rv = path->AppendNative(NS_LITERAL_CSTRING("id"));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
// $profileDir/gmp/id/
rv = path->Create(nsIFile::DIRECTORY_TYPE, 0700);
if (rv != NS_ERROR_FILE_ALREADY_EXISTS && NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
nsAutoCString hashStr;
hashStr.AppendInt((int64_t)hash);
// $profileDir/gmp/id/$hash
rv = path->AppendNative(hashStr);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
rv = path->Create(nsIFile::DIRECTORY_TYPE, 0700);
if (rv != NS_ERROR_FILE_ALREADY_EXISTS && NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
nsCOMPtr<nsIFile> saltFile;
rv = path->Clone(getter_AddRefs(saltFile));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
rv = saltFile->AppendNative(NS_LITERAL_CSTRING("salt"));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
nsAutoCString salt;
bool exists = false;
rv = saltFile->Exists(&exists);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (!exists) {
// No stored salt for this origin. Generate salt, and store it and
// the origin on disk.
nsresult rv = GenerateRandomPathName(salt, NodeIdSaltLength);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
MOZ_ASSERT(salt.Length() == NodeIdSaltLength);
// $profileDir/gmp/id/$hash/salt
rv = WriteToFile(path, NS_LITERAL_CSTRING("salt"), salt);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
// $profileDir/gmp/id/$hash/origin
rv = WriteToFile(path,
NS_LITERAL_CSTRING("origin"),
NS_ConvertUTF16toUTF8(aOrigin));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
// $profileDir/gmp/id/$hash/topLevelOrigin
rv = WriteToFile(path,
NS_LITERAL_CSTRING("topLevelOrigin"),
NS_ConvertUTF16toUTF8(aTopLevelOrigin));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
} else {
rv = ReadSalt(path, salt);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
}
aOutId = salt;
mPersistentStorageAllowed.Put(salt, true);
return NS_OK;
}
nsresult
nsScriptNameSpaceManager::FillHash(nsICategoryManager *aCategoryManager,
const char *aCategory,
nsGlobalNameStruct::nametype aType,
PRBool aPrivilegedOnly)
{
nsCOMPtr<nsIComponentRegistrar> registrar;
nsresult rv = NS_GetComponentRegistrar(getter_AddRefs(registrar));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISimpleEnumerator> e;
rv = aCategoryManager->EnumerateCategory(aCategory, getter_AddRefs(e));
NS_ENSURE_SUCCESS(rv, rv);
nsCAutoString categoryEntry;
nsXPIDLCString contractId;
nsCOMPtr<nsISupports> entry;
while (NS_SUCCEEDED(e->GetNext(getter_AddRefs(entry)))) {
nsCOMPtr<nsISupportsCString> category(do_QueryInterface(entry));
if (!category) {
NS_WARNING("Category entry not an nsISupportsCString!");
continue;
}
rv = category->GetData(categoryEntry);
NS_ENSURE_SUCCESS(rv, rv);
rv = aCategoryManager->GetCategoryEntry(aCategory, categoryEntry.get(),
getter_Copies(contractId));
NS_ENSURE_SUCCESS(rv, rv);
nsCID *cidPtr;
rv = registrar->ContractIDToCID(contractId, &cidPtr);
if (NS_FAILED(rv)) {
NS_WARNING("Bad contract id registed with the script namespace manager");
continue;
}
// Copy CID onto the stack, so we can free it right away and avoid having
// to add cleanup code at every exit point from this loop/function.
nsCID cid = *cidPtr;
nsMemory::Free(cidPtr);
if (aType == nsGlobalNameStruct::eTypeExternalConstructor) {
nsXPIDLCString constructorProto;
rv = aCategoryManager->GetCategoryEntry(JAVASCRIPT_GLOBAL_CONSTRUCTOR_PROTO_ALIAS_CATEGORY,
categoryEntry.get(),
getter_Copies(constructorProto));
if (NS_SUCCEEDED(rv)) {
nsGlobalNameStruct *s = AddToHash(categoryEntry.get());
NS_ENSURE_TRUE(s, NS_ERROR_OUT_OF_MEMORY);
if (s->mType == nsGlobalNameStruct::eTypeNotInitialized) {
s->mAlias = new nsGlobalNameStruct::ConstructorAlias;
if (!s->mAlias) {
// Free entry
NS_ConvertASCIItoUTF16 key(categoryEntry);
PL_DHashTableOperate(&mGlobalNames,
&key,
PL_DHASH_REMOVE);
return NS_ERROR_OUT_OF_MEMORY;
}
s->mType = nsGlobalNameStruct::eTypeExternalConstructorAlias;
s->mPrivilegedOnly = PR_FALSE;
s->mAlias->mCID = cid;
AppendASCIItoUTF16(constructorProto, s->mAlias->mProtoName);
s->mAlias->mProto = nsnull;
} else {
NS_WARNING("Global script name not overwritten!");
}
continue;
}
}
nsGlobalNameStruct *s = AddToHash(categoryEntry.get());
NS_ENSURE_TRUE(s, NS_ERROR_OUT_OF_MEMORY);
if (s->mType == nsGlobalNameStruct::eTypeNotInitialized) {
s->mType = aType;
s->mCID = cid;
s->mPrivilegedOnly = aPrivilegedOnly;
} else {
NS_WARNING("Global script name not overwritten!");
}
}
return NS_OK;
}
TreeCCNode *TreeCCNodeCreate(TreeCCContext *context, long linenum,
char *name, char *parent, int flags)
{
TreeCCNode *parentNode;
TreeCCNode *node;
/* Print debugging information if required */
if(context->debugMode)
{
TreeCCDebug(linenum, "%%node %s %s %d", name,
(parent ? parent : "no_parent"), flags);
}
/* Find or create the parent node */
if(parent)
{
parentNode = TreeCCNodeFind(context, parent);
if(!parentNode)
{
/* Create an undefined placeholder for the parent */
parentNode = (TreeCCNode *)malloc(sizeof(TreeCCNode));
if(!parentNode)
{
TreeCCOutOfMemory(context->input);
}
parentNode->parent = 0;
parentNode->firstChild = 0;
parentNode->lastChild = 0;
parentNode->nextSibling = 0;
parentNode->name = parent;
parentNode->flags = TREECC_NODE_UNDEFINED;
parentNode->number = (context->nodeNumber)++;
parentNode->filename = context->input->filename;
parentNode->linenum = linenum;
parentNode->fields = 0;
parentNode->virtuals = 0;
parentNode->header = context->headerStream;
parentNode->source = context->sourceStream;
AddToHash(context, parentNode);
}
else
{
free(parent);
}
}
else
{
parentNode = 0;
}
/* Find or create the current node */
node = TreeCCNodeFind(context, name);
if(node)
{
if((node->flags & TREECC_NODE_UNDEFINED) == 0)
{
TreeCCErrorOnLine(context->input, context->input->filename, linenum,
"node type `%s' is already declared", name);
TreeCCErrorOnLine(context->input, node->filename, node->linenum,
"previous declaration here");
free(name);
}
else
{
node->flags = flags;
node->parent = parentNode;
node->filename = context->input->filename;
node->linenum = linenum;
node->header = context->headerStream;
node->source = context->sourceStream;
node->nextSibling = 0;
if(parentNode)
{
if(parentNode->lastChild)
{
parentNode->lastChild->nextSibling = node;
}
else
{
parentNode->firstChild = node;
}
parentNode->lastChild = node;
}
}
}
else
{
node = (TreeCCNode *)malloc(sizeof(TreeCCNode));
if(!node)
{
TreeCCOutOfMemory(context->input);
}
node->parent = parentNode;
node->firstChild = 0;
node->lastChild = 0;
node->name = name;
node->flags = flags;
node->number = (context->nodeNumber)++;
node->filename = context->input->filename;
node->linenum = linenum;
node->fields = 0;
node->virtuals = 0;
node->header = context->headerStream;
node->source = context->sourceStream;
node->nextSibling = 0;
if(parentNode)
{
if(parentNode->lastChild)
{
parentNode->lastChild->nextSibling = node;
}
else
{
parentNode->firstChild = node;
}
parentNode->lastChild = node;
}
AddToHash(context, node);
}
return node;
}
void AActor::Serialize (FArchive &arc)
{
Super::Serialize (arc);
if (arc.IsStoring ())
{
arc << x
<< y
<< z
<< pitch
<< angle
<< roll
<< (int)sprite
<< frame
<< effects
<< floorz
<< ceilingz
<< radius
<< height
<< momx
<< momy
<< momz
<< (int)type
<< tics
<< state
<< flags
<< flags2
<< health
<< movedir
<< visdir
<< movecount
<< target->netid
<< lastenemy->netid
<< reactiontime
<< threshold
<< player
<< lastlook
<< tracer->netid
<< tid
<< goal->netid
<< (unsigned)0
<< translucency
<< waterlevel;
spawnpoint.Serialize (arc);
}
else
{
unsigned dummy;
arc >> x
>> y
>> z
>> pitch
>> angle
>> roll
>> (int&)sprite
>> frame
>> effects
>> floorz
>> ceilingz
>> radius
>> height
>> momx
>> momy
>> momz
>> (int&)type
>> tics
>> state
>> flags
>> flags2
>> health
>> movedir
>> visdir
>> movecount
>> target->netid
>> lastenemy->netid
>> reactiontime
>> threshold
>> player
>> lastlook
>> tracer->netid
>> tid
>> goal->netid
>> dummy
>> translucency
>> waterlevel;
DWORD trans;
arc >> trans;
spawnpoint.Serialize (arc);
if(type >= NUMMOBJTYPES)
I_Error("Unknown object type in saved game");
if(sprite >= NUMSPRITES)
I_Error("Unknown sprite in saved game");
info = &mobjinfo[type];
touching_sectorlist = NULL;
LinkToWorld ();
AddToHash ();
}
}
void AActor::Serialize (FArchive &arc)
{
Super::Serialize (arc);
if (arc.IsStoring ())
{
int playerid = player ? player->id : 0;
arc << x
<< y
<< z
<< pitch
<< angle
<< roll
<< (int)sprite
<< frame
<< effects
<< floorz
<< ceilingz
<< radius
<< height
<< momx
<< momy
<< momz
<< (int)type
<< tics
<< state
<< flags
<< flags2
<< special1
<< special2
<< health
<< movedir
<< visdir
<< movecount
/*<< target ? target->netid : 0*/
/*<< lastenemy ? lastenemy->netid : 0*/
<< reactiontime
<< threshold
<< playerid
<< lastlook
/*<< tracer ? tracer->netid : 0*/
<< tid
<< special
<< args[0]
<< args[1]
<< args[2]
<< args[3]
<< args[4]
/*<< goal ? goal->netid : 0*/
<< (unsigned)0
<< translucency
<< waterlevel;
if (translation)
arc << (DWORD)(translation - translationtables);
else
arc << (DWORD)0xffffffff;
spawnpoint.Serialize (arc);
}
else
{
unsigned dummy;
unsigned playerid;
arc >> x
>> y
>> z
>> pitch
>> angle
>> roll
>> (int&)sprite
>> frame
>> effects
>> floorz
>> ceilingz
>> radius
>> height
>> momx
>> momy
>> momz
>> (int&)type
>> tics
>> state
>> flags
>> flags2
>> special1
>> special2
>> health
>> movedir
>> visdir
>> movecount
/*>> target->netid*/
/*>> lastenemy->netid*/
>> reactiontime
>> threshold
>> playerid
>> lastlook
/*>> tracer->netid*/
>> tid
>> special
>> args[0]
>> args[1]
>> args[2]
>> args[3]
>> args[4]
/*>> goal->netid*/
>> dummy
>> translucency
>> waterlevel;
DWORD trans;
arc >> trans;
if (trans == (DWORD)0xffffffff)
translation = NULL;
else
translation = translationtables + trans;
spawnpoint.Serialize (arc);
if(type >= NUMMOBJTYPES)
I_Error("Unknown object type in saved game");
if(sprite >= NUMSPRITES)
I_Error("Unknown sprite in saved game");
info = &mobjinfo[type];
touching_sectorlist = NULL;
LinkToWorld ();
AddToHash ();
if(playerid && validplayer(idplayer(playerid)))
{
player = &idplayer(playerid);
player->mo = ptr();
player->camera = player->mo;
}
}
}