rb_encoding* rb_enc_from_index(int index) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
Encoding* enc = Encoding::from_index(env->state(), index);
if(enc->nil_p()) return 0;
return enc->get_encoding();
}
void UploadVideoImage(LPVOID lpParam)
{
UploadVideoImageInfo* pUploadInfo = (UploadVideoImageInfo*)lpParam;
string PackageDataSegment;
PackageDataSegment.append("site=");
PackageDataSegment.append(Encoding::Convert(pUploadInfo->strSite, CP_ACP));
PackageDataSegment.append("&videoid=");
PackageDataSegment.append(Encoding::Convert(pUploadInfo->strVideoId, CP_ACP));
PackageDataSegment.append("&xml=%3C%3Fxml%20version%3D%221.0%22%3F%3E%0D%0A%3CFile%20xmlns%3Adt%3D%22urn%3Aschemas-microsoft-com%3Adatatypes%22%3E%3CName%3E");
PackageDataSegment.append(Encoding::Convert(pUploadInfo->GetFileName(), CP_ACP));
PackageDataSegment.append("%3C/Name%3E%3CData%20dt%3Adt%3D%22bin.hex%22%3E");
PackageDataSegment.append(pUploadInfo->GetFileData());
PackageDataSegment.append("%3C/Data%3E%3C/File%3E");
vector<BYTE> vPostData(PackageDataSegment.length());
memcpy(&vPostData.at(0), PackageDataSegment.c_str(), PackageDataSegment.length());
vector<BYTE> vResponseData;
WebClient::Download(TEXT("http://wizard2.webdev.com/cgi-bin/article/uploadimages4video"), vResponseData, vPostData);
vResponseData.push_back(0);
Encoding encode;
TSTLSTRING strRetValue = CW2T(encode.Convert((const char*)&vResponseData.at(0), CP_ACP).c_str());
delete pUploadInfo;
}
ReloadEncodingDialog::ReloadEncodingDialog(TextEdit* textEdit,
const Encoding& fromEncoding,
const Encoding& toEncoding,
QWidget* parent)
: QDialog(parent),
m_fromEncoding(fromEncoding),
m_toEncoding(toEncoding),
m_textEdit(textEdit) {
QPushButton* cancelBtn = new QPushButton(tr("&Cancel"));
QPushButton* reloadBtn = new QPushButton(tr("&Reload"));
QPushButton* convertBtn = new QPushButton(tr("&Convert"));
auto buttonBox = new QDialogButtonBox(this);
// The button box takes ownership of the button
buttonBox->addButton(reloadBtn, QDialogButtonBox::ActionRole);
buttonBox->addButton(convertBtn, QDialogButtonBox::ActionRole);
buttonBox->addButton(cancelBtn, QDialogButtonBox::ResetRole);
auto label = new QLabel(
tr("Reload: reload current file from disk in %1\nConvert: convert current text in %1")
.arg(toEncoding.name()),
this);
QVBoxLayout* layout = new QVBoxLayout(this);
layout->addWidget(label);
layout->addWidget(buttonBox, 0, Qt::AlignRight);
setLayout(layout);
setWindowTitle(tr("%1: Reload or Convert to %2").arg(fromEncoding.name()).arg(toEncoding.name()));
setFixedHeight(sizeHint().height());
connect(cancelBtn, &QPushButton::clicked, this, &ReloadEncodingDialog::close);
connect(reloadBtn, &QPushButton::clicked, this, &ReloadEncodingDialog::reload);
connect(convertBtn, &QPushButton::clicked, this, &ReloadEncodingDialog::convert);
}
rb_encoding* rb_enc_find(const char* name) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
Encoding* enc = Encoding::find(env->state(), name);
if(enc->nil_p()) return 0;
return enc->get_encoding();
}
void Encoding::Info::show(STATE, Object* self, int level) {
Encoding* enc = as<Encoding>(self);
class_header(state, self);
indent_attribute(++level, "name"); enc->name()->show_simple(state, level);
indent_attribute(level, "dummy?"); enc->dummy()->show_simple(state, level);
close_body(level);
}
Encoding* Encoding::create(STATE, OnigEncodingType* enc, Object* dummy) {
Encoding* e = state->new_object<Encoding>(G(encoding));
e->dummy(state, dummy);
e->encoding_ = enc;
return e;
}
String* Time::locale_string(STATE, const char* data) {
String* str = String::create(state, data);
Encoding* locale = Encoding::find(state, "locale");
if(!locale->nil_p()) {
str->encoding(state, locale);
}
return str;
}
rb_encoding* rb_filesystem_encoding(void) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
Encoding* enc = Encoding::find(env->state(), "filesystem");
if(enc->nil_p()) {
return rb_ascii8bit_encoding();
} else {
return enc->get_encoding();
}
}
rb_encoding *rb_default_internal_encoding(void) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
Encoding* enc = Encoding::find(env->state(), "internal");
if(enc->nil_p()) {
return 0;
} else {
return enc->get_encoding();
}
}
rb_encoding* rb_locale_encoding(void) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
Encoding* enc = Encoding::find(env->state(), "locale");
if(enc->nil_p()) {
return rb_usascii_encoding();
} else {
return enc->get_encoding();
}
}
Encoding* Encoding::create(STATE, OnigEncodingType* enc, Object* dummy) {
Encoding* e = state->new_object<Encoding>(G(encoding));
e->dummy(state, dummy);
e->encoding_ = enc;
e->cache_index_ = cCachedOnigDatas - 1;
e->managed_ = false;
return e;
}
int rb_enc_get_index(VALUE obj) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
Object* val = env->get_object(obj);
Encoding* enc = Encoding::get_object_encoding(env->state(), val);
if(enc->nil_p()) return 0;
return Encoding::find_index(env->state(), enc->get_encoding()->name);
}
std::string estring::toStdString(std::string enc_name) const {
byte_const_iterator iter = _string.cbegin();
byte_string str;
Encoding* enc = Encoding::byName(enc_name);
while (iter != _string.end()) {
char_t i = encoding->next(iter);
enc->append(i, std::back_inserter(str));
}
return std::string(reinterpret_cast<char*>(&str[0]));
}
rb_encoding* rb_enc_get(VALUE obj) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
Object* val = env->get_object(obj);
if(!val->reference_p() && !val->symbol_p()) return 0;
Encoding* enc = Encoding::get_object_encoding(env->state(), val);
if(enc->nil_p()) return 0;
return enc->get_encoding();
}
rb_encoding* rb_to_encoding(VALUE obj) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
int index = rb_to_encoding_index(obj);
if(index < 0) return 0;
Encoding* enc = try_as<Encoding>(Encoding::from_index(env->state(), index));
if(!enc) return 0;
return enc->get_encoding();
}
rb_encoding* rb_enc_get(VALUE obj) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
int index = rb_enc_get_index(obj);
if(index < 0) return 0;
Encoding* enc = as<Encoding>(
Encoding::encoding_list(env->state())->get(env->state(), index));
return enc->get_encoding();
}
SymbolTable::Kind SymbolTable::detect_kind(STATE, const Symbol* sym) {
std::string str = strings[sym->index()];
size_t size = str.size();
uint8_t* p = reinterpret_cast<uint8_t*>(const_cast<char*>(str.c_str()));
Encoding* e = Encoding::from_index(state, encodings[sym->index()]);
OnigEncodingType* enc = e->encoding();
// Constants start with A-Z, followed by alphanumeric characters or '_' or
// non-ascii character.
if(isupper(*p)) {
uint8_t* e = p + size;
int n = 0, code = 0;
for(++p; p < e; p += n) {
n = Encoding::precise_mbclen(p, e, enc);
if(!ONIGENC_MBCLEN_CHARFOUND_P(n)) {
return SymbolTable::eNormal;
}
n = ONIGENC_MBCLEN_CHARFOUND_LEN(n);
code = ONIGENC_MBC_TO_CODE(enc, p, p + n);
if(!(ONIGENC_IS_CODE_ALNUM(enc, code) || *p == '_' || !ISASCII(*p))) {
return SymbolTable::eNormal;
}
}
return SymbolTable::eConstant;
}
if(p[0] == '@') {
// A class variable begins with @@
if(size > 1 && p[1] == '@') {
return SymbolTable::eCVar;
}
// An instance variable can't start with a digit and can't be just @.
if((size == 1) || (size > 1 && ISDIGIT(p[1]))) {
return SymbolTable::eNormal;
}
// An instance variable begins with @
return SymbolTable::eIVar;
}
// A system variable begins with __
if(size > 2 && p[0] == '_' && p[1] == '_') {
return SymbolTable::eSystem;
}
// Everything else is normal
return SymbolTable::eNormal;
}
void DeleteVideoToServer(LPVOID lpParam)
{
TCHAR* pKeyBuffer = (TCHAR*)lpParam;
TSTLSTRING strKey = TSTLSTRING(pKeyBuffer);
delete [] pKeyBuffer;
VideoInfo item = VideoDataManager::GetInstance().GetVideoInfo(strKey);
string PackageDataSegment("VideoID=");
PackageDataSegment.append(CT2A(item.VideoID.c_str()));
vector<BYTE> vPostData(PackageDataSegment.length());
memcpy(&vPostData.at(0), PackageDataSegment.c_str(), PackageDataSegment.length());
try
{
vector<BYTE> vResponseData;
WebClient::Download(VideoConfig::GetInstance().GetVideoProxyDeleteVideoUrl(), vResponseData, vPostData);
vResponseData.push_back(0);
Encoding encode;
TSTLSTRING strRetValue = CW2T(encode.Convert((const char*)&vResponseData.at(0), CP_UTF8).c_str());
TSTLSTRING::size_type pos = strRetValue.find(TEXT(":"));
if(pos == TSTLSTRING::npos)
{
TSTLSTRING ErrMsg(TEXT("·þÎñÆ÷·µ»ØÒì³££¡£¨"));
ErrMsg.append(strRetValue);
ErrMsg.append(TEXT("£©"));
VideoDataManager::GetInstance().ErrorDeleteVideoAndResume(strKey, ErrMsg);
throw Exception(ErrMsg);
}
if(TEXT("OK") == strRetValue.substr(0, pos))
{
TSTLSTRING strMsg(item.VideoName);
CTipsDlg::ShowTips(strMsg, false);
VideoDataManager::GetInstance().LocalDeleteVideo(strKey);
}
else
{
TSTLSTRING ErrMsg(TEXT("ɾ³ýÊÓƵʧ°Ü£¡£¨"));
ErrMsg.append(strRetValue.substr(pos + 1));
ErrMsg.append(TEXT("£©"));
VideoDataManager::GetInstance().ErrorDeleteVideoAndResume(strKey, ErrMsg);
throw Exception(ErrMsg);
}
}
catch(Exception& error)
{
VideoDataManager::GetInstance().VideoFail(strKey, error.GetMessage());
MessageBox(NULL, error.GetMessage().c_str(), TEXT("´íÎó"), MB_OK|MB_ICONERROR);
}
}
Encoding* Encoding::define(STATE, const char* name,
OnigEncodingType* enc, Object* dummy)
{
Encoding* e = create(state, enc, dummy);
e->name(state, String::create(state, name));
symbol_map(state)->store(state, state->symbol(name), e);
add_constant(state, name, e);
return e;
}
int rb_enc_get_index(VALUE obj) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
Object* val = env->get_object(obj);
if(!val->reference_p() && !val->symbol_p()) return -1;
Encoding* enc = Encoding::get_object_encoding(env->state(), val);
if(enc->nil_p()) return 0;
return Encoding::find_index(env->state(), enc->name()->c_str(env->state()));
}
void DecompressFile(){
cout << " What is the name of the file you want to decompress? " << endl;
string compressedFileName = GetLine();
ibstream filetoDecompress;
filetoDecompress.open(compressedFileName.c_str());
if (filetoDecompress.fail()) Error(" Failed to open the specified file");
cout << " What should we name the decompressed file? " << endl;
string newDecompedFile = GetLine();
Encoding dfile;
obstream decompedFile;
decompedFile.open(newDecompedFile.c_str());
dfile.decompress(filetoDecompress, decompedFile);
}
void CompressFile(){
Encoding inputFile;
cout << " What is the file name? " << endl;
string inputFileName = GetLine();
ibstream infile;
infile.open(inputFileName.c_str());
if (infile.fail()) Error("Can't open input file!");
cout << " What do you want to name the compressed file? " << endl;
string newFileName = GetLine();
obstream outfile;
outfile.open(newFileName.c_str());
if (outfile.fail())Error("That is not a valid file name");
inputFile.compress(infile, outfile);
}
QString Utils::jsFromScriptFile(const QString& scriptPath, const Encoding& enc)
{
QFile jsFile(scriptPath);
if (jsFile.exists() && jsFile.open(QFile::ReadOnly)) {
QString scriptBody = enc.decode(jsFile.readAll());
// Remove CLI script heading
if (scriptBody.startsWith("#!") && !jsFile.fileName().endsWith(COFFEE_SCRIPT_EXTENSION)) {
scriptBody.prepend("//");
}
if (jsFile.fileName().endsWith(COFFEE_SCRIPT_EXTENSION)) {
QVariant result = Utils::coffee2js(scriptBody);
if (result.toStringList().at(0) == "false") {
return QString();
} else {
scriptBody = result.toStringList().at(1);
}
}
jsFile.close();
return scriptBody;
} else {
return QString();
}
}
static QString jsFromScriptFile(const QString& scriptPath, const QString& scriptLanguage, const Encoding& enc)
{
QFile jsFile(scriptPath);
if (jsFile.exists() && jsFile.open(QFile::ReadOnly)) {
QString scriptBody = enc.decode(jsFile.readAll());
jsFile.close();
// Remove CLI script heading
if (scriptBody.startsWith("#!")) {
int len = scriptBody.indexOf(QRegExp("[\r\n]"));
if (len == -1) {
len = scriptBody.length();
}
scriptBody.remove(0, len);
}
// If a language is specified and is not "javascript", reject it.
if (scriptLanguage != "javascript" && !scriptLanguage.isNull()) {
QString errMessage = QString("Unsupported language: %1").arg(scriptLanguage);
Terminal::instance()->cerr(errMessage);
qWarning("%s", qPrintable(errMessage));
return QString();
}
return scriptBody;
} else {
return QString();
}
}
void Encoding::init(STATE) {
onig_init(); // in regexp.cpp too, but idempotent.
Class* enc = ontology::new_class_under(state, "EncodingClass", G(rubinius));
GO(encoding).set(ontology::new_class_under(state, "Encoding", enc));
G(encoding)->set_object_type(state, EncodingType);
enc->set_const(state, "EncodingMap", LookupTable::create(state));
enc->set_const(state, "EncodingList", Array::create(state, 3));
G(encoding)->set_ivar(state, state->symbol("@default_external"), G(undefined));
G(encoding)->set_ivar(state, state->symbol("@default_internal"), G(undefined));
Encoding* ascii = create_bootstrap(state, "US-ASCII", eAscii, ONIG_ENCODING_US_ASCII);
Encoding* binary = create_bootstrap(state, "ASCII-8BIT", eBinary, ONIG_ENCODING_ASCII);
Encoding* utf8 = create_bootstrap(state, "UTF-8", eUtf8, ONIG_ENCODING_UTF_8);
ascii->name(state, String::create(state, "US-ASCII"));
binary->name(state, String::create(state, "ASCII-8BIT"));
utf8->name(state, String::create(state, "UTF-8"));
#include "vm/gen/encoding_database.cpp"
int index = -1;
char* locale_charmap;
#ifdef HAVE_NL_LANGINFO
setlocale(LC_CTYPE, "");
locale_charmap = nl_langinfo(CODESET);
#else
locale_charmap = "US-ASCII";
#endif
enc->set_const(state, "LocaleCharmap", String::create(state, locale_charmap));
index = find_index(state, locale_charmap);
if(index < 0) index = find_index(state, "US-ASCII");
create_internal(state, "locale", index);
create_internal(state, "external", index);
create_internal(state, "filesystem", index);
create_internal(state, "internal", -1);
Transcoding::init(state);
Converter::init(state);
}
int main() {
{
MoveToFront<int> move;
SHOW(move.enter(4));
SHOW(move.enter(5));
SHOW(move.enter(6));
SHOW(move.enter(4));
SHOW(move.enter(4));
SHOW(move.enter(5));
SHOW(move.enter(4));
}
{
Encoding<int> enc;
enc.add(10, .5f);
enc.add(11, .125f);
enc.add(12, .125f);
enc.add(13, .125f);
enc.add(12, .125f);
enc.print();
SHOW(enc.huffman_cost());
SHOW(enc.entropy());
SHOW(enc.norm_entropy());
enc.print_top_entries("enc", 2, [](const int& i) { return sform("%d", i); });
}
{
DeltaEncoding de;
de.enter_sign(0);
de.enter_bits(3);
de.enter_sign(0);
de.enter_bits(4);
de.enter_sign(1);
de.enter_bits(5);
de.enter_sign(1);
de.enter_bits(4);
de.enter_sign(1);
de.enter_bits(3);
int total_bits = de.analyze("de");
SHOW(total_bits);
SHOW(DeltaEncoding::val_bits(13.f));
SHOW(DeltaEncoding::val_bits(3.15f));
SHOW(DeltaEncoding::val_bits(3.1f));
SHOW(DeltaEncoding::val_bits(3.f));
SHOW(DeltaEncoding::val_bits(2.5f));
SHOW(DeltaEncoding::val_bits(2.2f));
SHOW(DeltaEncoding::val_bits(2.0f));
SHOW(DeltaEncoding::val_bits(1.5f));
SHOW(DeltaEncoding::val_bits(1.0f));
SHOW(DeltaEncoding::val_sign(13.3f));
SHOW(DeltaEncoding::val_sign(-13.3f));
SHOW(de.total_entropy());
}
}
Encoding* Encoding::define(STATE, const char* name,
OnigEncodingType* enc, Object* dummy)
{
Encoding* e = create(state, enc, dummy);
e->name(state, String::create(state, name));
Array* list = encoding_list(state);
size_t index = list->size();
Tuple* ref = encoding_reference(state, index);
encoding_map(state)->store(state, encoding_symbol(state, name), ref);
list->set(state, index, e);
add_constant(state, name, e);
return e;
}
VALUE rb_external_str_new_with_enc(const char* string, long size, rb_encoding* encoding) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
String* str = String::create(env->state(), string, size);
str->taint(env->state());
Encoding* enc = Encoding::find(env->state(), encoding->name);
if(enc == Encoding::usascii_encoding(env->state())
&& !CBOOL(str->ascii_only_p(env->state()))) {
str->encoding(env->state(), Encoding::ascii8bit_encoding(env->state()));
} else {
str->encoding(env->state(), enc);
}
return rb_str_conv_enc(env->get_handle(str), enc->get_encoding(),
rb_default_internal_encoding());
}
void Genome::FillGenes(rapidxml::xml_document<>& doc, rapidxml::xml_node<>* chromosomeNode, Encoding& encoding){
for (rapidxml::xml_node<>* geneNode = chromosomeNode->first_node("Gene"); geneNode; geneNode = geneNode->next_sibling("Gene"))
{
char* pchRandomData = doc.allocate_string(encoding.RandomData(chromosomeNode).c_str());
geneNode->value(pchRandomData);
}
}
int rb_enc_get_index(VALUE obj) {
NativeMethodEnvironment* env = NativeMethodEnvironment::get();
Object* val = env->get_object(obj);
Encoding* enc;
if(String* str = try_as<String>(val)) {
enc = str->encoding(env->state());
} else if(Regexp* reg = try_as<Regexp>(val)) {
enc = reg->encoding(env->state());
} else if(Symbol* sym = try_as<Symbol>(val)) {
enc = sym->encoding(env->state());
} else {
rb_raise(rb_eArgError, "object does not have an associated Encoding");
}
if(enc->nil_p()) return -1;
return Encoding::find_index(env->state(), enc->get_encoding()->name);
}
