本文整理汇总了C++中CSTR2SYM函数的典型用法代码示例。如果您正苦于以下问题:C++ CSTR2SYM函数的具体用法?C++ CSTR2SYM怎么用?C++ CSTR2SYM使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了CSTR2SYM函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: rndr_tablecell
static void
rndr_tablecell(struct buf *ob, const struct buf *text, int align, void *opaque)
{
VALUE rb_align;
switch (align) {
case MKD_TABLE_ALIGN_L:
rb_align = CSTR2SYM("left");
break;
case MKD_TABLE_ALIGN_R:
rb_align = CSTR2SYM("right");
break;
case MKD_TABLE_ALIGN_CENTER:
rb_align = CSTR2SYM("center");
break;
default:
rb_align = Qnil;
break;
}
BLOCK_CALLBACK("table_cell", 2, buf2str(text), rb_align);
}
示例2: rb_git_conflict_add
/*
* call-seq:
* index.conflict_add(conflict) -> nil
*
* Add or update index entries that represent a conflict.
*
* +conflict+ has to be a hash containing +:ancestor+, +:ours+ and
* +:theirs+ key/value pairs. Any of those paris can be +nil+ (or left out)
* to indicate that the file was not present in the respective tree during
* the merge.
*/
static VALUE rb_git_conflict_add(VALUE self, VALUE rb_conflict)
{
VALUE rb_ancestor, rb_ours, rb_theirs;
git_index *index;
git_index_entry ancestor, ours, theirs;
int error;
Check_Type(rb_conflict, T_HASH);
rb_ancestor = rb_hash_aref(rb_conflict, CSTR2SYM("ancestor"));
rb_ours = rb_hash_aref(rb_conflict, CSTR2SYM("ours"));
rb_theirs = rb_hash_aref(rb_conflict, CSTR2SYM("theirs"));
if (!NIL_P(rb_ancestor))
rb_git_indexentry_toC(&ancestor, rb_ancestor);
if (!NIL_P(rb_ours))
rb_git_indexentry_toC(&ours, rb_ours);
if (!NIL_P(rb_theirs))
rb_git_indexentry_toC(&theirs, rb_theirs);
Data_Get_Struct(self, git_index, index);
error = git_index_conflict_add(index,
NIL_P(rb_ancestor) ? NULL : &ancestor,
NIL_P(rb_theirs) ? NULL : &ours,
NIL_P(rb_ours) ? NULL : &theirs);
rugged_exception_check(error);
return Qnil;
}
示例3: rugged_signature_new
VALUE rugged_signature_new(const git_signature *sig, const char *encoding_name)
{
VALUE rb_sig, rb_time;
rb_encoding *encoding = rb_utf8_encoding();
if (encoding_name != NULL)
encoding = rb_enc_find(encoding_name);
rb_sig = rb_hash_new();
/* Allocate the time with a the given timezone */
rb_time = rb_funcall(
rb_time_new(sig->when.time, 0),
rb_intern("getlocal"), 1,
INT2FIX(sig->when.offset * 60)
);
rb_hash_aset(rb_sig, CSTR2SYM("name"),
rb_enc_str_new(sig->name, strlen(sig->name), encoding));
rb_hash_aset(rb_sig, CSTR2SYM("email"),
rb_enc_str_new(sig->email, strlen(sig->email), encoding));
rb_hash_aset(rb_sig, CSTR2SYM("time"), rb_time);
return rb_sig;
}
示例4: rb_git_index_conflicts
/*
* call-seq:
* index.conflicts -> conflicts
*
* Return all conflicts in +index+.
*
* Each conflict is represented as a Hash with +:ancestor+, +:ours+ or
* +:theirs+ key-value pairs, each containing index entry data.
*
* If the value of the +:ancestor+, +:ours+ or +:theirs+ key is +nil+,
* that indicates that file in conflict did not exists in the respective tree.
*/
static VALUE rb_git_index_conflicts(VALUE self)
{
VALUE rb_conflicts = rb_ary_new();
git_index *index;
git_index_conflict_iterator *iter;
const git_index_entry *ancestor, *ours, *theirs;
int error;
Data_Get_Struct(self, git_index, index);
error = git_index_conflict_iterator_new(&iter, index);
rugged_exception_check(error);
while ((error = git_index_conflict_next(&ancestor, &ours, &theirs, iter)) == GIT_OK) {
VALUE rb_conflict = rb_hash_new();
rb_hash_aset(rb_conflict, CSTR2SYM("ancestor"), rb_git_indexentry_fromC(ancestor));
rb_hash_aset(rb_conflict, CSTR2SYM("ours"), rb_git_indexentry_fromC(ours));
rb_hash_aset(rb_conflict, CSTR2SYM("theirs"), rb_git_indexentry_fromC(theirs));
rb_ary_push(rb_conflicts, rb_conflict);
}
git_index_conflict_iterator_free(iter);
if (error != GIT_ITEROVER)
rugged_exception_check(error);
return rb_conflicts;
}
示例5: rb_git_rebase_next
/*
* call-seq:
* Rebase.next() -> operation or nil
*
* Perform the next step in the rebase. The returned operation is a
* Hash with its details or nil if there are no more operations to
* perform. The Hash contains some of the following entries:
*
* :type ::
* The type of operation being done. Can be one of +:pick+,
* +:reword+, +:edit+, +:squash+, +:fixup+ or +:exec+.
*
* :id ::
* The id of the commit being cherry-picked. Exists for all but
* +:exec+ operations.
*
* :exec ::
* If the operatin is +:exec+ this is what the user asked to be
* executed.
*/
static VALUE rb_git_rebase_next(VALUE self)
{
int error;
git_rebase *rebase;
git_rebase_operation *operation;
VALUE hash, val;
Data_Get_Struct(self, git_rebase, rebase);
error = git_rebase_next(&operation, rebase);
if (error == GIT_ITEROVER)
return Qnil;
rugged_exception_check(error);
/* Create the operation hash out of the relevant details */
hash = rb_hash_new();
val = rebase_operation_type(operation);
rb_hash_aset(hash, CSTR2SYM("type"), val);
if (operation->type != GIT_REBASE_OPERATION_EXEC) {
val = rugged_create_oid(&operation->id);
rb_hash_aset(hash, CSTR2SYM("id"), val);
}
if (operation->exec) {
val = rb_str_new_utf8(operation->exec);
rb_hash_aset(hash, CSTR2SYM("exec"), val);
}
return hash;
}
示例6: rb_git_delta_status_fromC
static VALUE rb_git_delta_status_fromC(git_delta_t status)
{
switch(status) {
case GIT_DELTA_UNMODIFIED:
return CSTR2SYM("unmodified");
case GIT_DELTA_ADDED:
return CSTR2SYM("added");
case GIT_DELTA_DELETED:
return CSTR2SYM("deleted");
case GIT_DELTA_MODIFIED:
return CSTR2SYM("modified");
case GIT_DELTA_RENAMED:
return CSTR2SYM("renamed");
case GIT_DELTA_COPIED:
return CSTR2SYM("copied");
case GIT_DELTA_IGNORED:
return CSTR2SYM("ignored");
case GIT_DELTA_UNTRACKED:
return CSTR2SYM("untracked");
case GIT_DELTA_TYPECHANGE:
return CSTR2SYM("typechange");
default:
return CSTR2SYM("unknown");
}
}
示例7: rb_redcarpet_htmltoc_init
static VALUE rb_redcarpet_htmltoc_init(int argc, VALUE *argv, VALUE self)
{
struct rb_redcarpet_rndr *rndr;
unsigned int render_flags = HTML_TOC;
VALUE hash, nesting_level = Qnil;
Data_Get_Struct(self, struct rb_redcarpet_rndr, rndr);
if (rb_scan_args(argc, argv, "01", &hash) == 1) {
Check_Type(hash, T_HASH);
/* escape_html */
if (rb_hash_aref(hash, CSTR2SYM("escape_html")) == Qtrue)
render_flags |= HTML_ESCAPE;
/* Nesting level */
nesting_level = rb_hash_aref(hash, CSTR2SYM("nesting_level"));
}
sdhtml_toc_renderer(&rndr->callbacks, (struct html_renderopt *)&rndr->options.html, render_flags);
rb_redcarpet__overload(self, rb_cRenderHTML_TOC);
if (!(NIL_P(nesting_level)))
rndr->options.html.toc_data.nesting_level = NUM2INT(nesting_level);
else
rndr->options.html.toc_data.nesting_level = 6;
return Qnil;
}
示例8: reflog_entry_new
static VALUE reflog_entry_new(const git_reflog_entry *entry)
{
VALUE rb_entry = rb_hash_new();
const char *message;
rb_hash_aset(rb_entry,
CSTR2SYM("id_old"),
rugged_create_oid(git_reflog_entry_id_old(entry))
);
rb_hash_aset(rb_entry,
CSTR2SYM("id_new"),
rugged_create_oid(git_reflog_entry_id_new(entry))
);
rb_hash_aset(rb_entry,
CSTR2SYM("committer"),
rugged_signature_new(git_reflog_entry_committer(entry), NULL)
);
if ((message = git_reflog_entry_message(entry)) != NULL) {
rb_hash_aset(rb_entry, CSTR2SYM("message"), rb_str_new_utf8(message));
}
return rb_entry;
}
示例9: rb_git_diff_patch_bytesize
/*
* call-seq:
* patch.bytesize(options = {}) -> int
*
* The following options can be passed in the +options+ Hash:
*
* :exclude_context ::
* Boolean value specifying that context lines should be excluded when
* counting the number of bytes in the patch.
*
* :exclude_hunk_headers ::
* Boolean value specifying that hunk headers should be excluded when
* counting the number of bytes in the patch.
*
* :exclude_file_headers ::
* Boolean value specifying that file headers should be excluded when
* counting the number of bytes in the patch.
*
* Returns the number of bytes in the patch, depending on which options are
* specified.
*/
static VALUE rb_git_diff_patch_bytesize(int argc, VALUE *argv, VALUE self)
{
git_patch *patch;
size_t bytesize;
VALUE rb_options;
int include_context, include_hunk_headers, include_file_headers;
Data_Get_Struct(self, git_patch, patch);
include_context = include_hunk_headers = include_file_headers = 1;
rb_scan_args(argc, argv, "0:", &rb_options);
if (!NIL_P(rb_options)) {
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_context")))) {
include_context = 0;
}
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_hunk_headers")))) {
include_hunk_headers = 0;
}
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_file_headers")))) {
include_file_headers = 0;
}
}
bytesize = git_patch_size(patch, include_context, include_hunk_headers, include_file_headers);
return INT2FIX(bytesize);
}
示例10: rb_git_commit_to_mbox
/*
* call-seq:
* commit.to_mbox(options = {}) -> str
*
* Returns +commit+'s contents formatted to resemble UNIX mailbox format.
*
* Does not (yet) support merge commits.
*
* The following options can be passed in the +options+ Hash:
*
* :patch_no ::
* Number for this patch in the series. Defaults to +1+.
*
* :total_patches ::
* Total number of patches in the series. Defaults to +1+.
*
* :exclude_subject_patch_marker ::
* If set to true, no "[PATCH]" marker will be
* added to the beginning of the subject line.
*
* Additionally, you can also pass the same options as for Rugged::Tree#diff.
*/
static VALUE rb_git_commit_to_mbox(int argc, VALUE *argv, VALUE self)
{
git_buf email_patch = { NULL };
git_repository *repo;
git_commit *commit;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
git_diff_format_email_flags_t flags = GIT_DIFF_FORMAT_EMAIL_NONE;
VALUE rb_repo = rugged_owner(self), rb_email_patch = Qnil, rb_val, rb_options;
int error;
size_t patch_no = 1, total_patches = 1;
rb_scan_args(argc, argv, ":", &rb_options);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Data_Get_Struct(self, git_commit, commit);
if (!NIL_P(rb_options)) {
Check_Type(rb_options, T_HASH);
rb_val = rb_hash_aref(rb_options, CSTR2SYM("patch_no"));
if (!NIL_P(rb_val))
patch_no = NUM2INT(rb_val);
rb_val = rb_hash_aref(rb_options, CSTR2SYM("total_patches"));
if (!NIL_P(rb_val))
total_patches = NUM2INT(rb_val);
if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_subject_patch_marker"))))
flags |= GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER;
rugged_parse_diff_options(&opts, rb_options);
}
error = git_diff_commit_as_email(
&email_patch,
repo,
commit,
patch_no,
total_patches,
flags,
&opts);
if (error) goto cleanup;
rb_email_patch = rb_enc_str_new(email_patch.ptr, email_patch.size, rb_utf8_encoding());
cleanup:
xfree(opts.pathspec.strings);
git_buf_free(&email_patch);
rugged_exception_check(error);
return rb_email_patch;
}
示例11: rb_git_tag_collection_create
/*
* call-seq:
* tags.create(name, target[, force = false][, annotation = nil]) -> oid
*
* Create a new tag with the specified +name+ on +target+ in +repo+.
*
* If +annotation+ is not +nil+, it will cause the creation of an annotated tag object.
* +annotation+ has to contain the following key value pairs:
*
* :tagger ::
* An optional Hash containing a git signature. Defaults to the signature
* from the configuration if only `:message` is given. Will cause the
* creation of an annotated tag object if present.
*
* :message ::
* An optional string containing the message for the new tag.
*
* Returns the OID of the newly created tag.
*/
static VALUE rb_git_tag_collection_create(int argc, VALUE *argv, VALUE self)
{
git_oid tag_oid;
git_repository *repo = NULL;
git_object *target = NULL;
int error, force = 0;
VALUE rb_repo = rugged_owner(self), rb_name, rb_target, rb_force, rb_annotation;
rb_scan_args(argc, argv, "21:", &rb_name, &rb_target, &rb_force, &rb_annotation);
rugged_check_repo(rb_repo);
Data_Get_Struct(rb_repo, git_repository, repo);
Check_Type(rb_name, T_STRING);
if (!NIL_P(rb_force))
force = rugged_parse_bool(rb_force);
target = rugged_object_get(repo, rb_target, GIT_OBJ_ANY);
if (NIL_P(rb_annotation)) {
error = git_tag_create_lightweight(
&tag_oid,
repo,
StringValueCStr(rb_name),
target,
force
);
} else {
git_signature *tagger = rugged_signature_get(
rb_hash_aref(rb_annotation, CSTR2SYM("tagger")), repo
);
VALUE rb_message = rb_hash_aref(rb_annotation, CSTR2SYM("message"));
Check_Type(rb_message, T_STRING);
error = git_tag_create(
&tag_oid,
repo,
StringValueCStr(rb_name),
target,
tagger,
StringValueCStr(rb_message),
force
);
git_signature_free(tagger);
}
git_object_free(target);
rugged_exception_check(error);
return rb_git_tag_collection_aref(self, rb_name);
}
示例12: rb_git_note_remove
/*
* call-seq:
* obj.remove_note(data = {}) -> boolean
*
* Removes a +note+ from +object+, with the given +data+
* arguments, passed as a +Hash+:
*
* - +:committer+ (optional): a hash with the signature for the committer,
* defaults to the signature from the configuration
* - +:author+ (optional): a hash with the signature for the author,
* defaults to the signature from the configuration
* - +:ref+: (optional): canonical name of the reference to use, defaults to "refs/notes/commits"
*
* When the note is successfully removed +true+ will be
* returned as a +Boolean+.
*
* author = {:email=>"[email protected]", :time=>Time.now, :name=>"Vicent Mart\303\255"}
*
* obj.remove_note(
* :author => author,
* :committer => author,
* :ref => 'refs/notes/builds'
* )
*/
static VALUE rb_git_note_remove(int argc, VALUE *argv, VALUE self)
{
int error = 0;
const char *notes_ref = NULL;
git_repository *repo = NULL;
git_signature *author, *committer;
git_object *target = NULL;
VALUE rb_data;
VALUE rb_ref = Qnil;
VALUE rb_author = Qnil;
VALUE rb_committer = Qnil;
VALUE owner;
Data_Get_Struct(self, git_object, target);
owner = rugged_owner(self);
Data_Get_Struct(owner, git_repository, repo);
rb_scan_args(argc, argv, "01", &rb_data);
if (!NIL_P(rb_data)) {
Check_Type(rb_data, T_HASH);
rb_ref = rb_hash_aref(rb_data, CSTR2SYM("ref"));
if (!NIL_P(rb_ref)) {
Check_Type(rb_ref, T_STRING);
notes_ref = StringValueCStr(rb_ref);
}
rb_committer = rb_hash_aref(rb_data, CSTR2SYM("committer"));
rb_author = rb_hash_aref(rb_data, CSTR2SYM("author"));
}
committer = rugged_signature_get(rb_committer, repo);
author = rugged_signature_get(rb_author, repo);
error = git_note_remove(
repo,
notes_ref,
author,
committer,
git_object_id(target));
git_signature_free(author);
git_signature_free(committer);
if (error == GIT_ENOTFOUND)
return Qfalse;
rugged_exception_check(error);
return Qtrue;
}
示例13: rugged_rhead_new
static VALUE rugged_rhead_new(const git_remote_head *head)
{
VALUE rb_head = rb_hash_new();
rb_hash_aset(rb_head, CSTR2SYM("local?"), head->local ? Qtrue : Qfalse);
rb_hash_aset(rb_head, CSTR2SYM("oid"), rugged_create_oid(&head->oid));
rb_hash_aset(rb_head, CSTR2SYM("loid"),
git_oid_iszero(&head->loid) ? Qnil : rugged_create_oid(&head->loid));
rb_hash_aset(rb_head, CSTR2SYM("name"), rb_str_new_utf8(head->name));
return rb_head;
}
示例14: rugged_exception_check
git_signature *rugged_signature_get(VALUE rb_sig, git_repository *repo)
{
int error;
VALUE rb_time, rb_unix_t, rb_offset, rb_name, rb_email, rb_time_offset;
git_signature *sig;
if (NIL_P(rb_sig)) {
rugged_exception_check(
git_signature_default(&sig, repo)
);
return sig;
}
Check_Type(rb_sig, T_HASH);
rb_name = rb_hash_aref(rb_sig, CSTR2SYM("name"));
rb_email = rb_hash_aref(rb_sig, CSTR2SYM("email"));
rb_time = rb_hash_aref(rb_sig, CSTR2SYM("time"));
rb_time_offset = rb_hash_aref(rb_sig, CSTR2SYM("time_offset"));
Check_Type(rb_name, T_STRING);
Check_Type(rb_email, T_STRING);
if (NIL_P(rb_time)) {
error = git_signature_now(&sig,
StringValueCStr(rb_name),
StringValueCStr(rb_email));
} else {
if (!rb_obj_is_kind_of(rb_time, rb_cTime))
rb_raise(rb_eTypeError, "expected Time object");
rb_unix_t = rb_funcall(rb_time, rb_intern("tv_sec"), 0);
if (NIL_P(rb_time_offset)) {
rb_offset = rb_funcall(rb_time, rb_intern("utc_offset"), 0);
} else {
Check_Type(rb_time_offset, T_FIXNUM);
rb_offset = rb_time_offset;
}
error = git_signature_new(&sig,
StringValueCStr(rb_name),
StringValueCStr(rb_email),
NUM2LONG(rb_unix_t),
FIX2INT(rb_offset) / 60);
}
rugged_exception_check(error);
return sig;
}
示例15: rb_git_blob_diff
/*
* call-seq:
* blob.diff(other, options = {}) -> patch
*
* Directly generate a Rugged::Patch from the difference between +blob+ and +other+.
*
* +other+ can either be another Rugged::Blob instance, a string,
* or nil (treated as an empty blob).
*
* The following options can be passed in the +options+ Hash:
*
* :max_size ::
* An integer specifying the maximum byte size of a blob before a it will
* be treated as binary. The default value is 512MB.
*
* :context_lines ::
* The number of unchanged lines that define the boundary of a hunk (and
* to display before and after the actual changes). The default is 3.
*
* :interhunk_lines ::
* The maximum number of unchanged lines between hunk boundaries before the hunks
* will be merged into a one. The default is 0.
*
* :reverse ::
* If true, the sides of the diff will be reversed.
*
* :force_text ::
* If true, all files will be treated as text, disabling binary attributes & detection.
*
* :ignore_whitespace ::
* If true, all whitespace will be ignored.
*
* :ignore_whitespace_change ::
* If true, changes in amount of whitespace will be ignored.
*
* :ignore_whitespace_eol ::
* If true, whitespace at end of line will be ignored.
*
* :patience ::
* If true, the "patience diff" algorithm will be used (currently unimplemented).
*
* :skip_binary_check ::
* If true, diff deltas will be generated without spending time on binary
* detection. This is useful to improve performance in cases where the actual
* file content difference is not needed.
*
* :old_path ::
* An optional string to treat +blob+ as if it had this filename.
*
* :new_path ::
* An optional string to treat +other+ as if it had this filename.
*/
static VALUE rb_git_blob_diff(int argc, VALUE *argv, VALUE self)
{
git_blob *blob;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
git_diff_patch *patch;
const char *old_path = NULL, *new_path = NULL;
VALUE rb_other, rb_options;
int error;
rb_scan_args(argc, argv, "10:", &rb_other, &rb_options);
if (!NIL_P(rb_options)) {
VALUE rb_value;
rb_value = rb_hash_aref(rb_options, CSTR2SYM("old_path"));
if (!NIL_P(rb_value)) {
Check_Type(rb_value, T_STRING);
old_path = StringValueCStr(rb_value);
}
rb_value = rb_hash_aref(rb_options, CSTR2SYM("new_path"));
if (!NIL_P(rb_value)) {
Check_Type(rb_value, T_STRING);
new_path = StringValueCStr(rb_value);
}
rugged_parse_diff_options(&opts, rb_options);
}
Data_Get_Struct(self, git_blob, blob);
if (NIL_P(rb_other)) {
error = git_diff_patch_from_blobs(&patch, blob, old_path, NULL, new_path, &opts);
} else if (rb_obj_is_kind_of(rb_other, rb_cRuggedBlob)) {
git_blob *other_blob;
Data_Get_Struct(rb_other, git_blob, other_blob);
error = git_diff_patch_from_blobs(&patch, blob, old_path, other_blob, new_path, &opts);
} else if (TYPE(rb_other) == T_STRING) {
const char * buffer = StringValueCStr(rb_other);
error = git_diff_patch_from_blob_and_buffer(&patch, blob, old_path, buffer, RSTRING_LEN(rb_other), new_path, &opts);
} else {
rb_raise(rb_eTypeError, "wrong argument type %s (expected Rugged::Blob, String, or nil)",
rb_obj_classname(rb_other));
}
rugged_exception_check(error);
//.........这里部分代码省略.........