void print(int level, FILE *file) { int count = 0; fprintf (file, "{"); for (map<StringObject *, BaseObject *>::iterator iter = m_map.begin(); iter != m_map.end(); iter ++) { if (count > 0) { fprintf (file, ", "); } StringObject *key = iter->first; BaseObject *obj = iter->second; key->print(level, file); fprintf (file, ": "); obj->print(level + 1, file); count ++; } fprintf (file, "}"); }
bool StringObject::deletePropertyByIndex(JSCell* cell, ExecState* exec, unsigned i) { StringObject* thisObject = jsCast<StringObject*>(cell); if (thisObject->internalValue()->canGetIndex(i)) return false; return JSObject::deletePropertyByIndex(thisObject, exec, i); }
bool StringObject::getOwnPropertySlot(JSObject* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot) { StringObject* thisObject = jsCast<StringObject*>(cell); if (thisObject->internalValue()->getStringPropertySlot(exec, propertyName, slot)) return true; return JSObject::getOwnPropertySlot(thisObject, exec, propertyName, slot); }
bool StringObject::getOwnPropertySlotByIndex(JSObject* object, ExecState* exec, unsigned propertyName, PropertySlot& slot) { StringObject* thisObject = jsCast<StringObject*>(object); if (thisObject->internalValue()->getStringPropertySlot(exec, propertyName, slot)) return true; return JSObject::getOwnPropertySlot(thisObject, exec, Identifier::from(exec, propertyName), slot); }
bool StringObject::getOwnPropertySlot(JSCell* cell, ExecState* exec, unsigned propertyName, PropertySlot& slot) { StringObject* thisObject = static_cast<StringObject*>(cell); if (thisObject->internalValue()->getStringPropertySlot(exec, propertyName, slot)) return true; return JSObject::getOwnPropertySlot(thisObject, exec, Identifier::from(exec, propertyName), slot); }
bool StringObject::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor) { StringObject* thisObject = jsCast<StringObject*>(object); if (thisObject->internalValue()->getStringPropertyDescriptor(exec, propertyName, descriptor)) return true; return JSObject::getOwnPropertyDescriptor(thisObject, exec, propertyName, descriptor); }
/* Returns the taint on an object. * - Currently only arrays and java.lang.String is supported */ u4 getObjectTaint(Object* obj, const char* descriptor) { ArrayObject *arrObj = NULL; if (obj == NULL) { return TAINT_CLEAR; } if (descriptor[0] == '[') { /* Get the taint from the array */ arrObj = (ArrayObject*) obj; if (arrObj != NULL) { return arrObj->taint.tag; } } if (strcmp(descriptor, "Ljava/lang/String;") == 0) { StringObject * strObj = (StringObject*) obj; arrObj = strObj->array(); if (arrObj != NULL) { return arrObj->taint.tag; } /* else, empty string? don't worry about it */ } /* TODO: What about classes derived from String? */ /* Don't worry about other object types */ return TAINT_CLEAR; }
void StringObject::getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode) { StringObject* thisObject = jsCast<StringObject*>(object); int size = thisObject->internalValue()->length(); for (int i = 0; i < size; ++i) propertyNames.add(Identifier(exec, String::number(i))); if (mode == IncludeDontEnumProperties) propertyNames.add(exec->propertyNames().length); return JSObject::getOwnPropertyNames(thisObject, exec, propertyNames, mode); }
bool StringObject::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName) { StringObject* thisObject = jsCast<StringObject*>(cell); if (propertyName == exec->propertyNames().length) return false; Optional<uint32_t> index = parseIndex(propertyName); if (index && thisObject->internalValue()->canGetIndex(index.value())) return false; return JSObject::deleteProperty(thisObject, exec, propertyName); }
bool StringObject::putByIndex(JSCell* cell, ExecState* exec, unsigned propertyName, JSValue value, bool shouldThrow) { VM& vm = exec->vm(); auto scope = DECLARE_THROW_SCOPE(vm); StringObject* thisObject = jsCast<StringObject*>(cell); if (thisObject->internalValue()->canGetIndex(propertyName)) return typeError(exec, scope, shouldThrow, ASCIILiteral(ReadonlyPropertyWriteError)); return JSObject::putByIndex(cell, exec, propertyName, value, shouldThrow); }
void StringObject::putByIndex(JSCell* cell, ExecState* exec, unsigned propertyName, JSValue value, bool shouldThrow) { StringObject* thisObject = jsCast<StringObject*>(cell); if (thisObject->internalValue()->canGetIndex(propertyName)) { if (shouldThrow) throwTypeError(exec, StrictModeReadonlyPropertyWriteError); return; } JSObject::putByIndex(cell, exec, propertyName, value, shouldThrow); }
bool StringObject::deleteProperty(JSCell* cell, ExecState* exec, const Identifier& propertyName) { StringObject* thisObject = static_cast<StringObject*>(cell); if (propertyName == exec->propertyNames().length) return false; bool isStrictUInt32; unsigned i = propertyName.toUInt32(isStrictUInt32); if (isStrictUInt32 && thisObject->internalValue()->canGetIndex(i)) return false; return JSObject::deleteProperty(thisObject, exec, propertyName); }
// Arity: 2 -> 0 Ref * sysMD5( Ref * pc, class MachineClass * vm ) { if ( vm->count != 1 ) throw Ginger::Mishap( "ArgsMismatch" ); StringObject input = Cell( vm->fastPop() ).asStringObject(); MD5Digester digester; digester.update( input.getCharPtr(), input.length() ); vm->fastPush( vm->heap().copyString( pc, digester.digest().c_str() ) ); return pc; }
bool StringObject::deleteProperty(JSCell* cell, ExecState* exec, PropertyName propertyName) { StringObject* thisObject = jsCast<StringObject*>(cell); if (propertyName == exec->propertyNames().length) return false; unsigned i = propertyName.asIndex(); if (thisObject->internalValue()->canGetIndex(i)) { ASSERT(i != PropertyName::NotAnIndex); // No need for an explicit check, the above test would always fail! return false; } return JSObject::deleteProperty(thisObject, exec, propertyName); }
bool StringObject::less(IObject *obj) { StringObject *temp = dynamic_cast<StringObject*>(obj); if(this->equal(obj)) return false; int min = strlen(value); if((int)strlen(temp->getStr()) < min) min = strlen(temp->getStr()); char *checkThis = this->getStr(); char *checkObj = temp->getStr(); int count = 0; for(count = 0; count < min; ++count) { if(checkThis[count] > checkObj[count]) return false; else if(checkThis[count] < checkObj[count]) return true; } if(count == (int)strlen(value)) return true; else return false; }
void ObjTracer::extract_str(const Object * const obj, ObjWriteMode flag) { if ( !check_obj ( obj ) ) { ALOG(LOG_VERBOSE, "YWB", "OBJECT NULL"); fprintf(traceFile_, "\n"); return; } else { StringObject * so = (StringObject *) obj; const u2 *s = so->chars(); if ( s == NULL ) { ALOG(LOG_VERBOSE, "YWB","string is null"); return; } this->record_str( obj, s, sizeof(u2) * so->length(), flag ); } }
bool StringObject::defineOwnProperty(JSObject* object, ExecState* exec, PropertyName propertyName, const PropertyDescriptor& descriptor, bool throwException) { VM& vm = exec->vm(); auto scope = DECLARE_THROW_SCOPE(vm); StringObject* thisObject = jsCast<StringObject*>(object); if (isStringOwnProperty(exec, thisObject, propertyName)) { // The current PropertyDescriptor is always // PropertyDescriptor{[[Value]]: value, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false}. // This ensures that any property descriptor cannot change the existing one. // Here, simply return the result of validateAndApplyPropertyDescriptor. // https://tc39.github.io/ecma262/#sec-string-exotic-objects-getownproperty-p PropertyDescriptor current; bool isCurrentDefined = thisObject->getOwnPropertyDescriptor(exec, propertyName, current); ASSERT(isCurrentDefined); bool isExtensible = thisObject->isExtensible(exec); RETURN_IF_EXCEPTION(scope, false); return validateAndApplyPropertyDescriptor(exec, nullptr, propertyName, isExtensible, descriptor, isCurrentDefined, current, throwException); } return Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException); }
void Tracer::extract_str (Object * obj, ObjWriteMode flag) { if ( !check_obj ( obj ) ) { FILE *f; ALOG(LOG_VERBOSE, "YWB", "OBJECT NULL"); if (flag == OPC_OBJ || flag == OPC_STR) f = fpObj_; else if (flag == FUNC_STR || flag == FUNC_OBJ) f = fpFuncs_; else { ALOG ( LOG_VERBOSE, "YWB", "error in which file to write" ); return; } fprintf(f, "\n"); fflush(f); return; } /* if ( strcmp (obj->clazz->descriptor, "Ljava/lang/String;") != 0) { ALOG(LOG_VERBOSE,"YWB","NOT STRING"); return; } */ { StringObject * so = (StringObject *) obj; const u2 *s = so->chars(); if ( s == NULL ) { ALOG(LOG_VERBOSE, "YWB","string is null"); return; } this->record_str( s, sizeof(u2) * so->length(), flag ); } }
////////////////////////////////////////////////////////////// // Send SMS alert ////////////////////////////////////////////////////////////// bool CSNAPIClient::sms(CHARPTR host,USHORT port,CHARPTR sender,CHARPTR dialno,CHARPTR start) { CMemplate memplate; CHttpClient client; StringObject result; httpResponseCode ret; // Build URI CHAR uri[CBUFF_MEDIUM]; sprintf(uri,"http://%s:%u/smsalert",host,port); result.Create(); memplate.create(&babylon); memplate.createField(MTF_TEXT,"name","64,1,\""); memplate.createField(MTF_TEXT,"number","64,1,\""); SMetastruct *meta = memplate.metaAlloc("guests",10); int counter=2; // Sneak in extra params meta->set(0,0,sender); meta->set(0,1,dialno); meta->set(1,0,start); meta->set(1,1,""); // Build list onSMSRequest(*meta); // Post request client.registerComs(this); ret = client.httpPost(uri,*meta,result); delete meta; result.Destroy(); return ret == 200; }
bool StringObject::defineOwnProperty(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor, bool throwException) { StringObject* thisObject = jsCast<StringObject*>(object); if (propertyName == exec->propertyNames().length) { if (!object->isExtensible()) { if (throwException) throwError(exec, createTypeError(exec, ASCIILiteral("Attempting to define property on object that is not extensible."))); return false; } if (descriptor.configurablePresent() && descriptor.configurable()) { if (throwException) throwError(exec, createTypeError(exec, ASCIILiteral("Attempting to configurable attribute of unconfigurable property."))); return false; } if (descriptor.enumerablePresent() && descriptor.enumerable()) { if (throwException) throwError(exec, createTypeError(exec, ASCIILiteral("Attempting to change enumerable attribute of unconfigurable property."))); return false; } if (descriptor.isAccessorDescriptor()) { if (throwException) throwError(exec, createTypeError(exec, ASCIILiteral("Attempting to change access mechanism for an unconfigurable property."))); return false; } if (descriptor.writablePresent() && descriptor.writable()) { if (throwException) throwError(exec, createTypeError(exec, ASCIILiteral("Attempting to change writable attribute of unconfigurable property."))); return false; } if (!descriptor.value()) return true; if (propertyName == exec->propertyNames().length && sameValue(exec, descriptor.value(), jsNumber(thisObject->internalValue()->length()))) return true; if (throwException) throwError(exec, createTypeError(exec, ASCIILiteral("Attempting to change value of a readonly property."))); return false; } return Base::defineOwnProperty(object, exec, propertyName, descriptor, throwException); }
void test3() { printf("Test 3 started!\n"); StringObject* all = newStringObject(); StringObject* first = newStringObject(); StringObject* second = newStringObject(); int pid1, pid2; all->append(all, "A child processed died."); first->append(first, "A child processed died.2"); second->append(second, "A child processed died.3"); proc_waiter_register(-1, proc_wait_cb, all); proc_waiter_register(-1, proc_wait_cb, first); proc_waiter_register(-1, proc_wait_cb, second); pid1 = fork(); if(!pid1) { usleep(1000); exit(0); } usleep(10000); proc_waiter_deregister(-1, NULL, first); pid2 = fork(); if(!pid2) { usleep(1000); exit(0); } sleep(1); proc_waiter_deregister_all(); proc_waiter_stop(); printf("Test 3 complete!\n\n\n"); }
inline StringObject* StringObject::create(ExecState* exec, JSGlobalObject* globalObject, JSString* string) { StringObject* object = new (NotNull, allocateCell<StringObject>(*exec->heap())) StringObject(exec->globalData(), globalObject->stringObjectStructure()); object->finishCreation(exec->globalData(), string); return object; }
bool StringObject::equal(IObject *obj) { StringObject *temp = dynamic_cast<StringObject*>(obj); if((strcmp(this->value, temp->getStr())) == 0) return true; else return false; }
StringObject* constructString(VM& vm, JSGlobalObject* globalObject, JSValue string) { StringObject* object = StringObject::create(vm, globalObject->stringObjectStructure()); object->setInternalValue(vm, string); return object; }
////////////////////////// // Read header & populate string with body ////////////////////////// bool CMimeProtocol::readMimeResponse(int link,CHARPTR headers,int size,StringObject& content) { CHAR buffer[CBUFF_HUGE+2]; CHARPTR ptrHeadEnd; CHARPTR ptrContLen; int read=0; int bytes; // 1st read headers while(true){ // Wait if(!waitForEvent(link,10000)){ content.strcpy(headers); return read > 0; } // Read next lot if((bytes = recvTcp(link,&headers[read],size-read)) <= 0) return false; read+=bytes; headers[read]=0; // Check for header & body ptrHeadEnd=strstr(headers,"\r\n\r\n"); // No header yet if(ptrHeadEnd) break; } ptrContLen=strstr(headers,"Content-Length: "); int contentLength; // Terminate *ptrHeadEnd=0; // Header & nobody - copy headers if(!ptrContLen){ // Just keep reading until server closes connection contentLength=128000; content.strcpy(headers); } else{ // Get content length if(!strparse(ptrContLen,"Content-Length: %1d",&contentLength)) return false; // Skip to start of body ptrHeadEnd += strlen("\r\n\r\n"); content.strcpy(ptrHeadEnd); } // Calculate remaining read = strlen(ptrHeadEnd); while(read < contentLength){ // Read next lot if((bytes = recvTcp(link,buffer,CBUFF_HUGE)) <= 0){ switch(bytes){ // Remote closure case 0: return true; // Error - check default: switch(OSALASTERROR){ // No data to read - try again case OSAWOULDBLOCK: if(!waitForEvent(link,2000)) return false; continue; // Oh oh default: return false; } break; } } buffer[bytes] = 0; read+=bytes; content.strcat(buffer); } // Good to go return true; }
ToUnicodeCMap::ToUnicodeCMap(IndirectObject * io) { this->indirectObject = io; if(io != null) { //Probably not necessary but harmless io->load(); io->processAsStream(); } if(this->indirectObject->unencodedStream != null) { char * stream = this->indirectObject->unencodedStream; char * bcsr = strstr(stream, "begincodespacerange"); bcsr += 19; //skip 'begincodespacerange' keyword bcsr = StringUtils::skipWhiteSpace(bcsr, this->indirectObject->unencodedStreamSize - (bcsr - stream)); do { StringObject * codeFrom = new StringObject(&bcsr, bcsr); StringObject * codeTo = new StringObject(&bcsr, bcsr); if(codeFrom->isHexa && codeTo->isHexa) { codeRanges.push_front(make_pair(codeFrom, codeTo)); } else { cerr<<"\nToUnicodeMap: Couldn't read code ranges properly.\n"; break; } bcsr = StringUtils::skipWhiteSpace(bcsr, this->indirectObject->unencodedStreamSize - (bcsr - stream)); }while(*bcsr == '<'); codeRanges.sort(compareRangeLen); char * bbfc = strstr(stream, "beginbfchar"); while(bbfc != null) { bbfc += 11; //skip 'beginbfchar' keyword do { StringObject code = StringObject(&bbfc, bbfc); StringObject * utfString = new StringObject(&bbfc, bbfc); if(code.isHexa) codeCharMap[code.toNum()] = utfString; bbfc = StringUtils::skipWhiteSpace(bbfc, this->indirectObject->unencodedStreamSize - (bbfc - stream)); }while(*bbfc == '<'); bbfc = strstr(bbfc, "beginbfchar"); } list<bfrange> rangeMapList; bbfc = strstr(stream, "beginbfrange"); while(bbfc != null) { bbfc += 12; do { StringObject beginCode = StringObject(&bbfc, bbfc); StringObject endCode = StringObject(&bbfc, bbfc); PdfObject * objectForRange = PdfObject::readValue(&bbfc, bbfc, false); BFRange bfr = BFRange(); bfr.begin = beginCode.toNum(); bfr.end = endCode.toNum(); bfr.object = objectForRange; rangeMapList.push_front(bfr); bbfc = StringUtils::skipWhiteSpace(bbfc, this->indirectObject->unencodedStreamSize - (bbfc - stream)); }while(*bbfc == '<'); bbfc = strstr(bbfc, "beginbfrange"); } rangeMapList.sort(compareBFRanges); while(!rangeMapList.empty()) { codeRangeMapVector.push_back(rangeMapList.front()); rangeMapList.pop_front(); } } }
inline StringObject* StringObject::create(VM& vm, JSGlobalObject* globalObject, JSString* string) { StringObject* object = new (NotNull, allocateCell<StringObject>(vm.heap)) StringObject(vm, globalObject->stringObjectStructure()); object->finishCreation(vm, string); return object; }
StringObject * ToUnicodeCMap::getUTFChar(unsigned char * charCode, int len) { int charCodeNum = 0; for(int i = 0; i<len; i++) { charCodeNum *= 16; charCodeNum += charCode[i]; } StringObject * utfChar = codeCharMap[charCodeNum]; if(utfChar == null) { //try to find range for char BFRange * range = null; int endSearch = codeRangeMapVector.size()-1; if(endSearch > 0) { int beginSearch = 0; do { int actualSearch = (beginSearch + endSearch) / 2; BFRange * actualItem = &codeRangeMapVector[actualSearch]; if(actualItem->begin <= charCodeNum && actualItem->end >= charCodeNum) { range = actualItem; break; } if(actualItem->begin > charCodeNum) { endSearch = actualSearch-1; } else { beginSearch = actualSearch+1; } }while(beginSearch <= endSearch); } if(range == null) { //Couldn't map character properly. return null; } else { int increment = charCodeNum - range->begin; if(range->object->objectType == PdfObject::TYPE_STRING) { StringObject * string = (StringObject*) range->object; int numResult = string->toNum(); numResult += increment; int len = string->getByteStringLen()*2; char * hexaString = new char[len+3]; hexaString[0] = '<'; hexaString[len+1] = '>'; hexaString[len+2] = 0; for(int i = len; i>0; i--) { int byte = numResult % 16; switch(byte) { case 0: hexaString[i] = '0'; break; case 1: hexaString[i] = '1'; break; case 2: hexaString[i] = '2'; break; case 3: hexaString[i] = '3'; break; case 4: hexaString[i] = '4'; break; case 5: hexaString[i] = '5'; break; case 6: hexaString[i] = '6'; break; case 7: hexaString[i] = '7'; break; case 8: hexaString[i] = '8'; break; case 9: hexaString[i] = '9'; break; case 10: hexaString[i] = 'A'; break; case 11: hexaString[i] = 'B'; break; case 12: hexaString[i] = 'C'; break; case 13: hexaString[i] = 'D'; break; case 14: hexaString[i] = 'E'; break; case 15: hexaString[i] = 'F'; break; } numResult /= 16; } char * _dummy = null; utfChar = new StringObject(&_dummy, hexaString); } else if(range->object->objectType == PdfObject::TYPE_ARRAY) { ArrayObject * utfArray = (ArrayObject*) range->object; utfChar = (StringObject*) utfArray->objectList[increment]; } else { //Couldn't find utf value in found range. return null; } // add result to char map - so there is no need to create the string again next time the char is used this->codeCharMap[charCodeNum] = utfChar; } } return utfChar; }
void thingamadooberObject::init(const StringObject &src) { delete tokenizer; tokenizer=new StringTokenizer(src.AsCharArray(),""); }
StringObject* constructString(ExecState* exec, JSGlobalObject* globalObject, JSValue string) { StringObject* object = StringObject::create(exec, globalObject->stringObjectStructure()); object->setInternalValue(exec->globalData(), string); return object; }