Exemple #1
0
PyMODINIT_FUNC
initCfilters(void)
{
  SC_OFF_LEN = strlen(SC_OFF);
  SC_OFF_U = to_unicode(SC_OFF, SC_OFF_LEN);
  SC_ON_LEN = strlen(SC_ON);
  SC_ON_U = to_unicode(SC_ON, SC_ON_LEN);

  (void) Py_InitModule("Cfilters", FilterMethods);
}
Exemple #2
0
PyObject *
DiffStats_format(DiffStats *self, PyObject *args, PyObject *kwds)
{
    int err, format;
    git_buf buf = { 0 };
    Py_ssize_t width;
    PyObject *str;
    char *keywords[] = {"format", "width", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "in", keywords, &format, &width))
        return NULL;

    if (width <= 0) {
        PyErr_SetString(PyExc_ValueError, "width must be positive");
        return NULL;
    }

    err = git_diff_stats_to_buf(&buf, self->stats, format, width);
    if (err < 0)
        return Error_set(err);

    str = to_unicode(buf.ptr, NULL, NULL);
    git_buf_free(&buf);

    return str;
}
Exemple #3
0
PyObject *
Refspec_rtransform(Refspec *self, PyObject *py_str)
{
    char *str, *trans;
    int err, len, alen;
    PyObject *py_trans;

    str = py_str_to_c_str(py_str, NULL);
    alen = len = strlen(str);

    do {
        alen *= alen;
        trans = malloc(alen);
        if (!trans) {
            free(str);
            return PyErr_NoMemory();
        }

        err = git_refspec_rtransform(trans, alen, self->refspec, str);
    } while(err == GIT_EBUFS);
    free(str);

    if (err < 0) {
        free(trans);
        Error_set(err);
        return NULL;
    }

    py_trans = to_unicode(trans, NULL, NULL);

    free(trans);

    return py_trans;
}
Exemple #4
0
PyObject *
Branch_upstream_name__get__(Branch *self)
{
    int err;
    const char *branch_name;
    char *c_name = NULL;
    PyObject *py_name;

    CHECK_REFERENCE(self);

    branch_name = git_reference_name(self->reference);
    /* Get the length of the upstream name */
    err = git_branch_upstream_name(NULL, 0, self->repo->repo, branch_name);
    if (err < GIT_OK)
        return Error_set(err);

    /* Get the actual upstream name */
    c_name = calloc(err, sizeof(char));
    if (c_name == NULL)
        return PyErr_NoMemory();

    err = git_branch_upstream_name(c_name,
                                   err * sizeof(char),
                                   self->repo->repo,
                                   branch_name);
    if (err < GIT_OK) {
        free(c_name);
        return Error_set(err);
    }

    py_name = to_unicode(c_name, NULL, NULL);
    free(c_name);

    return py_name;
}
Exemple #5
0
PyObject *
Diff_patch__get__(Diff *self)
{
    git_patch* patch;
    git_buf buf = {NULL};
    int err = GIT_ERROR;
    size_t i, len, num;
    PyObject *py_patch = NULL;

    num = git_diff_num_deltas(self->list);
    if (num == 0)
        Py_RETURN_NONE;

    for (i = 0, len = 1; i < num ; ++i) {
        err = git_patch_from_diff(&patch, self->list, i);
        if (err < 0)
            goto cleanup;

        /* This appends to the current buf, so we can simply keep passing it */
        err = git_patch_to_buf(&buf, patch);
        if (err < 0)
            goto cleanup;

        git_patch_free(patch);
    }

    py_patch = to_unicode(buf.ptr, NULL, NULL);
    git_buf_free(&buf);

cleanup:
    git_buf_free(&buf);
    return (err < 0) ? Error_set(err) : py_patch;
}
Exemple #6
0
static int foreach_path_cb(git_submodule *submodule, const char *name, void *payload)
{
    PyObject *list = (PyObject *)payload;
    PyObject *path = to_unicode(git_submodule_path(submodule), NULL, NULL);

    return PyList_Append(list, path);
}
Exemple #7
0
/* Reads file from MS-Word 97 and above file. Takes in account strange*
 * situation that unicode and non-unicode 256-byte blocks could be    *
 * intermixed in word file                                            *
 *                                                                    *
 * Parameters:                                                        *
 *                                                                    *
 * f - file to read                                                   *
 * offset - position of the character inside file (to determine       * 
 * possible  block boundaries                                         *
 **********************************************************************/ 
int get_word8_char(FILE *f,long *offset,long fileend) {
	int count,i,u;
	char c;
	if ((i=(*offset)%256) ==0) {
		count=catdoc_read(read_buf,1,256,f);
		memset(read_buf+count,0,256-count);
		buf_is_unicode=0;
		if (*offset+(long)count>fileend) {
			count=fileend-*offset;
		}	
		while (i<count) {
			c=read_buf[i++];
			if ((c==0x20|| c==0x0D||ispunct(c))&&i<count&&read_buf[i]==0) {
				buf_is_unicode=1;
				break;
			}
			i++;
		}   
		i=0;
	}    
	if (buf_is_unicode) {
		u=read_buf[i] | read_buf[i+1]<<8;
		(*offset)+=2;
	} else {
		u=to_unicode(source_charset,read_buf[i]);
		(*offset)++;
	}
	return u;
}  
Exemple #8
0
/* Reads file from MS-Word 97 and above file. Takes in account strange*
 * situation that unicode and non-unicode 256-byte blocks could be    *
 * intermixed in word file                                            *
 *                                                                    *
 * Parameters:                                                        *
 *                                                                    *
 * f - file to read                                                   *
 * offset - position of the character inside file (to determine       * 
 * possible  block boundaries                                         *
 **********************************************************************/ 
int get_word8_char(FILE *f,long *offset,long fileend, struct ole_params_t *ole_params,
                   unsigned char read_buf[256], int *buf_is_unicode, struct io_funcs_t *io_funcs) {
	int count,i,u;
	char c;

    
	if ((i=(*offset)%256) ==0) {
		count=io_funcs->catdoc_read(read_buf,1,256,f, ole_params);
		memset(read_buf+count,0,256-count);
		*buf_is_unicode=0;
		if (*offset+(long)count>fileend) {
			count=fileend-*offset;
		}	
		while (i<count) {
			c=read_buf[i++];
			if ((c==0x20|| c==0x0D||ispunct(c))&&i<count&&read_buf[i]==0) {
				*buf_is_unicode=1;
				break;
			}
			i++;
		}   
		i=0;
	}    
	if (*buf_is_unicode) {
		u=read_buf[i] | read_buf[i+1]<<8;
		(*offset)+=2;
	} else {
		u=to_unicode(source_charset,read_buf[i]);
		(*offset)++;
	}
	return u;
}  
Exemple #9
0
PyObject *
Commit_message__get__(Commit *commit)
{
    const char *message, *encoding;

    message = git_commit_message(commit->commit);
    encoding = git_commit_message_encoding(commit->commit);
    return to_unicode(message, encoding, "strict");
}
Exemple #10
0
char Square::ToPlain(const string_t & str)
{
    if (str.empty())
        return ToPlain(Blank);
    char ch = ToPlain(to_unicode(str).at(0));
    if (ch == 0)
        return ToPlain(Blank);
    return ch;
}
Exemple #11
0
PyObject *
Tag_name__get__(Tag *self)
{
    const char *name;
    name = git_tag_name(self->tag);
    if (!name)
        Py_RETURN_NONE;
    return to_unicode(name, "utf-8", "strict");
}
Exemple #12
0
PyObject *
Tag_message__get__(Tag *self)
{
    const char *message;
    message = git_tag_message(self->tag);
    if (!message)
        Py_RETURN_NONE;
    return to_unicode(message, "utf-8", "strict");
}
Exemple #13
0
void mg_fopen(const char *path, const char *mode, struct file *filep) {
#ifdef _WIN32
    wchar_t wbuf[PATH_MAX], wmode[20];
    to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
    MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, ARRAY_SIZE(wmode));
    filep->fp = _wfopen(wbuf, wmode);
#else
    filep->fp = fopen(path, mode);
#endif
}
Exemple #14
0
PyObject *
Remote_push_url__get__(Remote *self)
{
	const char *url;

    url = git_remote_pushurl(self->remote);
    if (!url)
        Py_RETURN_NONE;

    return to_unicode(url, NULL, NULL);
}
Exemple #15
0
PyObject* Branch_branch_name__get__(Branch *self)
{
    int err;
    const char *c_name;

    CHECK_REFERENCE(self);

    err = git_branch_name(&c_name, self->reference);
    if (err == GIT_OK)
        return to_unicode(c_name, NULL, NULL);
    else
        return Error_set(err);
}
Exemple #16
0
int
Config_get_multivar_fn_wrapper(const git_config_entry *value, void *data)
{
    PyObject *item = NULL;

    if (!(item = to_unicode(value->value, NULL, NULL)))
        return -2;

    PyList_Append((PyObject *)data, item);

    Py_CLEAR(item);

    return 0;
}
Exemple #17
0
PyObject *
get_pylist_from_git_strarray(git_strarray *strarray)
{
    int index;
    PyObject *new_list;

    new_list = PyList_New(strarray->count);
    if (new_list == NULL)
        return NULL;

    for (index = 0; index < strarray->count; index++)
        PyList_SET_ITEM(new_list, index,
                        to_unicode(strarray->strings[index], NULL, NULL));

    return new_list;
}
Exemple #18
0
static PyObject *
get_search_path(long level)
{
    git_buf buf = {NULL};
    PyObject *py_path;
    int err;

    err = git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, level, &buf);
    if (err < 0)
        return Error_set(err);

    py_path = to_unicode(buf.ptr, NULL, NULL);
    git_buf_free(&buf);

    if (!py_path)
        return NULL;

    return py_path;
}
Exemple #19
0
bool Square::IsValidString(const string_t & str)
{
    if (str == Black)
        return true;

#if PUZ_UNICODE
    std::wstring::const_iterator begin = str.begin();
    std::wstring::const_iterator end   = str.end();
#else
    std::wstring unicode = to_unicode(str);
    std::wstring::const_iterator begin = unicode.begin();
    std::wstring::const_iterator end   = unicode.end();
#endif // PUZ_UNICODE

    std::wstring::const_iterator it;
    for (it = begin; it != end; ++it)
        if (! IsValidChar(*it))
            return false;
    return true;
}
Exemple #20
0
PyObject *
Branch_remote_name__get__(Branch *self)
{
    int err;
    git_buf name = {NULL};
    const char *branch_name;
    PyObject *py_name;

    CHECK_REFERENCE(self);

    branch_name = git_reference_name(self->reference);
    err = git_branch_remote_name(&name, self->repo->repo, branch_name);
    if (err < GIT_OK)
        return Error_set(err);

    py_name = to_unicode(name.ptr, NULL, NULL);
    git_buf_free(&name);

    return py_name;
}
Exemple #21
0
		static lstring from_utf8(const char *text, size_t size) {
			namespace lb = boost::locale::boundary;
			std::string::const_iterator begin(text);
			std::string::const_iterator end(text + size);

			lb::ssegment_index wmap(lb::character, begin, end, __fuzzy_locale);
			wmap.rule(lb::character_any);

			lstring ret;

			for (auto it = wmap.begin(), e = wmap.end(); it != e; ++it) {
				std::string str = it->str();
				const char *ptr = str.c_str();
				auto code = __fuzzy_utf8_converter->to_unicode(ptr, ptr + str.size());

				letter<unsigned int> l(code);
				ret.append(&l, 1);
			}

			return ret;
		}
Exemple #22
0
PyObject *
Diff_patch__get__(Diff *self)
{
    const git_diff_delta* delta;
    git_diff_patch* patch;
    char **strings = NULL;
    char *buffer = NULL;
    int err = GIT_ERROR;
    size_t i, len, num;
    PyObject *py_patch = NULL;

    num = git_diff_num_deltas(self->list);
    MALLOC(strings, num * sizeof(char*), cleanup);

    for (i = 0, len = 1; i < num ; ++i) {
        err = git_diff_get_patch(&patch, &delta, self->list, i);
        if (err < 0)
            goto cleanup;

        err = git_diff_patch_to_str(&(strings[i]), patch);
        if (err < 0)
            goto cleanup;

        len += strlen(strings[i]);
        git_diff_patch_free(patch);
    }

    CALLOC(buffer, (len + 1), sizeof(char), cleanup);
    for (i = 0; i < num; ++i) {
        strcat(buffer, strings[i]);
        free(strings[i]);
    }
    free(strings);

    py_patch = to_unicode(buffer, NULL, NULL);
    free(buffer);

cleanup:
    return (err < 0) ? Error_set(err) : py_patch;
}
Exemple #23
0
PyObject *
Config_get_multivar(Config *self, PyObject *args)
{
    int err;
    PyObject *list;
    const char *name = NULL;
    const char *regex = NULL;
    git_config_iterator *iter;
    git_config_entry *entry;

    if (!PyArg_ParseTuple(args, "s|s", &name, &regex))
        return NULL;

    list = PyList_New(0);
    err = git_config_multivar_iterator_new(&iter, self->config, name, regex);
    if (err < 0)
        return Error_set(err);

    while ((err = git_config_next(&entry, iter)) == 0) {
        PyObject *item;

        item = to_unicode(entry->value, NULL, NULL);
        if (item == NULL) {
            git_config_iterator_free(iter);
            return NULL;
        }

        PyList_Append(list, item);
        Py_CLEAR(item);
    }

    git_config_iterator_free(iter);
    if (err == GIT_ITEROVER)
        err = 0;

    if (err < 0)
        return Error_set(err);

    return list;
}
Exemple #24
0
PyObject *
Config_getitem(Config *self, PyObject *py_key)
{
    int64_t value_int;
    int err, value_bool;
    const char *value_str;
    char *key;
    PyObject* py_value;

    key = py_str_to_c_str(py_key, NULL);
    if (key == NULL)
        return NULL;

    err = git_config_get_string(&value_str, self->config, key);
    if (err < 0)
        goto cleanup;

    if (git_config_parse_int64(&value_int, value_str) == 0)
        py_value = PyLong_FromLongLong(value_int);
    else if(git_config_parse_bool(&value_bool, value_str) == 0)
        py_value = PyBool_FromLong(value_bool);
    else
        py_value = to_unicode(value_str, NULL, NULL);

cleanup:
    free(key);

    if (err < 0) {
        if (err == GIT_ENOTFOUND) {
            PyErr_SetObject(PyExc_KeyError, py_key);
            return NULL;
        }

        return Error_set(err);
    }

    return py_value;
}
Exemple #25
0
static void create_directory(const char *root, const char *dir) throw (CargoException) {
    const char *separator = dir;
    while (true) {
        /* find separator */
        bool found = false;
        while (separator) {
            separator++;
            if (*separator == 0) {
                break;
            }
            if (*separator == '/' || *separator == '\\') {
                found = true;
                break;
            }
        }
        if (!found) {
            break;
        }

        /* create directory */
        std::string new_dir(root);
        new_dir += "/";
        new_dir.append(dir, separator - dir);

#ifndef _WIN32
        struct stat st;
        if (stat(new_dir.c_str(), &st) == -1) {
            mkdir(new_dir.c_str(), 0700);
        }
#else
        modify_directory_separator(new_dir);
        wchar_t wdir[MaxPathLength];
        to_unicode(new_dir.c_str(), wdir, MaxPathLength);
        int rv = CreateDirectoryW(wdir, 0);
#endif
    }
}
Exemple #26
0
PyObject *
Signature_name__get__(Signature *self)
{
    return to_unicode(self->signature->name, self->encoding, "strict");
}
Exemple #27
0
PyObject *
Signature_email__get__(Signature *self)
{
    return to_unicode(self->signature->email, self->encoding, "strict");
}
Exemple #28
0
PyObject *
Remote_name__get__(Remote *self)
{
    return to_unicode(git_remote_name(self->remote), NULL, NULL);
}
Exemple #29
0
int copy_out (FILE *f,char *header, FILE *out, get_unicode_char_t get_unicode_char,
              struct ole_params_t *ole_params, struct io_funcs_t *io_funcs) {
	char *buf= NULL;
	int count,i;
	long offset;
    unsigned short int *buffer = NULL;
    unsigned char read_buf[256];
    int buf_is_unicode = 0;

	if (get_unicode_char == get_word8_char) {
		/* non-word file and -u specified. Trying to guess which kind of
		 * unicode is used
		 */
		if ((unsigned char)header[0]==0xFE && (unsigned char)header[1]==0xFF) {
			get_unicode_char = get_utf16msb;
			fputs(convert_char(header[2]<<8|header[3]),out); 
			fputs(convert_char(header[4]<<8|header[5]),out); 
			fputs(convert_char(header[6]<<8|header[7]),out); 
		} else if ((unsigned char)header[0]!=0xFF ||
				(unsigned char)header[1]!=0xFE) {
			int c,j,d;
			/* if it is not utf16, assume it is UTF8. We are told -u,
			 * aren't we */
			get_unicode_char = get_utf8;
			i=0;
			while (i<8) {
				c=(unsigned char)header[i++];		
				if (c >=0x80) {
					if ( c<0xE0) {
						c=(c & 0x1F);
						count =1;
					} else {
						c=(c & 0xF);
						count = 2;
					}
					for (j=0;j<count;j++) {
						if (i<7) {
							d=(unsigned char) header[i++];
						} else {
							d=fgetc(f);
						}
						c=c<<6 | (d & 0x3F);
					}
				}
				fputs (convert_char(c),out);
			}
		} else {
			get_unicode_char = get_utf16lsb;
			fputs(convert_char(header[3]<<8|header[2]),out); 
			fputs(convert_char(header[5]<<8|header[4]),out); 
			fputs(convert_char(header[7]<<8|header[6]),out); 
		}	    
		while (!io_funcs->catdoc_eof(f)) {
			i=get_unicode_char(f,&offset,0x7FFFFFFF, ole_params, read_buf, &buf_is_unicode, io_funcs); 
            if (i!=EOF) fputs(convert_char(i),out);
		}    
	} else {
		for (i=0;i<8;i++) {
			fputs(convert_char(to_unicode(source_charset,(unsigned char)header[i])),out);
		}			 
        buffer = (unsigned short int*) malloc(PARAGRAPH_BUFFER * sizeof(unsigned short int));
        if (!buffer) return -1;
        buf = (char*)buffer;
		/* Assuming 8-bit input text */
		while ((count = io_funcs->catdoc_read(buf,1,PARAGRAPH_BUFFER,f, ole_params))) {
			for (i=0;i<count;i++) {
				fputs(convert_char(to_unicode(source_charset,
								(unsigned char)buf[i])),out);
			}		       
		}
        free(buffer);
	}
    
    return 0;
} 
Exemple #30
0
PyObject *
Refspec_string__get__(Refspec *self)
{
    return to_unicode(git_refspec_string(self->refspec), NULL, NULL);
}