C++ save_string函数代码示例

void RelationData::save(QTextStream & st, bool ref, QString & warning) const
{
    if (ref)
        st << "relation_ref " << get_ident() << " // " << (name);
    else {
        nl_indent(st);
        st << "relation " << get_ident() << " " << stringify(type);

        if (name != default_name(type)) {
            st << " name ";
            save_string(name, st);
        }

        indent(+1);

        BasicData::save(st, warning);

        if (original_id != 0) {
            nl_indent(st);
            st << "oid " << original_id;
        }

        bool assoc = isa_association(type);

        nl_indent(st);
        indent(+1);
        st << "a ";
        save_role(a, assoc, st, warning);
        start->save(st, TRUE, warning);
        indent(-1);

        nl_indent(st);
        indent(+1);
        st << "b";

        if (!RelationData::uni_directional(type)) {
            st << " ";
            save_role(b, assoc, st, warning);
            end->save(st, TRUE, warning);
        }
        else {
            if (!b.multiplicity.isEmpty()) {
                st << " multiplicity ";
                save_string(b.multiplicity, st);
            }

            st << " parent ";
            end_removed_from->save(st, TRUE, warning);
        }

        indent(-1);

        if ((association.type != 0) || !association.explicit_type.isEmpty()) {
            nl_indent(st);
            association.save(st, warning, "association_type ", "association_explicit_type ");
        }

        indent(-1);
    }
}

void save_presets(int do_update)
{
    FILE *f=fopen("powder.def", "wb");
    unsigned char sig[4] = {0x50, 0x44, 0x65, 0x66};
    unsigned char tmp = sdl_scale;
    if(!f)
        return;
    fwrite(sig, 1, 4, f);
    save_string(f, svf_user);
    save_string(f, svf_pass);
    fwrite(&tmp, 1, 1, f);
    tmp = cmode;
    fwrite(&tmp, 1, 1, f);
    tmp = svf_admin;
    fwrite(&tmp, 1, 1, f);
    tmp = svf_mod;
    fwrite(&tmp, 1, 1, f);
    save_string(f, http_proxy_string);
    tmp = SAVE_VERSION;
    fwrite(&tmp, 1, 1, f);
    tmp = MINOR_VERSION;
    fwrite(&tmp, 1, 1, f);
    tmp = do_update;
    fwrite(&tmp, 1, 1, f);
    fclose(f);
}

void Tool::save() 
{
  QByteArray newdef;
  Q3TextStream st(newdef, QIODevice::WriteOnly);
	
  st.setEncoding(Q3TextStream::Latin1);

  st << "// 'tool' \"the executable\" \"displayed string\" {target}+";
  
  for (unsigned rank = 0; rank != ntools; rank += 1) {
    ATool & tool = tools[rank];
    
    st << "\ntool ";
    save_string(tools[rank].display, st);
    st << ' ';
    save_string(tools[rank].cmd, st);
    
    for (int index = 0; index != sizeof(ToolCase) / sizeof(*ToolCase); index += 1) {
      if (tool.applicable[ToolCase[index].kind]) {
	st << ' ' << ToolCase[index].key;
      }
    }
  }
  st << '\n';
  
  st << '\000';
  save_if_needed("tools", newdef);
}

char *
pcePPReference(PceObject ref)
{ if ( isInteger(ref) )
  { Any addr = longToPointer(valInt(ref));
    char *rval = pp(addr);

    if ( rval[0] != '@' )
    { char tmp[256];
      sprintf(tmp, "@" INTPTR_FORMAT, valInt(ref));
      return save_string(tmp);
    } else
      return rval;
  } else if ( isName(ref) )
  { Any addr;

    if ( !(addr = getObjectAssoc(ref)) )
    { char tmp[256];

      sprintf(tmp, "@%s", strName(ref));
      return save_string(tmp);
    } else
      return pp(addr);
  } else
    return save_string("invalid reference");
}

void CodDirsCanvas::save(QTextStream & st, bool ref, QString & warning) const
{
    if (ref)
        st << "dirscanvas_ref " << get_ident();
    else {
        nl_indent(st);
        st << "dirscanvas " << get_ident() << " z " << zValue() << " ";
        link->save(st, TRUE, warning);

        indent(+1);

        settings.save_msg(st);

        if (label != 0) {
            nl_indent(st);
            st << "forward_label ";
            save_string(label->get_name().toLatin1().constData(), st);
            save_xyz(st, label, " xyz");
        }

        if (backward_label != 0) {
            nl_indent(st);
            st << "backward_label ";
            save_string(backward_label->get_name().toLatin1().constData(), st);
            save_xyz(st, backward_label, " xyz");
        }

        indent(-1);
    }
}

void Tool::save()
{
    QSharedPointer<QByteArray> newdef(new QByteArray());
    QTextStream st(newdef.data(), QIODevice::WriteOnly);

    //st.setEncoding(QTextStream::Latin1);
    st.setCodec(QTextCodec::codecForName("latin1"));
    st << "// 'tool' \"the executable\" \"displayed string\" {target}+";

    for (unsigned rank = 0; rank != ntools; rank += 1) {
        ATool & tool = tools[rank];

        st << "\ntool ";
        save_string(tools[rank].display.toLatin1().constData(), st);
        st << " ";
        save_string(tools[rank].cmd.toLatin1().constData(), st);

        for (int index = 0; index != sizeof(ToolCase) / sizeof(*ToolCase); index += 1) {
            if (tool.applicable[ToolCase[index].kind]) {
                st << " " << ToolCase[index].key;
            }
        }
    }

    st << '\n';

    st << '\000';
    st.flush();
    save_if_needed("tools", newdef);
}

int main (void) {
	PageManager* pm = new_page_manager(".");
	printf("I Made my pm\n");
	printf("My index path is: %s\n", pm->index_path);
	RawPage* new_page = new_data_page(pm);
	printf("new page fd is %d at memory addr %p\n", new_page->fd, new_page->page);
	// Save some strings
	PageRef* str_1 = save_string(new_page, "Hello There");
	PageRef* str_2 = save_string(new_page, "I am a second string");
	printf("Before unload page\n");
	unload_page(new_page);
	printf("After unloda page\n");
	// load some strings
	load_string(pm, str_1);
	load_string(pm, str_2);

	//make our tree page
	RawPage* t_page = new_tree_page(pm);
	TreeNode* test_node = malloc(sizeof(TreeNode));
	memset(test_node, 0, sizeof(TreeNode));
	test_node->size = 0;
	test_node->order = 2;
	test_node->num_leaves = 0;
	test_node->parent.page_type = 0xDE110;
	test_node->parent.page_num = 31337;
	test_node->parent.node_offset = 31337;
	PageRef* node1 = save_node(t_page, test_node);
	unload_page(t_page);
	load_node(pm, node1);

}

static int
cvtchar(register const char *sp)
/* convert a character to a terminfo push */
{
    unsigned char c = 0;
    int len;

    switch (*sp) {
    case '\\':
	switch (*++sp) {
	case '\'':
	case '$':
	case '\\':
	case '%':
	    c = *sp;
	    len = 2;
	    break;
	case '\0':
	    c = '\\';
	    len = 1;
	    break;
	case '0':
	case '1':
	case '2':
	case '3':
	    len = 1;
	    while (isdigit(UChar(*sp))) {
		c = 8 * c + (*sp++ - '0');
		len++;
	    }
	    break;
	default:
	    c = *sp;
	    len = 2;
	    break;
	}
	break;
    case '^':
	c = (*++sp & 0x1f);
	len = 2;
	break;
    default:
	c = *sp;
	len = 1;
    }
    if (isgraph(c) && c != ',' && c != '\'' && c != '\\' && c != ':') {
	dp = save_string(dp, "%\'");
	dp = save_char(dp, c);
	dp = save_char(dp, '\'');
    } else {
	dp = save_string(dp, "%{");
	if (c > 99)
	    dp = save_char(dp, c / 100 + '0');
	if (c > 9)
	    dp = save_char(dp, ((int) (c / 10)) % 10 + '0');
	dp = save_char(dp, c % 10 + '0');
	dp = save_char(dp, '}');
    }
    return len;
}

def_t *
emit_structure (const char *name, int su, struct_def_t *defs, type_t *type,
				void *data, storage_class_t storage)
{
	int         i, j;
	int         saw_null = 0;
	int         saw_func = 0;
	symbol_t   *struct_sym;
	symbol_t   *field_sym;
	def_t      *struct_def;
	def_t       field_def;

	name = save_string (name);
	if (!type)
		type = make_structure (0, su, defs, 0)->type;
	if (!is_struct (type) || (su == 's' && type->meta != ty_struct)
		|| (su == 'u' && type->meta != ty_union))
		internal_error (0, "structure %s type mismatch", name);
	for (i = 0, field_sym = type->t.symtab->symbols; field_sym;
		 i++, field_sym = field_sym->next) {
		if (!defs[i].name)
			internal_error (0, "structure %s unexpected end of defs", name);
		if (field_sym->type != defs[i].type)
			internal_error (0, "structure %s.%s field type mismatch", name,
							defs[i].name);
		if ((!defs[i].emit && saw_func) || (defs[i].emit && saw_null))
			internal_error (0, "structure %s mixed emit/copy", name);
		if (!defs[i].emit)
			saw_null = 1;
		if (defs[i].emit)
			saw_func = 1;
	}
	if (defs[i].name)
		internal_error (0, "structure %s too many defs", name);
	if (storage != sc_global && storage != sc_static)
		internal_error (0, "structure %s must be global or static", name);

	struct_sym = make_symbol (name, type, pr.far_data, storage);

	struct_def = struct_sym->s.def;
	if (struct_def->initialized)
		internal_error (0, "structure %s already initialized", name);
	struct_def->initialized = struct_def->constant = 1;
	struct_def->nosave = 1;

	for (i = 0, field_sym = type->t.symtab->symbols; field_sym;
		 i++, field_sym = field_sym->next) {
		field_def.type = field_sym->type;
		field_def.name = save_string (va ("%s.%s", name, field_sym->name));
		field_def.space = struct_def->space;
		field_def.offset = struct_def->offset + field_sym->s.offset;
		if (!defs[i].emit) {
			//FIXME relocs? arrays? structs?
			pr_type_t  *val = (pr_type_t *) data;
			memcpy (D_POINTER (void, &field_def), val,
					type_size (field_def.type) * sizeof (pr_type_t));
			data = &val[type_size (field_def.type)];
		} else {
			if (is_array (field_def.type)) {

int  C_THISCLASS::save_config(unsigned char *data)
{
	int pos=0;
  data[pos++]=1;
  save_string(data,pos,effect_exp[0]);
  save_string(data,pos,effect_exp[1]);
  save_string(data,pos,effect_exp[2]);
	PUT_INT(blend); pos+=4;
	PUT_INT(subpixel); pos+=4;
	return pos;
}

void ParamData::save(QTextStream & st, QString & warning) const
{
    nl_indent(st);
    st << "  param " << stringify(dir) << " name ";
    save_string(name, st);
    type.save(st, warning, " type ", " explicit_type ");

    if (!default_value.isEmpty()) {
        nl_indent(st);
        st << "    defaultvalue ";
        save_string(default_value, st);
    }
}

void HaveKeyValueData::save(Q3TextStream & st) const {
  if (nkeyvalues) {
    nl_indent(st);
    st << "ncouples " << nkeyvalues;
    
    for (unsigned i = 0; i != nkeyvalues; i += 1) {
      nl_indent(st);
      st << "key ";
      save_string(keyvalues[i].get_key(), st);
      st << " value ";
      save_string(keyvalues[i].get_value(), st);
    }
  }
}

void BasicData::save(Q3TextStream & st, QString &) const {
  if (! stereotype.isEmpty()) {
    nl_indent(st);
    st << "stereotype ";
    save_string(stereotype, st);
  }
}

bool
try_pk (string family, int size, int dpi, int dsize,
	tex_font_metric& tfm, font_glyphs& pk)
{
  // cout << "Try pk " << family << size << " at " << dpi << " dpi\n";
#ifdef USE_FREETYPE
  // Substitute by True Type font ?
  int tt_size= size<333? size: (size+50)/100;
  int tt_dpi = size<333? dpi : (size * dpi) / (100 * tt_size);
  string tt_name= tt_find_name (family, tt_size);
  if (tt_name != "") {
    if (font_glyphs::instances -> contains (tt_name))
      pk= font_glyphs (tt_name);
    else pk= tt_font_glyphs (tt_name, tt_size, tt_dpi);
    return true;
  }
#endif // USE_FREETYPE

  // Open regular pk font
  string name_pk= family * as_string (size) * "." * as_string (dpi) * "pk";
  if (font_glyphs::instances -> contains (name_pk)) {
    pk = font_glyphs (name_pk);
    return true;
  }
  if (dsize == 0) {
    int old_size= size;
    size= tfm->size;
    dpi = mag (dpi, old_size, size);
  }
  string size_name (dsize==0? string (""): as_string (size));
  string name (family * size_name * "." * as_string (dpi) * "pk");
  if (DEBUG_STD) debug_fonts << "Open pk " << name << "\n";
  url u= resolve_tex (name);
  if (is_none (u)) {
    if (exists (url ("$TEXMACS_HOME_PATH/fonts/error", name))) {
      if (DEBUG_STD)
        debug_fonts << "Error during " << name << " loading\n";
      return false;
    }
    if (get_setting ("MAKEPK") != "false") {
      system_wait ("Generating font file", name);
      make_tex_pk (family * size_name, dpi, as_int (get_setting ("DPI")));
      system_wait ("");
      u= resolve_tex (name);
      if (is_none (u)) {
	reset_pk_path ();
	u= resolve_tex (name);
      }
    }
    if (is_none (u)) {
      save_string (url ("$TEXMACS_HOME_PATH/fonts/error", name), "");
      if (DEBUG_STD)
        debug_fonts << "Error during " << name << " loading\n";
      return false;
    }
  }
  pk = font_glyphs (tm_new<pk_font_glyphs_rep> (name_pk,
					    tm_new<pk_loader> (u, tfm, dpi)));
  return true;
}

void filestorage::save_string(t_filestore file_type,
							  const std::string &filename,
							  const std::string &data,
							  bool overwrite) {

	if (filename == "") {
		throw std::invalid_argument("Fail to open file for write: empty filename");
	}

	fs::path file_with_path;
	try {

		file_with_path = prepare_path_for_write(file_type, filename, overwrite);
		fs::ofstream file(file_with_path, std::ios::out | std::ios::binary);

		if (file.is_open()) {
			file << data;
		} else {
			throw std::invalid_argument("Fail to open file for write: " + filename);
		}
		file.close();
		_dbg2("Successfully saved string to:" << file_with_path.native());

	} catch(overwrite_error &err) {
		std::cout << err.what() << std::endl;
		if(text_ui::ask_user_forpermission("overwrite file?")){
			save_string(file_type, filename, data, true);
		} else {
			_dbg2("Fail to save string");
		}
	}
}