mirrors/mc
1
0
Fork 0
mirror of https://github.com/MidnightCommander/mc synced 2024-12-22 12:32:40 +03:00
Code Issues Packages Projects Releases Wiki Activity

Completely removed MHL stuff

Browse Source 
Changed all source files relative to remove MHL

Some string-related functions moved into src/util.c

This stable fix.
This commit is contained in:
Slava Zanko 2009-02-06 14:01:28 +02:00
parent 3b8f37b99e
commit e54f318cef
61 changed files with 74 additions and 788 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
edit/choosesyntax.c
View File

@ -18,9 +18,6 @@
#include <config.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "edit.h"
#include "../src/global.h"
#include "../src/wtools.h"

3
edit/edit.c
View File

@ -32,9 +32,6 @@
#include <sys/stat.h>
#include <stdlib.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "edit.h"

13
edit/editcmd.c
View File

@ -38,9 +38,6 @@
#include <sys/stat.h>
#include <stdlib.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "../src/history.h"
@ -277,10 +274,10 @@ edit_save_file (WEdit *edit, const char *filename)
const char *slashpos;
slashpos = strrchr (filename, PATH_SEP);
if (slashpos) {
savedir = mhl_str_dup (filename);
savedir = g_strdup (filename);
savedir[slashpos - filename + 1] = '\0';
} else
savedir = mhl_str_dup (".");
savedir = g_strdup (".");
saveprefix = concat_dir_and_file (savedir, "cooledit");
g_free (savedir);
fd = mc_mkstemps (&savename, saveprefix, NULL);
@ -1850,9 +1847,9 @@ edit_replace_cmd (WEdit *edit, int again)
goto cleanup;
}
g_free (saved1), saved1 = mhl_str_dup (input1);
g_free (saved2), saved2 = mhl_str_dup (input2);
g_free (saved3), saved3 = mhl_str_dup (input3);
g_free (saved1), saved1 = g_strdup (input1);
g_free (saved2), saved2 = g_strdup (input2);
g_free (saved3), saved3 = g_strdup (input3);
}
{

3
edit/editlock.c
View File

@ -36,9 +36,6 @@
#include <sys/stat.h>
#include <stdlib.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "edit.h"

3
edit/editwidget.c
View File

@ -35,9 +35,6 @@
#include <sys/stat.h>
#include <stdlib.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "edit.h"

59
edit/syntax.c
View File

@ -32,9 +32,6 @@
#include <sys/stat.h>
#include <stdlib.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "edit.h"
@ -471,7 +468,7 @@ static struct syntax_rule edit_get_rule (WEdit * edit, long byte_index)
break;
}
s = edit->syntax_marker->next;
MHL_PTR_FREE (edit->syntax_marker);
MC_PTR_FREE (edit->syntax_marker);
edit->syntax_marker = s;
}
}
@ -666,8 +663,8 @@ static FILE *open_include_file (const char *filename)
{
FILE *f;
MHL_PTR_FREE (error_file_name);
error_file_name = mhl_str_dup (filename);
MC_PTR_FREE (error_file_name);
error_file_name = g_strdup (filename);
if (*filename == PATH_SEP)
return fopen (filename, "r");
@ -725,8 +722,8 @@ edit_read_syntax_rules (WEdit *edit, FILE *f, char **args, int args_size)
f = g;
g = 0;
line = save_line + 1;
MHL_PTR_FREE (error_file_name);
MHL_PTR_FREE (l);
MC_PTR_FREE (error_file_name);
MC_PTR_FREE (l);
if (!read_one_line (&l, f))
break;
} else {
@ -745,7 +742,7 @@ edit_read_syntax_rules (WEdit *edit, FILE *f, char **args, int args_size)
g = f;
f = open_include_file (args[1]);
if (!f) {
MHL_PTR_FREE (error_file_name);
MC_PTR_FREE (error_file_name);
result = line;
break;
}
@ -922,10 +919,10 @@ edit_read_syntax_rules (WEdit *edit, FILE *f, char **args, int args_size)
break_a;
}
free_args (args);
MHL_PTR_FREE (l);
MC_PTR_FREE (l);
}
free_args (args);
MHL_PTR_FREE (l);
MC_PTR_FREE (l);
/* Terminate context array. */
if (num_contexts > 0) {
@ -934,7 +931,7 @@ edit_read_syntax_rules (WEdit *edit, FILE *f, char **args, int args_size)
}
if (!edit->rules[0])
MHL_PTR_FREE (edit->rules);
MC_PTR_FREE (edit->rules);
if (result)
return result;
@ -976,34 +973,34 @@ void edit_free_syntax_rules (WEdit * edit)
return;
edit_get_rule (edit, -1);
MHL_PTR_FREE (edit->syntax_type);
MC_PTR_FREE (edit->syntax_type);
edit->syntax_type = 0;
for (i = 0; edit->rules[i]; i++) {
if (edit->rules[i]->keyword) {
for (j = 0; edit->rules[i]->keyword[j]; j++) {
MHL_PTR_FREE (edit->rules[i]->keyword[j]->keyword);
MHL_PTR_FREE (edit->rules[i]->keyword[j]->whole_word_chars_left);
MHL_PTR_FREE (edit->rules[i]->keyword[j]->whole_word_chars_right);
MHL_PTR_FREE (edit->rules[i]->keyword[j]);
MC_PTR_FREE (edit->rules[i]->keyword[j]->keyword);
MC_PTR_FREE (edit->rules[i]->keyword[j]->whole_word_chars_left);
MC_PTR_FREE (edit->rules[i]->keyword[j]->whole_word_chars_right);
MC_PTR_FREE (edit->rules[i]->keyword[j]);
}
}
MHL_PTR_FREE (edit->rules[i]->left);
MHL_PTR_FREE (edit->rules[i]->right);
MHL_PTR_FREE (edit->rules[i]->whole_word_chars_left);
MHL_PTR_FREE (edit->rules[i]->whole_word_chars_right);
MHL_PTR_FREE (edit->rules[i]->keyword);
MHL_PTR_FREE (edit->rules[i]->keyword_first_chars);
MHL_PTR_FREE (edit->rules[i]);
MC_PTR_FREE (edit->rules[i]->left);
MC_PTR_FREE (edit->rules[i]->right);
MC_PTR_FREE (edit->rules[i]->whole_word_chars_left);
MC_PTR_FREE (edit->rules[i]->whole_word_chars_right);
MC_PTR_FREE (edit->rules[i]->keyword);
MC_PTR_FREE (edit->rules[i]->keyword_first_chars);
MC_PTR_FREE (edit->rules[i]);
}
while (edit->syntax_marker) {
struct _syntax_marker *s = edit->syntax_marker->next;
MHL_PTR_FREE (edit->syntax_marker);
MC_PTR_FREE (edit->syntax_marker);
edit->syntax_marker = s;
}
MHL_PTR_FREE (edit->rules);
MC_PTR_FREE (edit->rules);
}
/* returns -1 on file error, line number on error in file syntax */
@ -1036,7 +1033,7 @@ edit_read_syntax_file (WEdit * edit, char ***pnames, const char *syntax_file,
args[0] = 0;
for (;;) {
line++;
MHL_PTR_FREE (l);
MC_PTR_FREE (l);
if (!read_one_line (&l, f))
break;
(void)get_args (l, args, 1023); /* Final NULL */
@ -1117,8 +1114,8 @@ edit_read_syntax_file (WEdit * edit, char ***pnames, const char *syntax_file,
else
result = line_error;
} else {
MHL_PTR_FREE (edit->syntax_type);
edit->syntax_type = mhl_str_dup (syntax_type);
MC_PTR_FREE (edit->syntax_type);
edit->syntax_type = g_strdup (syntax_type);
/* if there are no rules then turn off syntax highlighting for speed */
if (!g && !edit->rules[1])
if (!edit->rules[0]->keyword[1] && !edit->rules[0]->spelling) {
@ -1135,7 +1132,7 @@ edit_read_syntax_file (WEdit * edit, char ***pnames, const char *syntax_file,
}
}
}
MHL_PTR_FREE (l);
MC_PTR_FREE (l);
fclose (f);
return result;
}
@ -1200,7 +1197,7 @@ edit_load_syntax (WEdit *edit, char ***pnames, const char *type)
message (D_ERROR, _(" Load syntax file "),
_(" Error in file %s on line %d "),
error_file_name ? error_file_name : f, r);
MHL_PTR_FREE (error_file_name);
MC_PTR_FREE (error_file_name);
} else {
/* succeeded */
}

4
edit/usermap.c
View File

@ -30,10 +30,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <mhl/types.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "edit.h"

3
mhl/.gitignore vendored
View File

@ -1,3 +0,0 @@
.deps
Makefile
Makefile.in

103
mhl/README
View File

@ -1,103 +0,0 @@
Micro helper library.
--
This is a tiny library of helper functions/macros.
* MACRO-FUNC: macro w/ function syntax. (might become inline func)
* INLINE-FUNC: inline function (might become macro func)
* MACRO: strictly a macro (may never become a inline func)
--
mhl/memory.h: Memory management functions
* mhl_mem_alloc_u(sz) [MACRO-FUNC]
Allocate sz bytes on stack, unitialized
* mhl_mem_alloc_z(sz) [INLINE-FUNC]
Allocate sz bytes on stack, zero'ed
* g_free(ptr) [INLINE-FUNC]
Free chunk @ptr (MUST be allocated w/ mhl_mem_alloc_*()),
passing NULL is graciously allowed
* mhl_mem_realloc(ptr,newsize) -> returns newptr
Re-allocates a heap chunk, just like realloc()
* MHL_PTR_FREE(ptr) [MACRO-ONLY]
like g_free(), but with ptr as a variable that gets cleared
(use this as shortcut to "g_free(foo); foo = NULL")
mhl/string.h: String helpers
* mhl_str_dup(const char*s) -> char*
[MACRO-FUNC] Safe version of strdup(), when NULL passed, returns strdup("")
* mhl_str_ndup(const char* s) -> char*
[MACRO-FUNC] Safe version of strndup(), when NULL passed, returns strdup("")
* mhl_str_trim(char* s) -> char*
[INLINE-FUNC] Trims the string (removing leading and trailing whitespacs),
WITHIN the passed buffer, returning the string s itself.
When NULL passed returns NULL.
* mhl_str_toupper(char* s) -> char*
[INLINE-FUNC] Converts the string in passed buffer to uppercase, returns that
buffer. When NULL passed returns NULL.
* mhl_str_concat_1(const char* base, const char* one) -> char*
[INLINE-FUNC] Concatenates the string one onto the string base and returns the
result in a newly allocated buffer (free it w/ g_free()).
For NULL strings, "" is assumed.
* mhl_str_concat_2(const char* base,const char* one,const char* two) -> char*
mhl_str_concat_3(const char* base,const char* one,const char* two,const char* three) -> char*
mhl_str_concat_4(const char* base,const char* one,const char* two,const char* three,const char* four) -> char*
mhl_str_concat_5(const char* base,const char* one,const char* two,const char* three,const char* four,const char* five) -> char*
mhl_str_concat_6(const char* base,const char* one,const char* two,const char* three,const char* four,const char* five,const char* six) -> char*
mhl_str_concat_7(const char* base,const char* one,const char* two,const char* three,const char* four,const char* five,const char* six,const char* seven) -> char*
[INLINE-FUNC] Like str_concat_1() but adding more strings.
* mhl_str_reverse(char* str) -> char*
[INLINE-FUNC] Reverses the string in passed buffer and returns the buffer ptr itself.
If NULL is passed, returns NULL.
mhl/escape.h: Shell-style string escaping
* mhl_shell_escape_toesc(char c) -> bool
[MACRO-FUNC] returns true when given char has to be escaped
* mhl_shell_escape_nottoesc(char c) -> bool
[MACRO-FUNC] opposite of mhl_shell_escape_toesc()
* mhl_shell_escape_dup(const char* s) -> char*
[INLINE-FUNC] escapes an string and returns the result in a malloc()'ed chunk
Passing NULL returns an empty malloc()ed string.
* mhl_shell_unescape_buf(char* s) -> char*
[INLINE-FUNC] unescapes the string into given buffer (changes buffer!) and
returns ptr to the buffer itself. When NULL passed returns NULL.
mhl/env.h: Environment variable helpers
* mhl_getenv_dup(const char* n) -> char*
[MACRO-FUNC] like getenv() but returns an strdup()'ed copy. When NULL passed,
returns strdup("")

8
mhl/env.h
View File

@ -1,8 +0,0 @@
#ifndef MHL_ENV_H
#define MHL_ENV_H
#include <mhl/string.h>
#define mhl_getenv_dup(name) (mhl_str_dup(name ? getenv(name) : ""))
#endif

149
mhl/escape.h
View File

@ -1,149 +0,0 @@
#ifndef MHL_ESCAPE_H
#define MHL_ESCAPE_H
/* Micro helper library: shell escaping functions */
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#define mhl_shell_escape_toesc(x) \
(((x)==' ')||((x)=='!')||((x)=='#')||((x)=='$')||((x)=='%')|| \
((x)=='(')||((x)==')')||((x)=='\'')||((x)=='&')||((x)=='~')|| \
((x)=='{')||((x)=='}')||((x)=='[')||((x)==']')||((x)=='`')|| \
((x)=='?')||((x)=='|')||((x)=='<')||((x)=='>')||((x)==';')|| \
((x)=='*')||((x)=='\\')||((x)=='"'))
#define mhl_shell_escape_nottoesc(x) \
(((x)!=0) && (!mhl_shell_escape_toesc((x))))
/** To be compatible with the general posix command lines we have to escape
strings for the command line
/params const char * in
string for escaping
/returns
return escaped string (later need to free)
*/
static inline char* mhl_shell_escape_dup(const char* src)
{
if ((src==NULL)||(!(*src)))
return strdup("");
char* buffer = calloc(1, strlen(src)*2+2);
char* ptr = buffer;
/* look for the first char to escape */
while (1)
{
char c;
/* copy over all chars not to escape */
while ((c=(*src)) && mhl_shell_escape_nottoesc(c))
{
*ptr = c;
ptr++;
src++;
}
/* at this point we either have an \0 or an char to escape */
if (!c)
return buffer;
*ptr = '\\';
ptr++;
*ptr = c;
ptr++;
src++;
}
}
/** Unescape paths or other strings for e.g the internal cd
shell-unescape within a given buffer (writing to it!)
/params const char * src
string for unescaping
/returns
return unescaped string
*/
static inline char* mhl_shell_unescape_buf(char* text)
{
if (!text)
return NULL;
/* look for the first \ - that's quick skipover if there's nothing to escape */
char* readptr = text;
while ((*readptr) && ((*readptr)!='\\')) readptr++;
if (!(*readptr)) return text;
/* if we're here, we're standing on the first '\' */
char* writeptr = readptr;
char c;
while ((c = *readptr))
{
if (c=='\\')
{
readptr++;
switch ((c = *readptr))
{
case 'n': (*writeptr) = '\n'; writeptr++; break;
case 'r': (*writeptr) = '\r'; writeptr++; break;
case 't': (*writeptr) = '\t'; writeptr++; break;
case ' ':
case '\\':
case '#':
case '$':
case '%':
case '(':
case ')':
case '[':
case ']':
case '{':
case '}':
case '<':
case '>':
case '!':
case '*':
case '?':
case '~':
case '`':
case '"':
case ';':
case '\0': /* end of string! malformed escape string */
goto out;
default:
(*writeptr) = c; writeptr++; break;
}
}
else /* got a normal character */
{
(*writeptr) = *readptr;
writeptr++;
}
readptr++;
}
out:
*writeptr = 0;
return text;
}
/** Check if char in pointer contain escape'd chars
/params const char * in
string for checking
/returns
return TRUE if string contain escaped chars
otherwise return FALSE
*/
static inline bool
mhl_shell_is_char_escaped ( const char *in )
{
if (in == NULL || !*in || in[0] != '\\')
return false;
if (mhl_shell_escape_toesc(in[1]))
return true;
return false;
}
#endif

28
mhl/memory.h
View File

@ -1,28 +0,0 @@
#ifndef MHL_MEMORY_H
#define MHL_MEMORY_H
#include <memory.h>
#include <stdlib.h>
/* allocate a chunk of stack memory, uninitialized */
#define mhl_mem_alloc_u(sz) (malloc(sz))
/* allocate a chunk of stack memory, zeroed */
#define mhl_mem_alloc_z(sz) (calloc(1,sz))
/* free a chunk of memory from stack, passing NULL does no harm */
static inline void mhl_mem_free(void* ptr)
{
if (ptr) free(ptr);
}
/* free an ptr and NULL it */
#define MHL_PTR_FREE(ptr) do { mhl_mem_free(ptr); (ptr) = NULL; } while (0)
/* allocate a chunk on stack - automatically free'd on function exit */
#define mhl_stack_alloc(sz) (alloca(sz))
/* re-alloc memory chunk */
#define mhl_mem_realloc(ptr,sz) (realloc(ptr,sz))
#endif

49
mhl/strhash.h
View File

@ -1,49 +0,0 @@
#ifndef MHL_STRHASH_H
#define MHL_STRHASH_H
#include <hash.h>
#include <mhl/memory.h>
static void __mhl_strhash_free_key(void* ptr)
{
g_free(ptr);
}
static void __mhl_strhash_free_dummy(void* ptr)
{
}
typedef hash MHL_STRHASH;
#define MHL_STRHASH_DECLARE(n) MHL_STRHASH n;
#define MHL_STRHASH_INIT(h) \
hash_initialise(h, 997U, \
hash_hash_string, \
hash_compare_string, \
hash_copy_string, \
__mhl_strhash_free_key, \
__mhl_strhash_free_dummy)
#define MHL_STRHASH_DECLARE_INIT(n) \
MHL_STRHASH_DECLARE(n); \
MHL_STRHASH_INIT(&n);
#define MHL_STRHASH_DEINIT(ht) \
hash_deinitialise(ht)
static inline void mhl_strhash_addkey(MHL_STRHASH* ht, const char* key, void* value)
{
hash_insert(ht, (char*)key, value);
}
static inline void* mhl_strhash_lookup(MHL_STRHASH* ht, const char* key)
{
void* retptr;
if (hash_retrieve(ht, (char*)key, &retptr))
return retptr;
else
return NULL;
}
#endif

172
mhl/string.h
View File

@ -1,172 +0,0 @@
#ifndef MHL_STRING_H
#define MHL_STRING_H
#include <ctype.h>
#include <stdarg.h>
#include <assert.h>
#include <mhl/memory.h>
#define mhl_str_dup(str) ((str ? strdup(str) : strdup("")))
#define mhl_str_ndup(str,len) ((str ? strndup(str,len) : strdup("")))
#define mhl_str_len(str) ((str ? strlen(str) : 0))
#define ISSPACE(c) isspace((unsigned char)(c))
#define TOUPPER(c) toupper((unsigned char)(c))
static inline char * mhl_str_dup_range(const char * s_start, const char * s_bound)
{
return mhl_str_ndup(s_start, s_bound - s_start);
}
static inline char* mhl_str_trim(char* str)
{
if (!str) return NULL; /* NULL string ?! bail out. */
/* find the first non-space */
char* start; for (start=str; ((*str) && (!ISSPACE(*str))); str++);
/* only spaces ? */
if (!(*str)) { *str = 0; return str; }
/* get the size (cannot be empty - caught above) */
size_t _sz = strlen(str);
/* find the proper end */
char* end;
for (end=(str+_sz-1); ((end>str) && (ISSPACE(*end))); end--);
end[1] = 0; /* terminate, just to be sure */
/* if we have no leading spaces, just trucate */
if (start==str) { end++; *end = 0; return str; }
/* if it's only one char, dont need memmove for that */
if (start==end) { str[0]=*start; str[1]=0; return str; }
/* by here we have a (non-empty) region between start and end */
memmove(str,start,(end-start+1));
return str;
}
static inline void mhl_str_toupper(char* str)
{
if (str)
for (;*str;str++)
*str = TOUPPER(*str);
}
/* note: we use ((char*)(1)) as terminator - NULL is a valid argument ! */
static const char * mhl_s_c_sep__ = (const char *)1;
/* _NEVER_ call this function directly ! */
static inline char* mhl_str_concat_hlp__(const char* va_start_dummy, ...)
{
char * result;
size_t result_len = 0;
char * p;
const char * chunk;
va_list args;
va_start(args,va_start_dummy);
while ((chunk = va_arg(args, const char*)) != mhl_s_c_sep__)
{
if (chunk)
{
result_len += strlen (chunk);
}
}
va_end(args);
if (result_len == 0)
return mhl_str_dup("");
/* now as we know how much to copy, allocate the buffer + '\0'*/
result = (char*)mhl_mem_alloc_u (result_len + 1);
p = result;
va_start(args,va_start_dummy);
while ((chunk = va_arg(args, const char*)) != mhl_s_c_sep__)
{
if (chunk)
{
size_t chunk_len = strlen (chunk);
memcpy (p, chunk, chunk_len);
p += chunk_len;
}
}
va_end(args);
*p = '\0';
return result;
}
#define mhl_str_concat(...) (mhl_str_concat_hlp__(mhl_s_c_sep__, __VA_ARGS__, mhl_s_c_sep__))
static inline char* mhl_str_reverse(char* ptr)
{
if (!ptr) return NULL; /* missing string */
if (!(ptr[0] && ptr[1])) return ptr; /* empty or 1-ch string */
size_t _sz = strlen(ptr);
char* start = ptr;
char* end = ptr+_sz-1;
while (start<end)
{
char c = *start;
*start = *end;
*end = c;
start++;
end--;
}
return ptr;
}
/*
* strcpy is unsafe on overlapping memory areas, so define memmove-alike
* string function. Has sense only when dest <= src.
*/
static inline char * mhl_strmove(char * dest, const char * src)
{
size_t n = strlen (src) + 1; /* + '\0' */
/* strictly speaking, this invokes undefined behavior as soon as dest and src are pointers into different objects. */
assert (dest<=src);
return memmove(dest, src, n);
}
static inline char* mhl_str_dir_plus_file(const char* dirname, const char* filename)
{
/* make sure we have valid strings */
if (!dirname)
dirname="";
if (!filename)
filename="";
/* skip leading slashes on filename */
while (*filename == '/')
filename++;
/* skip trailing slashes on dirname */
size_t dnlen = strlen(dirname);
while ((dnlen != 0) && (dirname[dnlen-1]=='/'))
dnlen--;
size_t fnlen = strlen(filename);
char* buffer = mhl_mem_alloc_z(dnlen+fnlen+2); /* enough space for dirname, /, filename, zero */
char* ptr = buffer;
memcpy(ptr, dirname, dnlen);
ptr+=dnlen;
*ptr = '/';
ptr++;
memcpy(ptr, filename, fnlen);
ptr+=fnlen;
*ptr = 0;
return buffer;
}
#endif /* MHL_STRING_H */

18
mhl/types.h
View File

@ -1,18 +0,0 @@
/*
Micro Helper Library: generic type declarations
*/
#ifndef MHL_TYPES_H
#define MHL_TYPES_H
#if !defined(__bool_true_false_are_defined) && !defined(false) && !defined(true) && !defined(bool)
typedef enum
{
false = 0,
true = 1
} bool;
#endif
#endif

3
src/boxes.c
View File

@ -30,9 +30,6 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "win.h" /* Our window tools */

2
src/charsets.c
View File

@ -27,8 +27,6 @@
#include <iconv.h>
#include <mhl/string.h>
#include "global.h"
#include "charsets.h"

3
src/cmd.c
View File

@ -34,9 +34,6 @@
#endif
#include <unistd.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "cmd.h" /* Our definitions */
#include "fileopctx.h" /* file_op_context_new() */

3
src/color.c
View File

@ -22,9 +22,6 @@
#include <stdlib.h>
#include <string.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "setup.h" /* For the externs */

4
src/command.c
View File

@ -27,10 +27,6 @@
#include <errno.h>
#include <string.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include <mhl/escape.h>
#include "global.h" /* home_dir */
#include "tty.h"
#include "widget.h" /* WInput */

4
src/complete.c
View File

@ -30,10 +30,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <mhl/memory.h>
#include <mhl/escape.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "win.h"

3
src/dialog.c
View File

@ -24,9 +24,6 @@
#include <stdio.h>
#include <string.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "mouse.h"

3
src/dir.c
View File

@ -24,9 +24,6 @@
#include <string.h>
#include <sys/stat.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "dir.h"

3
src/ecs.c
View File

@ -27,9 +27,6 @@
#include <assert.h>
#include <ctype.h>
#include <mhl/types.h>
#include <mhl/string.h>
#include "global.h"
#include "ecs.h"

3
src/execute.c
View File

@ -19,9 +19,6 @@
#include <signal.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "win.h"

3
src/ext.c
View File

@ -27,9 +27,6 @@
#include <string.h>
#include <unistd.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "user.h"

10
src/file.c
View File

@ -50,10 +50,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <mhl/memory.h>
#include <mhl/escape.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "eregex.h"
@ -1805,13 +1801,13 @@ panel_operate (void *source_panel, FileOperation operation,
*/
if (force_single)
/* just copy */
dest_dir_ = mhl_str_dup (dest_dir);
dest_dir_ = g_strdup (dest_dir);
else
/* add trailing separator */
if (*dest_dir && strcmp(&dest_dir[strlen(dest_dir)-1], PATH_SEP_STR)) {
dest_dir_ = mhl_str_concat (dest_dir, PATH_SEP_STR);
dest_dir_ = g_strconcat (dest_dir, PATH_SEP_STR);
} else {
dest_dir_ = mhl_str_dup (dest_dir);
dest_dir_ = g_strdup (dest_dir);
}
if (!dest_dir_) {
file_op_context_destroy (ctx);

3
src/filegui.c
View File

@ -52,9 +52,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "setup.h" /* verbose */
#include "dialog.h" /* do_refresh() */

3
src/filenot.c
View File

@ -27,9 +27,6 @@
#include <errno.h>
#include <string.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
static char *

4
src/find.c
View File

@ -27,10 +27,6 @@
#include <string.h>
#include <sys/stat.h>
#include <mhl/types.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "win.h"

3
src/help.c
View File

@ -48,9 +48,6 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "color.h"

3
src/hotlist.c
View File

@ -36,9 +36,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h" /* COLS */
#include "color.h" /* dialog_colors */

3
src/info.c
View File

@ -20,9 +20,6 @@
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "global.h"
#include "tty.h"
#include "mouse.h" /* Gpm_Event */

4
src/key.c
View File

@ -32,10 +32,6 @@
#include <sys/types.h>
#include <unistd.h>
#include <mhl/types.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "mouse.h"

3
src/layout.c
View File

@ -42,9 +42,6 @@
#endif
#include <unistd.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h" /* COLS */
#include "win.h"

3
src/logging.c
View File

@ -26,9 +26,6 @@
#include <stdarg.h>
#include <stdio.h>
#include <mhl/memory.h>
#include <mhl/types.h>
#include "global.h"
#include "logging.h"
#include "setup.h"

3
src/main.c
View File

@ -33,9 +33,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "dir.h"

3
src/menu.c
View File

@ -23,9 +23,6 @@
#include <string.h>
#include <sys/types.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "menu.h"

3
src/panelize.c
View File

@ -29,9 +29,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h" /* attrset() */
#include "win.h"

3
src/profile.c
View File

@ -28,9 +28,6 @@
#include <string.h>
#include <sys/types.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "profile.h"

3
src/screen.c
View File

@ -27,9 +27,6 @@
#include <string.h>
#include <unistd.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "dir.h"

7
src/setup.c
View File

@ -23,9 +23,6 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "dir.h"
@ -415,14 +412,14 @@ panel_load_setup (WPanel *panel, const char *section)
/* User formats */
g_free (panel->user_format);
panel->user_format = mhl_str_dup (get_profile_string (section, "user_format",
panel->user_format = g_strdup (get_profile_string (section, "user_format",
DEFAULT_USER_FORMAT,
profile_name));
for (i = 0; i < LIST_TYPES; i++){
g_free (panel->user_status_format [i]);
g_snprintf (buffer, sizeof (buffer), "user_status%d", i);
panel->user_status_format [i] =
mhl_str_dup (get_profile_string (section, buffer,
g_strdup (get_profile_string (section, buffer,
DEFAULT_USER_FORMAT, profile_name));
}

3
src/subshell.c
View File

@ -44,9 +44,6 @@
# include <stropts.h> /* For I_PUSH */
#endif /* HAVE_STROPTS_H */
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h" /* LINES */
#include "panel.h" /* current_panel */

4
src/treestore.c
View File

@ -41,10 +41,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <mhl/types.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "treestore.h"
#include "profile.h"

3
src/user.c
View File

@ -23,9 +23,6 @@
#include <stdio.h>
#include <string.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "color.h"

65
src/util.c
View File

@ -34,10 +34,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <mhl/escape.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "profile.h"
#include "main.h" /* mc_home */
@ -1550,12 +1546,14 @@ Q_ (const char *s)
/** To be compatible with the general posix command lines we have to escape
strings for the command line
/params const char * in
\params in
string for escaping
/returns
\returns
return escaped string (later need to free)
*/
static char* shell_escape(const char* src)
char*
shell_escape(const char* src)
{
if ((src==NULL)||(!(*src)))
return strdup("");
@ -1590,12 +1588,14 @@ static char* shell_escape(const char* src)
/** Unescape paths or other strings for e.g the internal cd
shell-unescape within a given buffer (writing to it!)
/params const char * src
\params src
string for unescaping
/returns
\returns
return unescaped string
*/
static char* shell_unescape(char* text)
char*
shell_unescape(char* text)
{
if (!text)
return NULL;
@ -1660,53 +1660,20 @@ out:
/** Check if char in pointer contain escape'd chars
/params const char * in
\params in
string for checking
/returns
\returns
return TRUE if string contain escaped chars
otherwise return FALSE
*/
static gboolean
shell_is_char_escaped ( const char *in )
gboolean
shell_is_char_escaped ( const char *in )
{
if (in == NULL || !*in || in[0] != '\\')
return false;
return FALSE;
if (shell_escape_toesc(in[1]))
return TRUE;
return FALSE;
}
/*FIXME: move back to concat_dir_and_file */
static char* str_dir_plus_file(const char* dirname, const char* filename)
{
/* make sure we have valid strings */
if (!dirname)
dirname="";
if (!filename)
filename="";
/* skip leading slashes on filename */
while (*filename == '/')
filename++;
/* skip trailing slashes on dirname */
size_t dnlen = strlen(dirname);
while ((dnlen != 0) && (dirname[dnlen-1]=='/'))
dnlen--;
size_t fnlen = strlen(filename);
/*TODO: was previously calloc(1,dnlen+fnlen+2) - please review*/
char* buffer = g_malloc(dnlen+fnlen+2); /* enough space for dirname, /, filename, zero */
char* ptr = buffer;
memcpy(ptr, dirname, dnlen);
ptr+=dnlen;
*ptr = '/';
ptr++;
memcpy(ptr, filename, fnlen);
ptr+=fnlen;
*ptr = 0;
return buffer;
}

11
src/util.h
View File

@ -3,6 +3,7 @@
#include <sys/types.h>
/* Returns its argument as a "modifiable" string. This function is
* intended to pass strings to legacy libraries that don't know yet
* about the "const" modifier. The return value of this function
@ -256,4 +257,14 @@ extern int ascii_alpha_to_cntrl (int ch);
#undef Q_
const char *Q_ (const char *s);
gboolean shell_is_char_escaped ( const char * );
char *shell_unescape( char * );
char *shell_escape( const char * );
#define str_dup_range(s_start, s_bound) (g_strndup(s_start, s_bound - s_start))
#define str_move(dest, src) (g_strlcpy(dest,src,strlen(src)))
#define MC_PTR_FREE(ptr) do { g_free(ptr); (ptr) = NULL; } while (0)
#endif

14
src/utilunix.c
View File

@ -41,10 +41,6 @@
#endif
#include <unistd.h>
#include <mhl/types.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "execute.h"
#include "wtools.h" /* message() */
@ -430,7 +426,7 @@ canonicalize_pathname (char *path)
if (p[0] == PATH_SEP && p[1] == PATH_SEP) {
s = p + 1;
while (*(++s) == PATH_SEP);
mhl_strmove (p + 1, s);
str_move (p + 1, s);
}
p++;
}
@ -439,7 +435,7 @@ canonicalize_pathname (char *path)
p = lpath;
while (*p) {
if (p[0] == PATH_SEP && p[1] == '.' && p[2] == PATH_SEP)
mhl_strmove (p, p + 2);
str_move (p, p + 2);
else
p++;
}
@ -455,7 +451,7 @@ canonicalize_pathname (char *path)
lpath[1] = 0;
return;
} else {
mhl_strmove (lpath, lpath + 2);
str_move (lpath, lpath + 2);
}
}
@ -501,10 +497,10 @@ canonicalize_pathname (char *path)
if (p[3] != 0) {
if (s == lpath && *s == PATH_SEP) {
/* "/../foo" -> "/foo" */
mhl_strmove (s + 1, p + 4);
str_move (s + 1, p + 4);
} else {
/* "token/../foo" -> "foo" */
mhl_strmove (s, p + 4);
str_move (s, p + 4);
}
p = (s > lpath) ? s - 1 : s;
continue;

4
src/view.c
View File

@ -43,10 +43,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <mhl/types.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "cmd.h" /* For view_other_cmd */

4
src/widget.c
View File

@ -34,10 +34,6 @@
#include <string.h>
#include <sys/types.h>
#include <mhl/types.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "color.h"

3
src/wtools.c
View File

@ -29,9 +29,6 @@
#include <stdio.h>
#include <string.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "global.h"
#include "tty.h"
#include "color.h" /* dialog_colors */

3
vfs/cpio.c
View File

@ -22,9 +22,6 @@
#include <errno.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "../src/tty.h" /* enable/disable interrupt key */
#include "../src/wtools.h" /* message() */

3
vfs/direntry.c
View File

@ -28,9 +28,6 @@
#include <errno.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "../src/tty.h" /* enable/disable interrupt key */
#include "../src/wtools.h" /* message() */

3
vfs/extfs.c
View File

@ -36,9 +36,6 @@
#endif
#include <errno.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "../src/tty.h" /* enable/disable interrupt key */
#include "../src/wtools.h" /* message() */

10
vfs/fish.c
View File

@ -42,6 +42,7 @@
#include "../src/tty.h" /* enable/disable interrupt key */
#include "../src/wtools.h" /* message() */
#include "../src/main.h" /* print_vfs_message */
#include "../src/util.h"
#include "utilvfs.h"
#include "xdirentry.h"
#include "vfs.h"
@ -50,9 +51,6 @@
#include "tcputil.h"
#include "../src/unixcompat.h"
#include "fish.h"
#include "../mhl/memory.h"
#include "../mhl/string.h"
#include "../mhl/escape.h"
int fish_directory_timeout = 900;
@ -524,10 +522,10 @@ fish_dir_load(struct vfs_class *me, struct vfs_s_inode *dir, char *remote_path)
--linkname_bound; // skip trailing "
}
ent->name = mhl_str_dup_range(filename, filename_bound);
ent->name = str_dup_range(filename, filename_bound);
shell_unescape(ent->name);
ent->ino->linkname = mhl_str_dup_range(linkname, linkname_bound);
ent->ino->linkname = str_dup_range(linkname, linkname_bound);
shell_unescape(ent->ino->linkname);
} else {
// we expect: "escaped-name"
@ -541,7 +539,7 @@ fish_dir_load(struct vfs_class *me, struct vfs_s_inode *dir, char *remote_path)
--filename_bound;
}
ent->name = mhl_str_dup_range(filename, filename_bound);
ent->name = str_dup_range(filename, filename_bound);
shell_unescape(ent->name);
}
break;

3
vfs/ftpfs.c
View File

@ -69,9 +69,6 @@ What to do with this?
#include <errno.h>
#include <ctype.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "../src/tty.h" /* enable/disable interrupt key */
#include "../src/wtools.h" /* message() */

3
vfs/gc.c
View File

@ -31,9 +31,6 @@
#include <signal.h>
#include <ctype.h> /* is_digit() */
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "../src/tty.h" /* enable/disable interrupt key */
#include "../src/wtools.h" /* message() */

3
vfs/local.c
View File

@ -5,9 +5,6 @@
#include <stdio.h>
#include <string.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "../src/tty.h" /* enable/disable interrupt key */
#include "../src/wtools.h" /* message() */

3
vfs/sfs.c
View File

@ -34,9 +34,6 @@
#include <stdio.h>
#include <string.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "../src/tty.h" /* enable/disable interrupt key */
#include "../src/wtools.h" /* message() */

3
vfs/undelfs.c
View File

@ -51,9 +51,6 @@
#include <ext2fs/ext2fs.h>
#include <ctype.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "../src/tty.h" /* enable/disable interrupt key */
#include "../src/wtools.h" /* message() */

4
vfs/utilvfs.c
View File

@ -22,10 +22,6 @@
#include <ctype.h>
#include <mhl/types.h>
#include <mhl/memory.h>
#include <mhl/string.h>
#include "../src/global.h"
#include "../src/tty.h" /* enable/disable interrupt key */
#include "../src/wtools.h" /* message() */