encounter
/
MWCC
mirror of https://git.wuffs.org/MWCC
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
MWCC/command_line/CmdLine/Src/Envir/CLIO.c

903 lines
24 KiB
C
Raw Blame History

#include "cmdline.h"
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <util.h>
extern char STSbuf[256];
static int ioLineNum;
static Boolean printedAnything;
static char arrowBuf[256];
static Boolean newErr;
static Boolean newSrc;
static Boolean srcIsErr;
static OSSpec errSpec;
static OSSpec srcSpec;
static Boolean validErr;
static Boolean validSrc;
static SInt32 lastPrintingPlugin;
static Boolean ioInHelp;
static Boolean ioPiping;
static void catchinterrupt() {
clState.userBreak = 1;
}
static void SetupConsoleInfo(void) {
struct winsize ws;
struct stat st;
signal(SIGINT, catchinterrupt);
ioPiping = 0;
fstat(stdout->_file, &st);
if (st.st_mode & 0x1000)
ioPiping = 1;
fstat(stderr->_file, &st);
if (st.st_mode & 0x1000)
ioPiping = 1;
if (ioPiping) {
ws.ws_row = 0;
ws.ws_col = 80;
} else if (ioctl(stdout->_file, TIOCGWINSZ, &ws) < 0) {
ioPiping = 1;
ws.ws_row = 0;
ws.ws_col = 80;
}
optsEnvir.rows = ws.ws_row;
optsEnvir.cols = ws.ws_col;
if (optsEnvir.cols > 256)
optsEnvir.cols = 256;
}
static void Crash() {
*((unsigned char *) NULL) = 0;
}
void SetupDebuggingTraps(void) {
signal(SIGABRT, Crash);
}
Boolean IO_Initialize(void) {
ioPiping = 0;
ioInHelp = 0;
ioLineNum = 0;
SetupConsoleInfo();
if (ioPiping) {
setvbuf(stdout, NULL, 0, 1024);
setvbuf(stderr, NULL, 0, 1024);
} else {
setvbuf(stdout, NULL, 1, 1024);
setvbuf(stderr, NULL, 1, 1024);
}
InitWorking();
return 1;
}
Boolean IO_Terminate(void) {
if (ioInHelp)
IO_HelpTerminate();
TermWorking();
return 1;
}
Boolean IO_HelpInitialize(void) {
ioInHelp = 1;
return 1;
}
Boolean IO_HelpTerminate(void) {
ioInHelp = 0;
return 1;
}
static Boolean SendHandleToFile(FILE *file, Handle text, SInt32 size) {
Boolean ret;
char *ptr;
char *lineEnd;
char *end;
if (file != stdout && file != stderr)
setvbuf(file, NULL, 0, 1024);
HLock(text);
ptr = *text;
if (size && ptr[size - 1] == 0)
size--;
if (size <= 0) {
ret = 1;
} else {
end = ptr + size;
while (ptr < end) {
lineEnd = ptr;
while (lineEnd < end && *lineEnd != '\n' && *lineEnd != '\r')
lineEnd++;
if (lineEnd - ptr) {
if (fwrite(ptr, lineEnd - ptr, 1, file) != 1) {
CLReportCError(10, errno);
ret = 0;
goto fail;
}
}
if (CheckForUserBreak()) {
ret = 1;
goto fail;
}
// I have a hunch that this "\n" might be a define
if (fwrite("\n", strlen("\n"), 1, file) != 1) {
CLReportCError(10, errno);
ret = 0;
goto fail;
}
if (lineEnd < end && *(lineEnd++) == '\r' && *lineEnd == '\n')
++lineEnd;
ptr = lineEnd;
}
ret = 1;
}
fail:
HUnlock(text);
fflush(file);
if (file != stdout && file != stderr)
setvbuf(file, NULL, 2, 1024);
return ret;
}
void FixHandleForIDE(Handle text, UInt32 size) {
char *ptr;
HLock(text);
for (ptr = *text; ptr < (*text + size); ptr++) {
if (*ptr == '\r')
*ptr = '\n';
}
HUnlock(text);
}
Boolean ShowHandle(Handle text, UInt32 size, Boolean decorate) {
static const char *border = "===============\n";
if (decorate)
fprintf(stdout, border);
if (!SendHandleToFile(stdout, text, size))
return 0;
if (decorate)
fprintf(stdout, border);
fflush(stdout);
return 1;
}
Boolean WriteHandleToFile(OSSpec *spec, Handle text, UInt32 size, OSType creator, OSType type) {
FILE *file;
char path[256];
OS_SpecToString(spec, path, sizeof(path));
file = fopen(path, "w+b");
if (!file) {
CLReportCError(8, errno, path);
return 0;
}
SendHandleToFile(file, text, size);
fclose(file);
OS_SetMacFileCreatorAndType(spec, creator, type);
return 1;
}
Boolean WriteBinaryHandleToFile(OSSpec *spec, CWDataType maccreator, CWDataType mactype, OSHandle *text) {
int err;
OSFileHandle file;
if ((err = OS_NewFileHandle(spec, text, 1, &file)) || (err = OS_FreeFileHandle(&file)) || (err = OS_SetMacFileCreatorAndType(spec, maccreator, mactype))) {
CLReportOSError(8, err, OS_SpecToString(spec, STSbuf, sizeof(STSbuf)));
return 0;
}
return 1;
}
Boolean AppendHandleToFile(OSSpec *spec, Handle text, UInt32 size, CWDataType maccreator, CWDataType mactype) {
FILE *file;
char path[256];
OS_SpecToString(spec, path, sizeof(path));
file = fopen(path, "a+b");
if (!file) {
CLReportCError(8, errno, path);
return 0;
}
SendHandleToFile(file, text, size);
fclose(file);
OS_SetMacFileCreatorAndType(spec, maccreator, mactype);
return 1;
}
void InitWorking(void) {
}
void ShowWorking(int x) {
}
void TermWorking(void) {
}
static void ProgressFunction(const char *functionname) {
if (optsCmdLine.verbose)
CLReport(7, functionname);
}
Boolean CheckForUserBreak(void) {
ShowWorking(4);
return clState.userBreak;
}
typedef struct {
char *buffer;
int pos;
int maxlen;
SInt16 col;
Boolean original;
char *newline;
} UnkCLIOStruct;
// unknown names for these inlines
inline void appendText(UnkCLIOStruct *f, const char *str) {
int len = strlen(str);
if (f->pos + len >= f->maxlen) {
f->maxlen = f->maxlen * 2 + len;
if (f->original) {
char *oldbuf;
oldbuf = f->buffer;
f->buffer = xmalloc("message buffer", f->maxlen);
memcpy(f->buffer, oldbuf, f->pos);
} else {
f->buffer = xrealloc("message buffer", f->original ? NULL : f->buffer, f->maxlen);
}
f->original = 0;
}
memcpy(f->buffer + f->pos, str, len);
f->pos += len;
f->col += len;
}
inline void appendChar(UnkCLIOStruct *f, char c) {
if (f->pos >= f->maxlen) {
f->maxlen *= 2;
if (f->original) {
char *oldbuf = f->buffer;
f->buffer = xmalloc("message buffer", f->maxlen);
memcpy(f->buffer, oldbuf, f->pos);
} else {
f->buffer = xrealloc("message buffer", f->buffer, f->maxlen);
}
f->original = 0;
}
f->buffer[f->pos++] = c;
f->col++;
}
static void StartLine(UnkCLIOStruct *f) {
f->col = 0;
if (!optsEnvir.underIDE && f->newline)
appendText(f, f->newline);
}
inline void newLine(UnkCLIOStruct *f) {
if (f->newline)
appendChar(f, '\n');
else
appendChar(f, ' ');
StartLine(f);
}
static void WrapText(UnkCLIOStruct *f) {
int wrapped;
char wrapbuf[256];
char c;
wrapped = 0;
if (optsCmdLine.noWrapOutput)
return;
if (!f->newline)
return;
if (strlen(f->newline) > optsEnvir.cols / 2)
return;
while (wrapped < (optsEnvir.cols - 1) && f->col > strlen(f->newline)) {
c = f->buffer[f->pos - 1];
if (c == ' ') break;
if (c == '/') break;
if (c == '-') break;
wrapbuf[wrapped] = c;
f->pos = f->pos - 1;
f->col = f->col - 1;
wrapped++;
}
if (f->col <= strlen(f->newline)) {
while (f->col < (optsEnvir.cols - 1) && wrapped > 0) {
appendChar(f, wrapbuf[--wrapped]);
}
}
newLine(f);
while (wrapped > 0 && f->maxlen > 0) {
appendChar(f, wrapbuf[--wrapped]);
}
}
static char *IO_VFormatText(char *buffer, SInt32 size, char *newline, const char *format, va_list ap) {
UnkCLIOStruct f;
char *arg;
f.buffer = buffer;
f.pos = 0;
f.maxlen = size;
f.col = 0;
f.original = 1;
f.newline = newline;
StartLine(&f);
while (*format && f.maxlen > 0) {
if (*format == '%') {
arg = va_arg(ap, char *);
while (*arg && f.maxlen > 0) {
if (*arg == '\r' || *arg == '\n') {
newLine(&f);
arg++;
} else if (*arg == '\t') {
if (f.maxlen > 0) {
do {
appendChar(&f, ' ');
} while (f.col & 7);
}
arg++;
} else {
appendChar(&f, *(arg++));
if (!optsCmdLine.noWrapOutput && f.newline && f.col >= optsEnvir.cols - 1)
WrapText(&f);
}
}
format++;
} else if (*format == '\r' || *format == '\n') {
format++;
newLine(&f);
} else {
appendChar(&f, *(format++));
if (!optsCmdLine.noWrapOutput && f.col >= optsEnvir.cols - 1)
WrapText(&f);
}
}
if (f.newline) {
if (f.col == strlen(f.newline)) {
f.pos -= f.col;
f.col = 0;
}
}
appendChar(&f, 0);
return f.buffer;
}
char *IO_FormatText(char *buffer, SInt32 size, char *newline, const char *format, ...) {
va_list ap;
char *ret;
va_start(ap, format);
ret = IO_VFormatText(buffer, size, newline, format, ap);
va_end(ap);
return ret;
}
// TODO unify me with the one in the header
enum {
Msg_Note = 1,
Msg_Warning = 2,
Msg_Error = 3,
Msg_Alert = 4,
Msg_Status = 5
};
void CLPrintDispatch(int unk, SInt16 msgtype, const char *message) {
FILE *out;
const char *ptr;
const char *nptr;
if (optsCmdLine.stderr2stdout == 1 || msgtype == Msg_Note || msgtype == Msg_Status) {
out = stdout;
} else if (msgtype == Msg_Warning || msgtype == Msg_Error || msgtype == Msg_Alert) {
out = stderr;
} else {
#line 847
OPTION_ASSERT(0);
}
if (!printedAnything && !ioPiping) {
printedAnything = 1;
ioLineNum = 0;
}
ptr = message;
while (*ptr) {
nptr = ptr;
while (*nptr && *nptr != '\n' && *nptr != '\r')
++nptr;
if (nptr - ptr) {
if (fwrite(ptr, nptr - ptr, 1, out) != 1)
clState.userBreak = 1;
}
if (*nptr) {
ioLineNum++;
fwrite("\n", strlen("\n"), 1, out);
if (*nptr == '\r')
nptr++;
if (*nptr == '\n')
nptr++;
if (nptr[0] && !nptr[1] && (nptr[0] == '\n' || nptr[0] == '\r'))
nptr++;
}
ptr = nptr;
}
if (out == stdout && optsCmdLine.verbose > 1)
fflush(out);
}
static void GetFileInfo(MessageRef *ref) {
if (ref) {
srcIsErr = OS_EqualSpec(&ref->sourcefile, &ref->errorfile);
if (!validSrc || !OS_EqualSpec(&ref->sourcefile, &srcSpec)) {
newSrc = 1;
srcSpec = ref->sourcefile;
validSrc = 1;
} else {
newSrc = 0;
}
if (!validErr || !OS_EqualSpec(&ref->errorfile, &errSpec)) {
newErr = 1;
errSpec = ref->errorfile;
validErr = 1;
} else {
newErr = 0;
}
}
}
static char *Arrows(MessageRef *ref) {
int start;
int len;
arrowBuf[0] = 0;
start = ref->tokenoffset;
start %= optsEnvir.cols;
if (start >= 0 && start < sizeof(arrowBuf)) {
len = ref->tokenlength;
if (len + start > sizeof(arrowBuf))
len = sizeof(arrowBuf) - start;
if (len == 0)
len = 1;
memset(arrowBuf, ' ', start);
memset(arrowBuf + start, '^', len);
arrowBuf[start + len] = 0;
}
return arrowBuf;
}
static Boolean IsLikelyAnImporter(Plugin *plugin) {
if (Plugin_CL_GetObjectFlags(plugin)->flags & 0x80000000)
return 0;
return plugin != Plugins_CL_MatchTarget(NULL, gTarg->cpu, gTarg->os, clState.plugintype, clState.language);
}
static char *GuessTool(Plugin *plugin) {
if (plugin) {
DropInFlags *df = Plugin_GetDropInFlags(plugin);
switch (df->dropintype) {
case CWDROPINDRIVERTYPE: return "Driver";
case CWDROPINPARSERTYPE: return "Usage";
case CWDROPINCOMPILERTYPE:
if (df->edit_language == Lang_C_CPP || df->edit_language == Lang_Pascal)
return "Compiler";
else if (df->edit_language == CWFOURCHAR('A','s','m',' '))
return "Assembler";
else if (IsLikelyAnImporter(plugin))
return "Importer";
else
return "Compiler";
case CWDROPINLINKERTYPE:
return "Linker";
}
}
return "Driver";
}
static char *GuessDoing(Plugin *plugin) {
if (plugin) {
DropInFlags *df = Plugin_GetDropInFlags(plugin);
switch (df->dropintype) {
case CWDROPINPARSERTYPE: return "parsing";
case CWDROPINCOMPILERTYPE: return "compiling";
case CWDROPINLINKERTYPE: return "linking";
}
}
return "processing";
}
static const char *msgnames[6] = {
"",
"Note",
"Warning",
"Error",
"Alert",
"Status"
};
static const char *msgnames_gcc[6] = {
"",
" note",
" warning",
"",
" alert",
" status"
};
static void styledMessage_MPW(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, va_list va) {
char msgBuf[256];
char *msgPtr;
msgPtr = IO_VFormatText(msgBuf, sizeof(msgBuf), "# ", format, va);
if (msgType != Msg_Status)
CLPrintType(msgType, "### %s %s %s:\n", clState.programName, GuessTool(plugin), msgnames[msgType]);
if (ref) {
CLPrintType(msgType, "#\t%s\n", ref->sourceline);
CLPrintType(msgType, "#\t%s\n", Arrows(ref));
}
CLPrintDispatch(0, msgType, msgPtr);
if (ref) {
CLPrintType(msgType, "#----------------------------------------------------------\n");
CLPrintType(msgType, " File \"%s\"; Line %d\n", OS_SpecToString(&ref->errorfile, STSbuf, sizeof(STSbuf)), ref->linenumber);
GetFileInfo(ref);
if (!srcIsErr)
CLPrintType(msgType, "#\twhile %s \"%s\"\n", GuessDoing(plugin), OS_SpecToString(&ref->sourcefile, STSbuf, sizeof(STSbuf)));
CLPrintType(msgType, "#----------------------------------------------------------\n");
}
if (msgPtr != msgBuf)
free(msgPtr);
}
static void styledMessage_Default(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, va_list va) {
char lineBuf[320];
char msgBuf[256];
char *msgPtr;
char *ptr;
msgPtr = IO_VFormatText(msgBuf, sizeof(msgBuf), "# ", format, va);
if (ref) {
CLPrintType(msgType, "### %s %s:\n", clState.programName, GuessTool(plugin));
} else if (msgType != Msg_Status) {
CLPrintType(msgType, "### %s %s %s:\n", clState.programName, GuessTool(plugin), msgnames[msgType]);
}
if (ref) {
GetFileInfo(ref);
if (newErr || (newSrc && srcIsErr)) {
if (srcIsErr) {
sprintf(lineBuf, "#%8s: %s\n", "File", OS_SpecToStringRelative(&errSpec, NULL, STSbuf, sizeof(STSbuf)));
} else {
sprintf(lineBuf, "#%8s: %s\n", "In", OS_SpecToStringRelative(&errSpec, NULL, STSbuf, sizeof(STSbuf)));
}
CLPrintDispatch(0, msgType, lineBuf);
}
if (newSrc && !srcIsErr) {
sprintf(lineBuf, "# %7s: %s\n", "From", OS_SpecToStringRelative(&srcSpec, NULL, STSbuf, sizeof(STSbuf)));
CLPrintDispatch(0, msgType, lineBuf);
}
if (newErr || newSrc) {
ptr = &lineBuf[2];
while (*ptr && *ptr != '\n')
*(ptr++) = '-';
*ptr = 0;
if (ptr - lineBuf >= optsEnvir.cols - 1)
lineBuf[optsEnvir.cols - 1] = 0;
strcat(lineBuf, "\n");
CLPrintDispatch(0, msgType, lineBuf);
}
CLPrintType(msgType, "#%8d: %s\n", ref->linenumber, ref->sourceline);
CLPrintType(msgType, "#%8s: %s\n", msgnames[msgType], Arrows(ref));
}
CLPrintDispatch(0, msgType, msgPtr);
if (msgPtr != msgBuf)
free(msgPtr);
}
static void styledMessage_Terse(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, va_list va) {
char *msg;
char *ptr;
char msgBuf[256];
char *msgPtr;
char header[256];
char *headPtr;
char errBuf[256];
char *errPtr;
if (ref) {
if (msgnames_gcc[msgType][0]) {
headPtr = mprintf(
header, sizeof(header),
"%s:%d:%s: ",
OS_SpecToStringRelative(&ref->errorfile, NULL, STSbuf, sizeof(STSbuf)),
ref->linenumber,
msgnames_gcc[msgType]
);
} else {
headPtr = mprintf(
header, sizeof(header),
"%s:%d: ",
OS_SpecToStringRelative(&ref->errorfile, NULL, STSbuf, sizeof(STSbuf)),
ref->linenumber
);
}
} else if (msgType != Msg_Status) {
headPtr = mprintf(header, sizeof(header), "%s: ", clState.programName);
} else {
header[0] = 0;
headPtr = header;
}
msgPtr = IO_VFormatText(msgBuf, sizeof(msgBuf), headPtr, format, va);
if ((strstr(msgPtr, "#warning") || strstr(msgPtr, "#error")) && ref->sourceline[0]) {
errPtr = IO_FormatText(errBuf, sizeof(errBuf), headPtr, "%", ref->sourceline);
} else {
errPtr = 0;
}
if (headPtr != header)
free(headPtr);
msg = msgPtr;
while (*msg) {
ptr = msg;
while (*ptr && *ptr != '\n')
ptr++;
CLPrintType(msgType, "%.*s\n", ptr - msg, msg);
if (errPtr) {
CLPrintType(msgType, "%s\n", errPtr);
if (errPtr != errBuf)
free(errPtr);
errPtr = NULL;
}
if (*ptr)
msg = ptr + 1;
else
msg = ptr;
}
if (msgPtr != msgBuf)
free(msgPtr);
}
static void styledMessage_IDE(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, va_list va) {
char msgBuf[256];
char *msgPtr;
SInt16 oldCols;
oldCols = optsEnvir.cols;
msgPtr = IO_VFormatText(msgBuf, sizeof(msgBuf), " ", format, va);
optsEnvir.cols = oldCols;
CLPrintType(msgType, "%8s : %s\n", msgnames[msgType], msgPtr + 11);
if (msgPtr != msgBuf)
free(msgPtr);
if (ref) {
msgPtr = IO_FormatText(msgBuf, sizeof(msgBuf), "\t", "%", ref->sourceline);
CLPrintType(msgType, "%s line %d%s\n", OS_SpecToStringRelative(&ref->errorfile, NULL, STSbuf, sizeof(STSbuf)), ref->linenumber, msgPtr);
if (msgPtr != msgBuf)
free(msgPtr);
}
}
static void styledMessage_Parseable(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, va_list va) {
char msgBuf[256];
char *msgPtr;
CLPrintType(msgType, "%s|%s|%s\n", clState.programName, GuessTool(plugin), msgnames[msgType]);
if (ref) {
CLPrintType(
msgType,
"(%s|%d|%d|%d|%d|%d)\n",
OS_SpecToString(&ref->errorfile, STSbuf, sizeof(STSbuf)),
ref->linenumber,
ref->tokenoffset,
ref->tokenlength,
ref->selectionoffset,
ref->selectionlength
);
CLPrintType(msgType, "=%s\n", ref->sourceline);
}
msgPtr = IO_VFormatText(msgBuf, sizeof(msgBuf), ">", format, va);
CLPrintType(msgType, "%s\n", msgPtr);
if (msgPtr != msgBuf)
free(msgPtr);
}
void CLPrintType(SInt16 msgtype, const char *format, ...) {
char printbuffer[256];
char *ptr;
va_list va;
va_start(va, format);
ptr = mvprintf(printbuffer, sizeof(printbuffer), format, va);
va_end(va);
CLPrintDispatch(0, msgtype, ptr);
if (ptr != printbuffer)
free(ptr);
}
void CLPrint(const char *format, ...) {
char printbuffer[256];
char *ptr;
va_list va;
va_start(va, format);
ptr = mvprintf(printbuffer, sizeof(printbuffer), format, va);
va_end(va);
CLPrintDispatch(0, Msg_Note, ptr);
if (ptr != printbuffer)
free(ptr);
}
void CLPrintWarning(const char *format, ...) {
char printbuffer[256];
char *ptr;
va_list va;
va_start(va, format);
ptr = mvprintf(printbuffer, sizeof(printbuffer), format, va);
va_end(va);
CLPrintDispatch(0, Msg_Warning, ptr);
if (ptr != printbuffer)
free(ptr);
}
void CLPrintErr(const char *format, ...) {
char printbuffer[256];
char *ptr;
va_list va;
va_start(va, format);
ptr = mvprintf(printbuffer, sizeof(printbuffer), format, va);
va_end(va);
CLPrintDispatch(0, Msg_Error, ptr);
if (ptr != printbuffer)
free(ptr);
}
static void FixupMessageRef(MessageRef *ref) {
char *bol;
char *eol;
int len;
int scan;
if (ref->sourceline && *ref->sourceline) {
bol = ref->sourceline + ref->tokenoffset;
eol = ref->sourceline + ref->tokenoffset + ref->tokenlength - 1;
if (eol < bol)
eol = bol;
while (bol > ref->sourceline && bol[-1] != '\r')
bol--;
while (*eol && *eol != '\r' && *eol != '\n')
eol++;
len = eol - bol;
ref->sourceline = xmalloc("text buffer", len + 1);
strncpy(ref->sourceline, bol, len);
ref->sourceline[len] = 0;
for (scan = 0; scan < len; scan++) {
if (ref->sourceline[scan] < ' ' || ref->sourceline[scan] >= 127)
ref->sourceline[scan] = ' ';
}
} else {
ref->sourceline = 0;
}
}
SInt16 CLStyledMessageDispatch(Plugin *plugin, MessageRef *ref, SInt32 errorNumber, SInt16 msgType, const char *format, ...) {
va_list va;
MessageRef myref;
UInt32 ptype;
if (msgType == Msg_Warning) {
ptype = plugin ? Plugin_GetPluginType(plugin) : CWDROPINDRIVERTYPE;
if (optsCmdLine.noWarnings)
return 0;
if ((ptype == CWDROPINDRIVERTYPE || ptype == CWDROPINPARSERTYPE) && optsCmdLine.noCmdLineWarnings)
return 0;
if (optsCmdLine.warningsAreErrors)
msgType = Msg_Error;
}
if (msgType == Msg_Error && clState.withholdErrors)
return 0;
if (msgType == Msg_Warning && clState.withholdWarnings)
return 0;
if (ref) {
myref = *ref;
FixupMessageRef(&myref);
}
va_start(va, format);
if (optsCmdLine.msgStyle == 2) {
styledMessage_MPW(plugin, ref ? &myref : 0, errorNumber, msgType, format, va);
} else if (optsCmdLine.msgStyle == 1) {
styledMessage_Terse(plugin, ref ? &myref : 0, errorNumber, msgType, format, va);
} else if (optsCmdLine.msgStyle == 3) {
styledMessage_IDE(plugin, ref ? &myref : 0, errorNumber, msgType, format, va);
} else if (optsCmdLine.msgStyle == 4) {
styledMessage_Parseable(plugin, ref ? &myref : 0, errorNumber, msgType, format, va);
} else {
styledMessage_Default(plugin, ref ? &myref : 0, errorNumber, msgType, format, va);
}
va_end(va);
if (ref && myref.sourceline)
xfree(myref.sourceline);
if (msgType == Msg_Error && optsCmdLine.maxErrors) {
if (++clState.countErrors >= optsCmdLine.maxErrors) {
clState.withholdErrors = 1;
if (!optsCompiler.noFail) {
CLReport(70);
clState.userBreak = 1;
} else {
CLReport(71);
}
}
}
if (msgType == Msg_Warning && optsCmdLine.maxWarnings) {
if (++clState.countWarnings >= optsCmdLine.maxWarnings) {
clState.withholdWarnings = 1;
CLReport(72);
}
}
return msgType;
}
Reference in New Issue View Git Blame Copy Permalink