void delete_vars(UniVar *vars, int which) { while(--which) { if (IsStr(which) && !IsProc(which)) { #ifdef DEBUG debug("(delete_vars) deleting string var `%s'\n",VarName[which].name); #endif /* DEBUG */ Free((char**)&vars[which].str_var); } } #ifdef DEBUG debug("(delete_vars) all done\n"); #endif /* DEBUG */ }
OP_STATUS SoundUtils::SoundIt(const OpStringC &sndfile, BOOL force, BOOL async) { OP_STATUS rc = OpStatus::OK; if ((!g_pcui->GetIntegerPref(PrefsCollectionUI::SoundsEnabled) && !force) || !IsStr(sndfile.CStr())) return rc; OpString osPrefsNoSound; TRAP_AND_RETURN(rc, g_languageManager->GetStringL(Str::SI_NO_SOUND_STRING, osPrefsNoSound)); if (sndfile.CompareI(osPrefsNoSound) == 0 || sndfile.Compare("None") == 0) return OpStatus::ERR; #if defined(MSWIN) rc = ( sndPlaySound(sndfile.CStr(), (async ? SND_ASYNC : SND_SYNC) | SND_NODEFAULT)==TRUE ? OpStatus::OK : OpStatus::ERR); #elif defined(_UNIX_DESKTOP_) if (g_audio_player) { char *filename = uni_down_strdup(sndfile.CStr()); if (!filename) return OpStatus::ERR_NO_MEMORY; WavFile *wav = OP_NEW(WavFile, ()); if (!wav) { rc = OpStatus::ERR_NO_MEMORY; } else { if (wav->Open(filename)) { g_audio_player->Play(wav); } else { OP_DELETE(wav); rc = OpStatus::ERR; } } op_free(filename); } #elif defined(_MACINTOSH_) rc = (MacPlaySound(sndfile.CStr(), async) == TRUE) ? OpStatus::OK : OpStatus::ERR; #endif return rc; }
void copy_vars(UniVar *dst, UniVar *src) { int i; for(i=0;i<CHANSET_SIZE;i++) { if (IsStr(i)) { if (src[i].str_var) { set_mallocdoer(copy_vars); dst[i].str_var = Strdup(src[i].str_var); } } else { dst[i].int_var = src[i].int_var; } } }
uint64 LLBC_Variant::AsUInt64() const { if (IsNil()) { return 0; } else if (IsDict()) { return 0; } else if (IsStr()) { return LLBC_Str2UInt64(_holder.str.c_str()); } if (IsDouble() || IsFloat()) { return static_cast<uint64>(_holder.raw.doubleVal); } return _holder.raw.uint64Val; }
bool LLBC_Variant::AsBool() const { if (IsNil()) { return false; } else if (IsDict()) { return false; } else if (IsStr()) { LLBC_String trimedData(LLBC_Trim(_holder.str)); if (trimedData.length() != 4 && trimedData.length() != 5) { return (AsInt64() != 0 ? true : false); } LLBC_String lowerData(LLBC_ToLower(trimedData.c_str())); return (lowerData == "true" ? true : false); } return _holder.raw.uint64Val != 0; }
bool CTag::WriteNewEd2kTag(CFileDataIO* data, EUtf8Str eStrEncode) const { // Write tag type uint8 uType; if (IsInt()) { if (m_uVal <= 0xFF) { uType = TAGTYPE_UINT8; } else if (m_uVal <= 0xFFFF) { uType = TAGTYPE_UINT16; } else if (m_uVal <= 0xFFFFFFFF) { uType = TAGTYPE_UINT32; } else { uType = TAGTYPE_UINT64; } } else if (IsStr()) { uint16 uStrValLen = GetRawSize(*m_pstrVal, eStrEncode); if (uStrValLen >= 1 && uStrValLen <= 16) { uType = TAGTYPE_STR1 + uStrValLen - 1; } else { uType = TAGTYPE_STRING; } } else { uType = m_uType; } // Write tag name if (!m_Name.IsEmpty()) { data->WriteUInt8(uType); data->WriteString(m_Name,utf8strNone); } else { wxASSERT( m_uName != 0 ); data->WriteUInt8(uType | 0x80); data->WriteUInt8(m_uName); } // Write tag data switch (uType) { case TAGTYPE_STRING: data->WriteString(*m_pstrVal,eStrEncode); break; case TAGTYPE_UINT64: data->WriteUInt64(m_uVal); break; case TAGTYPE_UINT32: data->WriteUInt32(m_uVal); break; case TAGTYPE_UINT16: data->WriteUInt16(m_uVal); break; case TAGTYPE_UINT8: data->WriteUInt8(m_uVal); break; case TAGTYPE_FLOAT32: //#warning Endianess problem? data->Write(&m_fVal, 4); break; case TAGTYPE_HASH16: data->WriteHash(*m_hashVal); break; case TAGTYPE_BLOB: data->WriteUInt32(m_nSize); data->Write(m_pData, m_nSize); break; default: // See comment on the default: of CTag::CTag(const CFileDataIO& data, bool bOptUTF8) if (uType >= TAGTYPE_STR1 && uType <= TAGTYPE_STR16) { // Sending '0' as len size makes it not write the len on the IO file. // This is because this tag types send the len as their type. data->WriteString(*m_pstrVal,eStrEncode,0); } else { printf("%s; Unknown tag: type=0x%02X\n", __FUNCTION__, uType); wxFAIL; return false; } break; } return true; }
const wxString& CTag::GetStr() const { CHECK_TAG_TYPE(IsStr(), String); return *m_pstrVal; }
bool CTag::WriteNewEd2kTag(CFileDataIO* data, EUtf8Str eStrEncode) const { ASSERT_VALID(this); // Write tag type uint8 uType; UINT uStrValLen = 0; LPCSTR pszValA = NULL; CStringA* pstrValA = NULL; if (IsInt()) { if (m_uVal <= 0xFF) uType = TAGTYPE_UINT8; else if (m_uVal <= 0xFFFF) uType = TAGTYPE_UINT16; else uType = TAGTYPE_UINT32; } else if (IsStr()) { #ifdef _UNICODE if (eStrEncode == utf8strRaw) { CUnicodeToUTF8 utf8(*m_pstrVal); pstrValA = new CStringA((LPCSTR)utf8, utf8.GetLength()); } else if (eStrEncode == utf8strOptBOM) { if (NeedUTF8String(*m_pstrVal)) { CUnicodeToBOMUTF8 bomutf8(*m_pstrVal); pstrValA = new CStringA((LPCSTR)bomutf8, bomutf8.GetLength()); } else { CUnicodeToMultiByte mb(*m_pstrVal); pstrValA = new CStringA((LPCSTR)mb, mb.GetLength()); } } else { CUnicodeToMultiByte mb(*m_pstrVal); pstrValA = new CStringA((LPCSTR)mb, mb.GetLength()); } uStrValLen = pstrValA->GetLength(); pszValA = *pstrValA; #else uStrValLen = m_pstrVal->GetLength(); pszValA = *m_pstrVal; #endif if (uStrValLen >= 1 && uStrValLen <= 16) uType = TAGTYPE_STR1 + uStrValLen - 1; else uType = TAGTYPE_STRING; } else uType = m_uType; // Write tag name if (m_pszName) { data->WriteUInt8(uType); UINT uTagNameLen = strlen(m_pszName); data->WriteUInt16(uTagNameLen); data->Write(m_pszName, uTagNameLen); } else { ASSERT( m_uName != 0 ); data->WriteUInt8(uType | 0x80); data->WriteUInt8(m_uName); } // Write tag data if (uType == TAGTYPE_STRING) { data->WriteUInt16(uStrValLen); data->Write(pszValA, uStrValLen); } else if (uType >= TAGTYPE_STR1 && uType <= TAGTYPE_STR16) { data->Write(pszValA, uStrValLen); } else if (uType == TAGTYPE_UINT32) { data->WriteUInt32(m_uVal); } else if (uType == TAGTYPE_UINT16) { data->WriteUInt16(m_uVal); } else if (uType == TAGTYPE_UINT8) { data->WriteUInt8(m_uVal); } else if (uType == TAGTYPE_FLOAT32) { data->Write(&m_fVal, 4); } else if (uType == TAGTYPE_HASH) { data->WriteHash16(m_pData); } else if (uType == TAGTYPE_BLOB) { data->WriteUInt32(m_nBlobSize); data->Write(m_pData, m_nBlobSize); } else { TRACE("%s; Unknown tag: type=0x%02X\n", __FUNCTION__, uType); ASSERT(0); return false; } delete pstrValA; return true; }
bool LLBC_Variant::DeSerialize(LLBC_Stream &stream) { BecomeNil(); if (!stream.Read(_holder.type)) { return false; } if (IsNil()) { return true; } if (IsRaw()) { if (!stream.Read(_holder.raw.uint64Val)) { _holder.type = LLBC_VariantType::VT_NIL; return false; } } else if (IsStr()) { if (!stream.Read(_holder.str)) { _holder.type = LLBC_VariantType::VT_NIL; return false; } } else if (IsDict()) { uint32 count = 0; if (!stream.Read(count)) { _holder.type = LLBC_VariantType::VT_NIL; return false; } if (count == 0) { return true; } _holder.dict = new Dict; for (uint32 i = 0; i < count; i ++) { LLBC_Variant key; LLBC_Variant val; if (!stream.Read(key) || !stream.Read(val)) { LLBC_XDelete(_holder.dict); _holder.type = LLBC_VariantType::VT_NIL; return false; } _holder.dict->insert(std::make_pair(key, val)); } return true; } return false; }
LLBC_String LLBC_Variant::ValueToString() const { if (IsStr()) { return _holder.str; } else if (IsDict()) { LLBC_String content; content.append("{"); if (_holder.dict) { for (DictConstIter it = _holder.dict->begin(); it != _holder.dict->end(); ) { content.append(it->first.ValueToString()); content.append(":"); content.append(it->second.ValueToString()); if (++ it != _holder.dict->end()) { content.append("|"); } } } content.append("}"); return content; } else if (IsNil()) { return "nil"; } // RAW type var data. switch(_holder.type) { case LLBC_VariantType::VT_RAW_BOOL: return _holder.raw.int64Val != 0 ? "true" : "false"; case LLBC_VariantType::VT_RAW_SINT8: case LLBC_VariantType::VT_RAW_SINT16: case LLBC_VariantType::VT_RAW_SINT32: case LLBC_VariantType::VT_RAW_LONG: case LLBC_VariantType::VT_RAW_SINT64: return LLBC_Num2Str(_holder.raw.int64Val); case LLBC_VariantType::VT_RAW_UINT8: case LLBC_VariantType::VT_RAW_UINT16: case LLBC_VariantType::VT_RAW_UINT32: case LLBC_VariantType::VT_RAW_ULONG: case LLBC_VariantType::VT_RAW_UINT64: return LLBC_Num2Str(_holder.raw.uint64Val); case LLBC_VariantType::VT_RAW_FLOAT: case LLBC_VariantType::VT_RAW_DOUBLE: return LLBC_Num2Str(_holder.raw.doubleVal); default: break; } return ""; }
void do_set(COMMAND_ARGS) { /* * on_msg checks: */ Chan *chan; UniVar *univar,*varval; char tmp[MSGLEN]; char *pp,*channel,*name; int n,which,i,sz,limit,uaccess; /* * */ channel = get_channel2(to,&rest); chan = find_channel_ny(channel); name = chop(&rest); /* * empty args, its "set" or "set #channel" */ if (!name) { if (!chan) { to_user(from,ERR_CHAN,channel); return; } if (!CurrentDCC) return; i = CHANSET_SIZE; limit = SIZE_VARS - 1; univar = current->setting; *tmp = 0; if ((uaccess = get_useraccess(from,GLOBAL_CHANNEL))) to_user(from,str_underline("Global settings")); second_pass: for(;i<limit;i++) { if (uaccess < VarName[i].uaccess) continue; varval = (IsProc(i)) ? current->setting[i].proc_var : &univar[i]; sz = Strlen2(tmp,VarName[i].name); if (IsStr(i)) { sz += (varval->str_var) ? strlen(varval->str_var) : 7; } if (sz > 58) { to_user(from,FMT_PLAIN,tmp); *tmp = 0; } if (IsInt(i)) { pp = tolowercat(tmp,VarName[i].name); sprintf(pp,(IsChar(i)) ? "=`%c' " : "=%i ",varval->int_var); } else if (IsStr(i)) { pp = tolowercat(tmp,VarName[i].name); sprintf(pp,(varval->str_var) ? "=\"%s\" " : "=(unset) ",varval->str_var); } else if (IsTog(i)) { pp = Strcat(tmp,(varval->int_var) ? "+" : "-"); pp = tolowercat(pp,VarName[i].name); pp[0] = ' '; pp[1] = 0; } } if (*tmp && tmp[1]) to_user(from,FMT_PLAIN,tmp); if (limit != CHANSET_SIZE) { to_user(from,"\037Channel settings: %s\037",(chan) ? chan->name : rest); i = 0; limit = CHANSET_SIZE; univar = chan->setting; *tmp = 0; uaccess = get_useraccess(from,(chan) ? chan->name : rest); goto second_pass; } return; } /* * alter a setting */ if ((which = find_setting(name)) == -1) { set_usage: usage(from); /* usage for CurrentCmd->name */ return; } if ((which < CHANSET_SIZE) && *channel != '*') { if (!chan) { to_user(from,ERR_CHAN,channel); return; } /* * its a channel setting */ channel = chan->name; varval = &chan->setting[which]; } else { /* * its a global setting */ channel = MATCH_ALL; varval = ¤t->setting[which]; } if (VarName[which].uaccess > get_authaccess(from,channel)) return; /* * Check each type and process `rest' if needed. */ n = 0; if (IsChar(which)) { if (rest[1]) goto set_usage; } else if (IsNum(which)) { if (IsTog(which)) { if (!Strcasecmp(rest,"ON")) { n = 1; goto num_data_ok; } else if (!Strcasecmp(rest,"OFF")) { /* n is 0 by default */ goto num_data_ok; } } n = a2i((rest = chop(&rest))); if (errno || n < VarName[which].min || n > VarName[which].max) { to_user(from,"Possible values are %i through %i",VarName[which].min,VarName[which].max); return; } } num_data_ok: /* * */ if ((which < CHANSET_SIZE) && *channel == '*') { for(chan=current->chanlist;chan;chan=chan->next) { if (IsNum(which)) { chan->setting[which].int_var = n; } else if (IsStr(which)) { Free((char**)&chan->setting[which].str_var); if (*rest) { set_mallocdoer(do_set); chan->setting[which].str_var = Strdup(rest); } } } channel = "(all channels)"; } else { if (IsProc(which)) varval = varval->proc_var; if (IsChar(which)) varval->char_var = *rest; else if (IsNum(which)) varval->int_var = n; else { if (varval->str_var) Free((char**)&varval->str_var); if (*rest) { set_mallocdoer(do_set); varval->str_var = Strdup(rest); } } } to_user(from,"Var: %s On: %s Set to: %s",VarName[which].name, (which >= CHANSET_SIZE) ? "(global)" : channel,(*rest) ? rest : NULLSTR); if (VarName[which].func) VarName[which].func(&VarName[which]); }
void ec_set(char *from, char *to) { Chan *chan; UniVar *varval; char num[20]; char *src; int which,uaccess; src = ec_src; while(*src && *src != ')') src++; if (*src != ')') return; *(src++) = 0; if ((which = find_setting(ec_src)) >= 0) { if (which >= CHANSET_SIZE) { uaccess = get_useraccess(from,ANY_CHANNEL); varval = ¤t->setting[which]; } else if ((chan = find_channel_ny(to))) { uaccess = get_useraccess(from,to); varval = &chan->setting[which]; } else { nobo_strcpy("(unknown channel)"); return; } if (uaccess < VarName[which].uaccess) return; if (IsProc(which)) varval = varval->proc_var; if (IsChar(which)) { num[0] = varval->char_var; num[1] = 0; nobo_strcpy(num); } else if (IsInt(which)) { sprintf(num,"%i",varval->int_var); nobo_strcpy(num); } else if (IsTog(which)) { nobo_strcpy((varval->int_var) ? "on" : "off"); } else if (IsStr(which)) { nobo_strcpy(nullstr(varval->str_var)); } } else { nobo_strcpy("(unknown setting)"); } ec_src = src; }