{

if (filename == NULL)

{

return(0);

}

return((int)(path_basename(filename) - filename));

{

if (msg != NULL)

{

fprintf(stderr, "%s\n", msg);

}

if ((code != EXIT_SUCCESS) || (argv0 == NULL))

{

fprintf(stderr, "Try running with -h for usage information\n");

exit(code);

}

fprintf(stdout,

"Usage:\n"

"%s [options] [files ...]\n"

"\n"

"If no input files are specified, the input is read from stdin\n"

"If reading from stdin, you should specify the language using -l\n"

"\n"

"If -F is used or files are specified on the command line, the output filename is\n"

"'prefix/filename' + suffix\n"

"\n"

"When reading from stdin or doing a single file via the '-f' option,\n"

"the output is dumped to stdout, unless redirected with -o FILE.\n"

"\n"

"Errors are always dumped to stderr\n"

"\n"

"The '-f' and '-o' options may not be used with '-F', '--replace' or '--no-backup'.\n"

"The '--prefix' and '--suffix' options may not be used with '--replace' or '--no-backup'.\n"

"\n"

"Basic Options:\n"

" -c CFG : use the config file CFG\n"

" -f FILE : process the single file FILE (output to stdout, use with -o)\n"

" -o FILE : Redirect stdout to FILE\n"

" -F FILE : read files to process from FILE, one filename per line (- is stdin)\n"

" --check : Do not output the new text, instead verify that nothing changes when\n"

" the file(s) are processed.\n"

" The status of every file is printed to stderr.\n"

" The exit code is EXIT_SUCCESS if there were no changes, EXIT_FAILURE otherwise.\n"

" files : files to process (can be combined with -F)\n"

" --suffix SFX : Append SFX to the output filename. The default is '.uncrustify'\n"

" --prefix PFX : Prepend PFX to the output filename path.\n"

" --replace : replace source files (creates a backup)\n"

" --no-backup : replace files, no backup. Useful if files are under source control\n"

#ifdef HAVE_UTIME_H

" --mtime : preserve mtime on replaced files\n"

#endif

" -l : language override: C, CPP, D, CS, JAVA, PAWN, OC, OC+, VALA\n"

" -t : load a file with types (usually not needed)\n"

" -q : quiet mode - no output on stderr (-L will override)\n"

" --frag : code fragment, assume the first line is indented correctly\n"

"\n"

"Config/Help Options:\n"

" -h -? --help --usage : print this message and exit\n"

" --version : print the version and exit\n"

" --show-config : print out option documentation and exit\n"

" --update-config : Output a new config file. Use with -o FILE\n"

" --update-config-with-doc : Output a new config file. Use with -o FILE\n"

" --universalindent : Output a config file for Universal Indent GUI\n"

" --detect : detects the config from a source file. Use with '-f FILE'\n"

" Detection is fairly limited.\n"

"\n"

"Debug Options:\n"

" -p FILE : dump debug info to a file\n"

" -L SEV : Set the log severity (see log_levels.h)\n"

" -s : Show the log severity in the logs\n"

" --decode : decode remaining args (chunk flags) and exit\n"

"\n"

"Usage Examples\n"

"cat foo.d | uncrustify -q -c my.cfg -l d\n"

"uncrustify -c my.cfg -f foo.d\n"

"uncrustify -c my.cfg -f foo.d -L0-2,20-23,51\n"

"uncrustify -c my.cfg -f foo.d -o foo.d\n"

"uncrustify -c my.cfg foo.d\n"

"uncrustify -c my.cfg --replace foo.d\n"

"uncrustify -c my.cfg --no-backup foo.d\n"

"uncrustify -c my.cfg --prefix=out -F files.txt\n"

"\n"

"Note: Use comments containing ' *INDENT-OFF*' and ' *INDENT-ON*' to disable\n"

" processing of parts of the source file.\n"

"\n"

"There are currently %d options and minimal documentation.\n"

"Try UniversalIndentGUI and good luck.\n"

"\n"

,

path_basename(argv0), UO_option_count);

exit(code);

{

printf("uncrustify %s\n", UNCRUSTIFY_VERSION);

exit(0);

{

/* Reopen stdout */

FILE *my_stdout = stdout;

if (output_file != NULL)

{

my_stdout = freopen(output_file, "wb", stdout);

if (my_stdout == NULL)

{

LOG_FMT(LERR, "Unable to open %s for write: %s (%d)\n",

output_file, strerror(errno), errno);

usage_exit(NULL, NULL, 56);

}

LOG_FMT(LNOTE, "Redirecting output to %s\n", output_file);

}

{

string cfg_file;

const char *parsed_file = NULL;

const char *source_file = NULL;

const char *output_file = NULL;

const char *source_list = NULL;

log_mask_t mask;

int idx;

const char *p_arg;

/* If ran without options... check keyword sort and show the usage info */

if (argc == 1)

{

keywords_are_sorted();

usage_exit(NULL, argv[0], EXIT_SUCCESS);

}

/* Build options map */

register_options();

Args arg(argc, argv);

if (arg.Present("--version") || arg.Present("-v"))

{

version_exit();

}

if (arg.Present("--help") || arg.Present("-h") ||

arg.Present("--usage") || arg.Present("-?"))

{

usage_exit(NULL, argv[0], EXIT_SUCCESS);

}

if (arg.Present("--show-config"))

{

print_options(stdout);

return EXIT_SUCCESS;

}

cpd.do_check = arg.Present("--check");

#ifdef WIN32

/* tell windoze not to change what I write to stdout */

(void)_setmode(_fileno(stdout), _O_BINARY);

#endif

/* Init logging */

log_init(cpd.do_check ? stdout : stderr);

if (arg.Present("-q"))

{

logmask_from_string("", mask);

log_set_mask(mask);

}

if (((p_arg = arg.Param("-L")) != NULL) ||

((p_arg = arg.Param("--log")) != NULL))

{

logmask_from_string(p_arg, mask);

log_set_mask(mask);

}

cpd.frag = arg.Present("--frag");

if (arg.Present("--decode"))

{

idx = 1;

while ((p_arg = arg.Unused(idx)) != NULL)

{

log_pcf_flags(LSYS, strtoul(p_arg, NULL, 16));

}

return EXIT_SUCCESS;

}

/* Get the config file name */

if (((p_arg = arg.Param("--config")) != NULL) ||

((p_arg = arg.Param("-c")) != NULL))

{

cfg_file = p_arg;

}

/* Try to find a config file at an alternate location */

if (cfg_file.empty())

{

if (!unc_getenv("UNCRUSTIFY_CONFIG", cfg_file))

{

string home;

if (unc_homedir(home))

{

struct stat tmp_stat;

string path;

path = home + "/uncrustify.cfg";

if (stat(path.c_str(), &tmp_stat) == 0)

{

cfg_file = path;

}

else

{

path = home + "/.uncrustify.cfg";

if (stat(path.c_str(), &tmp_stat) == 0)

{

cfg_file = path;

}

}

}

}

}

/* Get the parsed file name */

if (((parsed_file = arg.Param("--parsed")) != NULL) ||

((parsed_file = arg.Param("-p")) != NULL))

{

LOG_FMT(LNOTE, "Will export parsed data to: %s\n", parsed_file);

}

/* Enable log sevs? */

if (arg.Present("-s") || arg.Present("--show"))

{

log_show_sev(true);

}

/* Load the config file */

set_option_defaults();

/* Load type files */

idx = 0;

while ((p_arg = arg.Params("-t", idx)) != NULL)

{

load_keyword_file(p_arg);

}

/* add types */

idx = 0;

while ((p_arg = arg.Params("--type", idx)) != NULL)

{

add_keyword(p_arg, CT_TYPE);

}

/* Load define files */

idx = 0;

while ((p_arg = arg.Params("-d", idx)) != NULL)

{

load_define_file(p_arg);

}

/* add defines */

idx = 0;

while ((p_arg = arg.Params("--define", idx)) != NULL)

{

add_define(p_arg, NULL);

}

/* Check for a language override */

if ((p_arg = arg.Param("-l")) != NULL)

{

cpd.lang_flags = language_flags_from_name(p_arg);

if (cpd.lang_flags == 0)

{

LOG_FMT(LWARN, "Ignoring unknown language: %s\n", p_arg);

}

else

{

cpd.lang_forced = true;

}

}

/* Get the source file name */

if (((source_file = arg.Param("--file")) == NULL) &&

((source_file = arg.Param("-f")) == NULL))

{

// not using a single file, source_file is NULL

}

if (((source_list = arg.Param("--files")) == NULL) &&

((source_list = arg.Param("-F")) == NULL))

{

// not using a file list, source_list is NULL

}

const char *prefix = arg.Param("--prefix");

const char *suffix = arg.Param("--suffix");

bool no_backup = arg.Present("--no-backup");

bool replace = arg.Present("--replace");

bool keep_mtime = arg.Present("--mtime");

bool update_config = arg.Present("--update-config");

bool update_config_wd = arg.Present("--update-config-with-doc");

bool detect = arg.Present("--detect");

/* Grab the output override */

output_file = arg.Param("-o");

LOG_FMT(LDATA, "config_file = %s\n", cfg_file.c_str());

LOG_FMT(LDATA, "output_file = %s\n", (output_file != NULL) ? output_file : "null");

LOG_FMT(LDATA, "source_file = %s\n", (source_file != NULL) ? source_file : "null");

LOG_FMT(LDATA, "source_list = %s\n", (source_list != NULL) ? source_list : "null");

LOG_FMT(LDATA, "prefix = %s\n", (prefix != NULL) ? prefix : "null");

LOG_FMT(LDATA, "suffix = %s\n", (suffix != NULL) ? suffix : "null");

LOG_FMT(LDATA, "replace = %d\n", replace);

LOG_FMT(LDATA, "no_backup = %d\n", no_backup);

LOG_FMT(LDATA, "detect = %d\n", detect);

LOG_FMT(LDATA, "check = %d\n", cpd.do_check);

if (cpd.do_check &&

(output_file || replace || no_backup || keep_mtime || update_config ||

update_config_wd || detect || prefix || suffix))

{

usage_exit("Cannot use --check with output options.", argv[0], 67);

}

if (!cpd.do_check)

{

if (replace || no_backup)

{

if ((prefix != NULL) || (suffix != NULL))

{

usage_exit("Cannot use --replace with --prefix or --suffix", argv[0], 66);

}

if ((source_file != NULL) || (output_file != NULL))

{

usage_exit("Cannot use --replace or --no-backup with -f or -o", argv[0], 66);

}

}

else

{

if ((prefix == NULL) && (suffix == NULL))

{

suffix = ".uncrustify";

}

}

}

/* Try to load the config file, if available.

if (!cfg_file.empty())

{

cpd.filename = cfg_file.c_str();

if (load_option_file(cpd.filename) < 0)

{

usage_exit("Unable to load the config file", argv[0], 56);

}

}

if (arg.Present("--universalindent"))

{

FILE *pfile = stdout;

if (output_file != NULL)

{

pfile = fopen(output_file, "w");

if (pfile == NULL)

{

fprintf(stderr, "Unable to open %s for write: %s (%d)\n",

output_file, strerror(errno), errno);

return EXIT_FAILURE;

}

}

print_universal_indent_cfg(pfile);

fclose(pfile);

return EXIT_SUCCESS;

}

if (detect)

{

file_mem fm;

if ((source_file == NULL) || (source_list != NULL))

{

fprintf(stderr, "The --detect option requires a single input file\n");

return EXIT_FAILURE;

}

/* Do some simple language detection based on the filename extension */

if (!cpd.lang_forced || (cpd.lang_flags == 0))

{

cpd.lang_flags = language_flags_from_filename(source_file);

}

/* Try to read in the source file */

if (load_mem_file(source_file, fm) < 0)

{

LOG_FMT(LERR, "Failed to load (%s)\n", source_file);

cpd.error_count++;

return EXIT_FAILURE;

}

uncrustify_start(fm.data);

detect_options();

uncrustify_end();

redir_stdout(output_file);

save_option_file(stdout, update_config_wd);

return EXIT_SUCCESS;

}

if (update_config || update_config_wd)

{

/* TODO: complain if file-processing related options are present */

redir_stdout(output_file);

save_option_file(stdout, update_config_wd);

return EXIT_SUCCESS;

}

/* Everything beyond this point requires a config file, so complain and

if (cfg_file.empty())

{

usage_exit("Specify the config file with '-c file' or set UNCRUSTIFY_CONFIG",

argv[0], 58);

}

/*

/* Check for unused args (ignore them) */

idx = 1;

p_arg = arg.Unused(idx);

/* Check args - for multifile options */

if ((source_list != NULL) || (p_arg != NULL))

{

if (source_file != NULL)

{

usage_exit("Cannot specify both the single file option and a multi-file option.",

argv[0], 67);

}

if (output_file != NULL)

{

usage_exit("Cannot specify -o with a multi-file option.",

argv[0], 68);

}

}

/* This relies on cpd.filename being the config file name */

load_header_files();

if (cpd.do_check)

{

cpd.bout = new deque<UINT8>();

}

if ((source_file == NULL) && (source_list == NULL) && (p_arg == NULL))

{

/* no input specified, so use stdin */

if (cpd.lang_flags == 0)

{

cpd.lang_flags = LANG_C;

}

if (!cpd.do_check)

{

redir_stdout(output_file);

}

file_mem fm;

if (!read_stdin(fm))

{

LOG_FMT(LERR, "Failed to read stdin\n");

return(100);

}

cpd.filename = "stdin";

/* Done reading from stdin */

LOG_FMT(LSYS, "Parsing: %d bytes (%d chars) from stdin as language %s\n",

(int)fm.raw.size(), (int)fm.data.size(),

language_name_from_flags(cpd.lang_flags));

uncrustify_file(fm, stdout, parsed_file);

}

else if (source_file != NULL)

{

/* Doing a single file */

do_source_file(source_file, output_file, parsed_file, no_backup, keep_mtime);

}

else

{

/* Doing multiple files */

if (prefix != NULL)

{

LOG_FMT(LSYS, "Output prefix: %s/\n", prefix);

}

if (suffix != NULL)

{

LOG_FMT(LSYS, "Output suffix: %s\n", suffix);

}

/* Do the files on the command line first */

idx = 1;

while ((p_arg = arg.Unused(idx)) != NULL)

{

char outbuf[1024];

do_source_file(p_arg,

make_output_filename(outbuf, sizeof(outbuf), p_arg, prefix, suffix),

NULL, no_backup, keep_mtime);

}

if (source_list != NULL)

{

process_source_list(source_list, prefix, suffix, no_backup, keep_mtime);

}

}

clear_keyword_file();

clear_defines();

if (cpd.do_check)

{

return cpd.check_fail_cnt ? EXIT_FAILURE : EXIT_SUCCESS;

}

return((cpd.error_count != 0) ? EXIT_FAILURE : EXIT_SUCCESS);

const char *prefix, const char *suffix,

bool no_backup, bool keep_mtime)

{

int from_stdin = strcmp(source_list, "-") == 0;

FILE *p_file = from_stdin ? stdin : fopen(source_list, "r");

if (p_file == NULL)

{

LOG_FMT(LERR, "%s: fopen(%s) failed: %s (%d)\n",

__func__, source_list, strerror(errno), errno);

cpd.error_count++;

return;

}

char linebuf[256];

char *fname;

int line = 0;

int len;

while (fgets(linebuf, sizeof(linebuf), p_file) != NULL)

{

line++;

fname = linebuf;

len = strlen(fname);

while ((len > 0) && unc_isspace(*fname))

{

fname++;

len--;

}

while ((len > 0) && unc_isspace(fname[len - 1]))

{

len--;

}

fname[len] = 0;

while (len-- > 0)

{

if (fname[len] == '\\')

{

fname[len] = '/';

}

}

LOG_FMT(LFILELIST, "%3d] %s\n", line, fname);

if (fname[0] != '#')

{

char outbuf[1024];

do_source_file(fname,

make_output_filename(outbuf, sizeof(outbuf), fname, prefix, suffix),

NULL, no_backup, keep_mtime);

}

}

if (!from_stdin)

{

fclose(p_file);

}

{

deque<UINT8> dq;

char buf[4096];

int len;

int idx;

fm.raw.clear();

fm.data.clear();

fm.enc = ENC_ASCII;

while (!feof(stdin))

{

len = fread(buf, 1, sizeof(buf), stdin);

for (idx = 0; idx < len; idx++)

{

dq.push_back(buf[idx]);

}

}

/* Copy the raw data from the deque to the vector */

fm.raw.insert(fm.raw.end(), dq.begin(), dq.end());

return(decode_unicode(fm.raw, fm.data, fm.enc, fm.bom));

{

int idx;

int last_idx = 0;

char outname[4096];

snprintf(outname, sizeof(outname), "%s", filename.c_str());

for (idx = 0; outname[idx] != 0; idx++)

{

if ((outname[idx] == '/') || (outname[idx] == '\\'))

{

outname[idx] = PATH_SEP;

}

if ((idx > last_idx) && (outname[idx] == PATH_SEP))

{

outname[idx] = 0;

if ((strcmp(&outname[last_idx], ".") != 0) &&

(strcmp(&outname[last_idx], "..") != 0))

{

//fprintf(stderr, "%s: %s\n", __func__, outname);

mkdir(outname, 0750);

}

outname[idx] = PATH_SEP;

}

if (outname[idx] == PATH_SEP)

{

last_idx = idx + 1;

}

}

{

int retval = -1;

struct stat my_stat;

FILE *p_file;

fm.raw.clear();

fm.data.clear();

fm.enc = ENC_ASCII;

/* Grab the stat info for the file */

if (stat(filename, &my_stat) < 0)

{

return(-1);

}

#ifdef HAVE_UTIME_H

/* Save off mtime */

fm.utb.modtime = my_stat.st_mtime;

#endif

/* Try to read in the file */

p_file = fopen(filename, "rb");

if (p_file == NULL)

{

return(-1);

}

fm.raw.resize(my_stat.st_size);

if (my_stat.st_size == 0)

{

/* Empty file */

retval = 0;

fm.bom = false;

fm.enc = ENC_ASCII;

fm.data.clear();

}

else

{

/* read the raw data */

if (fread(&fm.raw[0], fm.raw.size(), 1, p_file) != 1)

{

LOG_FMT(LERR, "%s: fread(%s) failed: %s (%d)\n",

__func__, filename, strerror(errno), errno);

cpd.error_count++;

}

else if (!decode_unicode(fm.raw, fm.data, fm.enc, fm.bom))

{

LOG_FMT(LERR, "%s: failed to decode the file '%s'\n", __func__, filename);

}

else

{

LOG_FMT(LNOTE, "%s: '%s' encoding looks like %s (%d)\n", __func__, filename,

fm.enc == ENC_ASCII ? "ASCII" :

fm.enc == ENC_BYTE ? "BYTES" :

fm.enc == ENC_UTF16_LE ? "UTF-16-LE" :

fm.enc == ENC_UTF16_BE ? "UTF-16-BE" : "Error",

fm.enc);

retval = 0;

}

}

fclose(p_file);

return(retval);

{

int retval;

char buf[1024];

snprintf(buf, sizeof(buf), "%.*s%s",

path_dirname_len(cpd.filename), cpd.filename, filename);

retval = load_mem_file(buf, fm);

if (retval < 0)

{

retval = load_mem_file(filename, fm);

if (retval < 0)

{

LOG_FMT(LERR, "Failed to load (%s) or (%s)\n", buf, filename);

cpd.error_count++;

}

}

return(retval);

{

int retval = 0;

if ((cpd.settings[UO_cmt_insert_file_header].str != NULL) &&

(cpd.settings[UO_cmt_insert_file_header].str[0] != 0))

{

retval |= load_mem_file_config(cpd.settings[UO_cmt_insert_file_header].str,

cpd.file_hdr);

}

if ((cpd.settings[UO_cmt_insert_file_footer].str != NULL) &&

(cpd.settings[UO_cmt_insert_file_footer].str[0] != 0))

{

retval |= load_mem_file_config(cpd.settings[UO_cmt_insert_file_footer].str,

cpd.file_ftr);

}

if ((cpd.settings[UO_cmt_insert_func_header].str != NULL) &&

(cpd.settings[UO_cmt_insert_func_header].str[0] != 0))

{

retval |= load_mem_file_config(cpd.settings[UO_cmt_insert_func_header].str,

cpd.func_hdr);

}

if ((cpd.settings[UO_cmt_insert_class_header].str != NULL) &&

(cpd.settings[UO_cmt_insert_class_header].str[0] != 0))

{

retval |= load_mem_file_config(cpd.settings[UO_cmt_insert_class_header].str,

cpd.class_hdr);

}

if ((cpd.settings[UO_cmt_insert_oc_msg_header].str != NULL) &&

(cpd.settings[UO_cmt_insert_oc_msg_header].str[0] != 0))

{

retval |= load_mem_file_config(cpd.settings[UO_cmt_insert_oc_msg_header].str,

cpd.oc_msg_hdr);

}

return(retval);

{

struct stat st1, st2;

int fd1, fd2;

UINT8 buf1[1024], buf2[1024];

int len1 = 0, len2 = 0;

int minlen;

/* Check the sizes first */

if ((stat(filename1.c_str(), &st1) != 0) ||

(stat(filename2.c_str(), &st2) != 0) ||

(st1.st_size != st2.st_size))

{

return(false);

}

if ((fd1 = open(filename1.c_str(), O_RDONLY)) < 0)

{

return(false);

}

if ((fd2 = open(filename2.c_str(), O_RDONLY)) < 0)

{

close(fd1);

return(false);

}

while ((len1 >= 0) && (len2 >= 0))

{

if (len1 == 0)

{

len1 = read(fd1, buf1, sizeof(buf1));

}

if (len2 == 0)

{

len2 = read(fd2, buf2, sizeof(buf2));

}

if ((len1 <= 0) || (len2 <= 0))

{

break;

}

minlen = (len1 < len2) ? len1 : len2;

if (memcmp(buf1, buf2, minlen) != 0)

{

break;

}

len1 -= minlen;

len2 -= minlen;

}

close(fd1);

close(fd2);

return((len1 == 0) && (len2 == 0));