(SYNC) Synchronisation with local latest modifications.
This commit is contained in:
William
7
.gitignore
vendored
7
.gitignore
vendored
@@ -2,7 +2,7 @@
|
||||
*CMakeFiles/*
|
||||
*CMakeCache*
|
||||
cmake_install.cmake
|
||||
*[tT]est*
|
||||
test.sh
|
||||
*~
|
||||
gitwork
|
||||
work
|
||||
@@ -13,11 +13,10 @@ todo_stack
|
||||
getReady.sh
|
||||
base_type.c
|
||||
sample
|
||||
<<<<<<< HEAD
|
||||
compile
|
||||
=======
|
||||
>>>>>>> refs/remotes/master/master
|
||||
.vscode/
|
||||
todo
|
||||
vsc*
|
||||
libcompound.so
|
||||
ccwarn
|
||||
genwarn.sh
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
Status Array_Create(Array *inst, int len, size_t size)
|
||||
{
|
||||
/* Skip unavailable inst and invalid param. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
state((len < 0), apply(InvalidArrayLength));
|
||||
solve((!len), { inst->len = 0; inst->members = NULL; return apply(NormalStatus); })
|
||||
|
||||
@@ -49,8 +49,8 @@ Status Array_Create(Array *inst, int len, size_t size)
|
||||
Status Array_CopyOf(Array *inst, Array *other)
|
||||
{
|
||||
// /* Skip unavailable inst and invalid param. */
|
||||
// fails(inst, apply(UnavailableInstance));
|
||||
// fails(other, error(InvalidParameter, "Given other was unavailable."));
|
||||
// nonull(inst, apply(UnavailableInstance));
|
||||
// nonull(other, error(InvalidParameter, "Given other was unavailable."));
|
||||
|
||||
// /* Assign value for len. */
|
||||
// inst->len = other->len;
|
||||
@@ -86,7 +86,7 @@ Status Array_CopyOf(Array *inst, Array *other)
|
||||
Status Array_Delete(Array *inst)
|
||||
{
|
||||
/* Skip unavailable inst and invalid param. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
solve((inst->members == NULL), return apply(NormalStatus));
|
||||
|
||||
inst->len = 0;
|
||||
@@ -99,8 +99,8 @@ Status Array_Delete(Array *inst)
|
||||
Status Array_GetIdx(Array *inst, Var *store, int index)
|
||||
{
|
||||
/* Skip unavailable inst and invalid param. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(store,
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(store,
|
||||
apply(error(InvalidParameter, "Given reference to store was unavailable.")));
|
||||
state((index < 0 || index >= inst->len), apply(ArrayIndexOutOfBound));
|
||||
|
||||
@@ -112,8 +112,8 @@ Status Array_GetIdx(Array *inst, Var *store, int index)
|
||||
Status Array_SetIdx(Array *inst, Var *source, int index)
|
||||
{
|
||||
/* Skip unavailable inst and invalid param. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(source,
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(source,
|
||||
apply(
|
||||
error(InvalidParameter, "Given reference to source was unavailable.")));
|
||||
state((index < 0 || index >= inst->len), apply(ArrayIndexOutOfBound));
|
||||
@@ -142,8 +142,8 @@ bool Array_Equals(Array *a, Array *b)
|
||||
|
||||
Status ArrayUtils_Fill(Array *inst, Var *elem, int off, int len)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(elem,
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(elem,
|
||||
apply(error(InvalidParameter, "Given reference to elem was unavailable.")));
|
||||
state((off + len > inst->len) || (off < 0) || (len < 0),
|
||||
apply(ArrayIndexOutOfBound));
|
||||
|
||||
@@ -2,7 +2,76 @@ cmake_minimum_required (VERSION 3.5)
|
||||
|
||||
project (Compound)
|
||||
|
||||
add_compile_options(-g -std=c99 -Wall -Wextra -Wformat)
|
||||
set(CMAKE_C_COMPILER gcc)
|
||||
|
||||
set(WALL -Waddress
|
||||
-Warray-compare
|
||||
-Warray-parameter=2
|
||||
-Wbool-compare
|
||||
-Wbool-operation
|
||||
-Wchar-subscripts
|
||||
-Wcomment
|
||||
-Wdangling-else
|
||||
-Wdangling-pointer=2
|
||||
-Wenum-compare
|
||||
-Wenum-int-mismatch
|
||||
-Wformat=1
|
||||
-Wformat-contains-nul
|
||||
-Wformat-diag
|
||||
-Wformat-extra-args
|
||||
-Wformat-overflow=1
|
||||
-Wformat-truncation=1
|
||||
-Wformat-zero-length
|
||||
-Wframe-address
|
||||
-Wimplicit
|
||||
-Wimplicit-function-declaration
|
||||
-Wimplicit-int
|
||||
-Winfinite-recursion
|
||||
-Wint-in-bool-context
|
||||
-Wlogical-not-parentheses
|
||||
-Wmain
|
||||
-Wmaybe-uninitialized
|
||||
-Wmemset-elt-size
|
||||
-Wmemset-transposed-args
|
||||
-Wmisleading-indentation
|
||||
-Wmismatched-dealloc
|
||||
-Wmissing-attributes
|
||||
-Wmissing-braces
|
||||
-Wmultistatement-macros
|
||||
-Wnonnull
|
||||
-Wnonnull-compare
|
||||
-Wopenmp-simd
|
||||
-Wpacked-not-aligned
|
||||
-Wparentheses
|
||||
-Wpointer-sign
|
||||
-Wrestrict
|
||||
-Wreturn-type
|
||||
-Wsequence-point
|
||||
-Wsizeof-array-div
|
||||
-Wsizeof-pointer-div
|
||||
-Wsizeof-pointer-memaccess
|
||||
-Wstrict-aliasing
|
||||
-Wstrict-overflow=1
|
||||
-Wswitch
|
||||
-Wtautological-compare
|
||||
-Wtrigraphs
|
||||
-Wuninitialized
|
||||
-Wunknown-pragmas
|
||||
-Wunused
|
||||
-Wunused-but-set-variable
|
||||
-Wunused-const-variable=1
|
||||
-Wunused-function
|
||||
-Wunused-label
|
||||
-Wunused-local-typedefs
|
||||
-Wunused-value
|
||||
-Wunused-variable
|
||||
-Wuse-after-free=2
|
||||
-Wvla-parameter
|
||||
-Wvolatile-register-var
|
||||
-Wzero-length-bounds
|
||||
)
|
||||
|
||||
add_compile_options(-g -std=c99 ${WALL} -Wextra -D__DEBUG__)
|
||||
|
||||
set(SHARED_SOURCE
|
||||
MemMan/src/memman.c
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
Status Memory_Create(Memory *inst, size_t size)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
|
||||
*inst = (Memory) {
|
||||
.addr = NULL,
|
||||
@@ -16,7 +16,7 @@ Status Memory_Create(Memory *inst, size_t size)
|
||||
|
||||
Status Memory_Allocate(Memory *inst)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
state(inst->alive, apply(InstanceStillAlive));
|
||||
|
||||
/* When failed on allocating. */
|
||||
@@ -28,7 +28,7 @@ Status Memory_Allocate(Memory *inst)
|
||||
|
||||
Status Memory_Reallocate(Memory *inst, size_t size)
|
||||
{
|
||||
fails(inst, apply(UnavailableBuffer));
|
||||
nonull(inst, apply(UnavailableBuffer));
|
||||
state(!inst->alive, apply(InstanceNotAlive));
|
||||
|
||||
/* When failed on reallocating. */
|
||||
@@ -40,7 +40,7 @@ Status Memory_Reallocate(Memory *inst, size_t size)
|
||||
|
||||
Status Memory_Release(Memory *inst)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
state(!inst->alive,
|
||||
apply(error(InstanceNotAlive, "Cannot release a non-alive instance.")));
|
||||
|
||||
@@ -52,7 +52,7 @@ Status Memory_Release(Memory *inst)
|
||||
|
||||
Status Memory_Delete(Memory *inst)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
state(inst->alive,
|
||||
apply(
|
||||
error(InstanceStillAlive, "Cannot deinitialise a instance still alive.")));
|
||||
|
||||
@@ -63,46 +63,18 @@ typedef struct _Status {
|
||||
struct _Status *prev;
|
||||
} Status;
|
||||
|
||||
# define DEFSTATUS(i, v, d, c, p)\
|
||||
static const Status i = {\
|
||||
.identity = nameof(i),\
|
||||
.value = v,\
|
||||
.description = d,\
|
||||
.characteristic = c,\
|
||||
.loc = __GLOBAL__,\
|
||||
.prev = (Status *)p\
|
||||
# define DEFSTATUS(i, v, d, c, p) \
|
||||
static const Status i = { \
|
||||
.identity = nameof(i), \
|
||||
.value = v, \
|
||||
.description = d, \
|
||||
.characteristic = c, \
|
||||
.loc = __GLOBAL__, \
|
||||
.prev = (Status *)p \
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
{value "description" characteristic prev}
|
||||
|
||||
"%d \"%s\" %d %p"
|
||||
|
||||
*/
|
||||
|
||||
/* line, func, file */
|
||||
// # define LOCATION_LITERALISE_FORMAT "at line %d, in %s, %s"
|
||||
|
||||
/* file, line, func */
|
||||
# define LOCATION_LITERALISE_FORMAT "at %s:%d, in function `%s\'"
|
||||
# define LOCATION_LITERALISE_FORMAT_LENGTH 20
|
||||
|
||||
/* value, description, characteristic, prev */
|
||||
// # define STATUS_LITERALISE_FORMAT "%d \"%s\" %d %p"
|
||||
/* identity, prev->identity, value, characteristic, description, <loc> */
|
||||
// # define STATUS_LITERALISE_FORMAT "%s (prev: %s): $=%d @=%d\n\t\"%s\"\n\t%s"
|
||||
|
||||
// MaximumLiteralisationLengthExceeded (prev: MaximumLengthExceeded): $=1 @=1
|
||||
|
||||
/*
|
||||
MaximumLengthExceeded: "Buffer was too long."
|
||||
predecessor=<ArrayLengthError> value=(1) characteristic=[1]
|
||||
at line 40, in Main, /home/william/Documents/Projects/Compound/test.c
|
||||
|
||||
*/
|
||||
|
||||
// identity, description, prev->identity, value, characteristic, <loc>
|
||||
# define STATUS_LITERALISE_FORMAT \
|
||||
"%s: \"%s\"\n\tpredecessor=<%s> value=(%d) characteristic=[%d]\n\t%s\n"
|
||||
|
||||
@@ -116,7 +88,7 @@ typedef enum {
|
||||
REPORT_SENDING_PRIORITY_MINOR,
|
||||
REPORT_SENDING_PRIORITY_DEBUG,
|
||||
REPORT_SENDING_PRIORITY_NONE, // Lowest level, greatest value.
|
||||
} ReportSendingPriority;
|
||||
} ReportLevel;
|
||||
|
||||
typedef enum {
|
||||
REPORT_SENDING_TASK_STATUS_FINISHED = 0,
|
||||
@@ -124,21 +96,20 @@ typedef enum {
|
||||
REPORT_SENDING_TASK_STATUS_PROCEEDING,
|
||||
REPORT_SENDING_TASK_STATUS_PAUSED,
|
||||
REPORT_SENDING_TASK_STATUS_NOTFOUND
|
||||
} ReportSendingTaskStatus;
|
||||
} ReportStatus;
|
||||
|
||||
/* "Report" recollects essential informations, included but not limited to
|
||||
Status and others for making an report for debugging and such. */
|
||||
typedef struct {
|
||||
Status status;
|
||||
Status content;
|
||||
char *initiator;
|
||||
time_t time;
|
||||
ReportSendingPriority priority;
|
||||
ReportSendingTaskStatus taskprint_status;
|
||||
FILE *dest; // The destination where the report is sending to.
|
||||
ReportLevel level;
|
||||
ReportStatus status;
|
||||
FILE *dst; // The destination where the report is sending to.
|
||||
} Report;
|
||||
|
||||
/*
|
||||
|
||||
DATETIME [PRIORITY] STATUSNAME (ORIGINATOR): STATUS.DESCRIPTION
|
||||
at LOCATION.FILE:LOCATION.LINE, LOCATION.FUNC
|
||||
at LOCATION.FILE:LOCATION.LINE, LOCATION.FUNC
|
||||
@@ -146,7 +117,7 @@ DATETIME [PRIORITY] STATUSNAME (ORIGINATOR): STATUS.DESCRIPTION
|
||||
at LOCATION.FILE:LOCATION.LINE, LOCATION.FUNC
|
||||
|
||||
|
||||
Fri 10 May 03:02:37 CST 2024 [EXCEPTIONAL] InvalidParameter (Nullity): Given buffer was unavailable.
|
||||
Fri 10 May 03:02:37 CST 2024 [URGENT] InvalidParameter (Nullity): Given buffer was unavailable.
|
||||
at /external/Documents/Projects/Compound/Status/src/status.c:104, Report_Literalise
|
||||
at /external/Documents/Projects/Compound/Status/src/status.c:114, ReportSender_Send
|
||||
at /external/Documents/Projects/Compound/Status/src/status.c:69, _throw
|
||||
@@ -155,33 +126,29 @@ Fri 10 May 03:02:37 CST 2024 [EXCEPTIONAL] InvalidParameter (Nullity): Given buf
|
||||
|
||||
*/
|
||||
|
||||
# define REPORT_LITERALISE_HEADER_FORMAT "%s [%s] %s (%s): %s"
|
||||
# define REPORT_LITERALISE_CHAINS_FORMAT " at %s:%d, %s"
|
||||
# define REPORT_LITERALISE_CHAINS_EXCLAIM_FORMAT "!!!!at %s:%d, %s"
|
||||
// DATETIME [LEVEL] STATUS.IDENTITY (INITIATOR): STATUS.DESCRIPTION
|
||||
# define REPORT_LITERALISE_FORMAT_HEADER "%s [%d] %s (%s): %s\n\tat %s:%d, %s\n%s"
|
||||
|
||||
// STATUS.IDENTITY, STATUS.PREV.IDENTITY, STATUS.VALUE, STATUS.CHARACTERISTIC,
|
||||
// FILE, LINE, FUNC
|
||||
# define REPORT_LITERALISE_FORMAT_DETAIL "\t%s(%s, %d, %d) at %s:%d, %s\n"
|
||||
|
||||
typedef enum {
|
||||
REPORT_SENDER_RESULT_FINISHED,
|
||||
REPORT_SENDER_RESULT_PROGRESSING,
|
||||
REPORT_SENDER_RESULT_PENDING
|
||||
} ReportSenderResult;
|
||||
REPORT_RESULT_SUCCEEDED,
|
||||
REPORT_RESULT_FAILED,
|
||||
REPORT_RESULT_PROGRESSING,
|
||||
REPORT_RESULT_PENDING,
|
||||
} ReportResult;
|
||||
|
||||
typedef struct {
|
||||
thrd_t thread;
|
||||
Report *report; // The report for sending.
|
||||
time_t elapsed; // The individual elapsed time for each report. (Array)
|
||||
ReportSenderResult result;
|
||||
bool successful;
|
||||
Report report;
|
||||
time_t elapsed;
|
||||
ReportResult result;
|
||||
} ReportSender;
|
||||
|
||||
typedef int (*ReportSendingTask)(Report *rep);
|
||||
typedef int ReportSendingTaskID;
|
||||
|
||||
typedef struct {
|
||||
ReportSendingTask *tasks; // Array Ref
|
||||
int sendercount;
|
||||
int finishedcount;
|
||||
int *results; // Array
|
||||
} ReportSendingManager;
|
||||
typedef int (*ReportTask)(Report *);
|
||||
typedef int ReportTaskID;
|
||||
|
||||
// typedef thrd_start_t ArgueStart;
|
||||
|
||||
@@ -218,8 +185,10 @@ typedef struct {
|
||||
Status Location_Literalise(Location *inst, char *buff);
|
||||
bool Location_Equals(Location lc1, Location lc2);
|
||||
Status Status_Literalise(Status *inst, char *buff);
|
||||
Status Status_LiteraliseForReport(Status *inst, char *buff);
|
||||
bool Status_Equal(Status *stat1, Status *stat2);
|
||||
void StatusUtils_Dump(Status *inst, Status *store, int idx);
|
||||
// void StatusUtils_Dump(Status *inst, Status **store, int idx);
|
||||
void StatusUtils_Dump(Status *inst, Status *store);
|
||||
bool StatusUtils_HasPrev(Status inst);
|
||||
bool StatusUtils_IsOkay(Status inst);
|
||||
bool StatusUtils_IsRecursive(Status inst);
|
||||
@@ -232,16 +201,12 @@ Status Report_Literalise(Report *inst, char *buff);
|
||||
void Report_Delete(Report *inst);
|
||||
bool Report_Equals(Report repo1, Report repo2);
|
||||
|
||||
// Status ReportSender_Create(ReportSender *inst, Report *report, thrd_start_t *handler);
|
||||
Status ReportSender_Create(ReportSender *inst, Report *report);
|
||||
Status ReportSender_Send(ReportSender *inst, ReportSendingTask task);
|
||||
// ReportSendingTaskStatus
|
||||
// ReportSender_GetStatus(ReportSender *inst);
|
||||
Status ReportSender_Send(ReportSender *inst, ReportTask task);
|
||||
|
||||
ReportSendingTaskID
|
||||
ReportSenderManager_AppendTask(ReportSendingManager *inst,
|
||||
ReportSendingTask task);
|
||||
Status ReportSenderManager_RemoveTask(ReportSendingManager *inst,
|
||||
ReportSendingTaskID taskid);
|
||||
// ReportTaskStatus
|
||||
// ReportSender_GetStatus(ReportSender *inst);
|
||||
|
||||
// Status
|
||||
// arguestarter_create(ArgueStartParam *inst, void *external_param);
|
||||
@@ -315,6 +280,10 @@ DEFSTATUS(RuntimeError, 1,
|
||||
"A runtime error occurred.",
|
||||
STATUS_ERROR, &ErrorStatus);
|
||||
|
||||
DEFSTATUS(InstanceCreatingFailure, 1,
|
||||
"Cannot create the instance.",
|
||||
STATUS_ERROR, &RuntimeError);
|
||||
|
||||
DEFSTATUS(ArrayLengthError, 1,
|
||||
"Given array length does not meet the requirement.",
|
||||
STATUS_ERROR, &ErrorStatus);
|
||||
@@ -403,72 +372,89 @@ DEFSTATUS(InvalidLiteralisingBuffer, 1,
|
||||
"Given buffer does not have a good integrity on its length.",
|
||||
STATUS_ERROR, &InvalidObject);
|
||||
|
||||
DEFSTATUS(NoBytesWereRead, 1,
|
||||
"Called function had returned ZERO indicating no bytes were read.",
|
||||
STATUS_ERROR, &ReadWriteError);
|
||||
|
||||
DEFSTATUS(NoBytesWereWritten, 1,
|
||||
"Called function had returned ZERO indicating no bytes were written.",
|
||||
STATUS_ERROR, &ReadWriteError);
|
||||
|
||||
// DEFSTATUS(ProgrammeConstructionError, 1,
|
||||
// "Failed on constructing programme at the entrance.",
|
||||
// STATUS_ERROR, &RuntimeError);
|
||||
|
||||
// ========================================================
|
||||
|
||||
static inline Status PrintStatus(Status s)
|
||||
{
|
||||
/* Literalise. */
|
||||
char buff[LITERALISATION_LENGTH_MAXIMUM];
|
||||
(void)Status_Literalise(&s, buff);
|
||||
|
||||
/* Handle returning value. */
|
||||
/* No bytes were written to buffer. */
|
||||
unsure(Status_Literalise(&s, buff), !_.value, {
|
||||
return apply(NoBytesWereWritten);
|
||||
})
|
||||
|
||||
/* Output. */
|
||||
where(fprintf(stderr, "%s\n", buff), {
|
||||
/* Pass on returning value. */
|
||||
return apply(value(TraditionalFunctionReturn, _));
|
||||
})
|
||||
}
|
||||
|
||||
static inline void PrintStatusDump(Status s)
|
||||
{
|
||||
Status stat = s;
|
||||
const int dump_len = StatusUtils_Depth(&stat);
|
||||
/* Create dump. */
|
||||
const int dump_len = StatusUtils_Depth(&s);
|
||||
Status dump[dump_len];
|
||||
StatusUtils_Dump(&stat, dump, 0);
|
||||
/* TODO(william): Replace following line with coloured-term-output function. */
|
||||
(void)printf("\e[1m======== STATUS STACK DUMP: %s ========\e[0m\n",
|
||||
stat.identity);
|
||||
Status current = s;
|
||||
dump[0] = current; // Put self at leading.
|
||||
for (register int i = 1; i < dump_len; i++) {
|
||||
// StatusUtils_Dump will only access (storage) the prev.
|
||||
// It does not include this status itself.
|
||||
StatusUtils_Dump(¤t, &dump[i]);
|
||||
current = *current.prev;
|
||||
}
|
||||
|
||||
/* Output by iterating. */
|
||||
for (register int i = 0; i < dump_len; i++) {
|
||||
/* TODO(william): Replace following line with coloured-term-output function. */
|
||||
(void)printf("\e[1m[%d/%d]\e[0m\n", (dump_len - i), dump_len);
|
||||
seek(PrintStatus(dump[i]), {
|
||||
solve(!_.value, {
|
||||
(void)fprintf(stderr, "\e[38;5;9m!!!!!!!! PRINT DUMP FAILED !!!!!!!!"
|
||||
"\e[0m\n");
|
||||
(void)PrintStatus(_);
|
||||
})
|
||||
|
||||
unsure(PrintStatus(dump[i]), !_.value, {
|
||||
(void)fprintf(stderr, "Unable to literalise.\n");
|
||||
})
|
||||
|
||||
// seek(PrintStatus(dump[i]), { // Get returning status.
|
||||
|
||||
// /* Handle TraditionalFunctionReturn. */
|
||||
// nest(_, __, unsure(__, !__.value, { // No bytes were written to buffer.
|
||||
// (void)fprintf(stderr, "Unable to literalise.\n");
|
||||
// return;
|
||||
// }));
|
||||
|
||||
// // Handle abnormal status.
|
||||
// nest(_, __, notok(__, {
|
||||
// /* Output the description as explanation. */
|
||||
// (void)fprintf(stderr, "%s\n", __.description);
|
||||
// return;
|
||||
// }));
|
||||
// });
|
||||
}
|
||||
}
|
||||
|
||||
// ========================================================
|
||||
|
||||
/* Throw the report created with $e if $e is abnormal, commented with $c. */
|
||||
# define ensure(e, c) { \
|
||||
Status stat = e; \
|
||||
solve(!(StatusUtils_IsOkay(stat)), { \
|
||||
Report rep = stamp(error(stat, c), (char *)__func__); \
|
||||
(void)throw(rep); \
|
||||
return ReportThrown; \
|
||||
}) \
|
||||
}
|
||||
|
||||
/* Throw the report created with $s if $e is abnormal, commented with $c. */
|
||||
# define match(s, e, c) { \
|
||||
Status stat = s; \
|
||||
solve(!(StatusUtils_IsOkay(e)), { \
|
||||
Report rep = stamp(error(stat, c), (char *)__func__); \
|
||||
(void)throw(rep); \
|
||||
return ReportThrown; \
|
||||
}) \
|
||||
}
|
||||
|
||||
/* Add location parameter requirement in order to give proper information
|
||||
* before throwing the report out. */
|
||||
# define throw(report) THROW(report, __HERE__)
|
||||
// # define throw(report) THROW(report, __HERE__)
|
||||
|
||||
/* Useless in C, only for human to see.
|
||||
Probably rewrite this in Classify. */
|
||||
# define throws(e)
|
||||
|
||||
ReportSendingTaskID THROW(Report report, Location loc);
|
||||
Report CATCH(ReportSendingTaskID taskid);
|
||||
// ReportTaskID THROW(Report report, Location loc);
|
||||
// Report CATCH(ReportTaskID taskid, Status (*handler)());
|
||||
int HANDLER(void *report);
|
||||
|
||||
#endif /* COMPOUND_STATUS_H */
|
||||
|
||||
@@ -2,30 +2,18 @@
|
||||
|
||||
Status Location_Literalise(Location *inst, char *buff)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(buff, apply(UnavailableBuffer));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(buff, apply(UnavailableBuffer));
|
||||
|
||||
/* Literalise line. */
|
||||
char line_buff[LITERALISATION_LENGTH_MAXIMUM];
|
||||
char line_buff[LITERALISATION_LENGTH_MAXIMUM] = EMPTY;
|
||||
Utils_LiteraliseInteger(inst->line, line_buff);
|
||||
|
||||
/* Concatenate every buff. */
|
||||
const long total_len = strlen(strnil(inst->file)) + strlen(strnil(line_buff))
|
||||
+ strlen(strnil(inst->func))
|
||||
+ LOCATION_LITERALISE_FORMAT_LENGTH;
|
||||
|
||||
state(total_len > LITERALISATION_LENGTH_MAXIMUM,
|
||||
apply(MaximumLiteralisationLengthExceeded));
|
||||
|
||||
/* Copy and assign. */
|
||||
// return value(UnknownStatus,
|
||||
// !sprintf(buff, LOCATION_LITERALISE_FORMAT,
|
||||
// inst->file, inst->line, inst->func));
|
||||
const int written =
|
||||
sprintf(buff, LOCATION_LITERALISE_FORMAT,inst->file,inst->line,inst->func);
|
||||
|
||||
// written in "value" is absolutely ZERO.
|
||||
state(!written, apply(value(UnknownStatus, written)));
|
||||
where(
|
||||
snprintf(buff, LITERALISATION_LENGTH_MAXIMUM,
|
||||
LOCATION_LITERALISE_FORMAT,inst->file,inst->line,inst->func),
|
||||
return apply(value(TraditionalFunctionReturn, _));
|
||||
);
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
@@ -56,12 +44,14 @@ bool Status_Equal(Status *stat1, Status *stat2)
|
||||
Status Status_Literalise(Status *inst, char *buff)
|
||||
{
|
||||
/* Skip unavailable instance and invalid parameter. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(buff, apply(UnavailableBuffer));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(buff, apply(UnavailableBuffer));
|
||||
|
||||
/* Literalise loc. */
|
||||
char loc_buff[LITERALISATION_LENGTH_MAXIMUM];
|
||||
notok(Location_Literalise(&inst->loc, loc_buff), {
|
||||
char loc_buff[LITERALISATION_LENGTH_MAXIMUM] = EMPTY;
|
||||
(void)printf("%s\n", loc_buff);
|
||||
unsure(Location_Literalise(&inst->loc, loc_buff), !_.value, {
|
||||
(void)printf("failed on loc liter.\n");
|
||||
return apply(_);
|
||||
});
|
||||
|
||||
@@ -80,13 +70,28 @@ Status Status_Literalise(Status *inst, char *buff)
|
||||
}
|
||||
|
||||
/* Concatenate every buffer. */
|
||||
where(sprintf(buff, fmt, inst->identity, inst->description,
|
||||
(!inst->prev
|
||||
? "(null)"
|
||||
: (inst->prev->identity)),
|
||||
inst->value, inst->characteristic, loc_buff), {
|
||||
where(
|
||||
snprintf(buff, LITERALISATION_LENGTH_MAXIMUM, fmt, inst->identity,
|
||||
inst->description,
|
||||
(!inst->prev ? "(null)" : (inst->prev->identity)),
|
||||
inst->value, inst->characteristic, loc_buff), {
|
||||
return apply(value(TraditionalFunctionReturn, _));
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
Status Status_LiteraliseForReport(Status *inst, char *buff)
|
||||
{
|
||||
/* Skip unavailable instance and invalid parameter. */
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(buff, apply(UnavailableBuffer));
|
||||
|
||||
where(
|
||||
snprintf(buff, LITERALISATION_LENGTH_MAXIMUM, REPORT_LITERALISE_FORMAT_DETAIL,
|
||||
strnil(inst->identity), strnil(inst->prev->identity),
|
||||
inst->value, inst->characteristic, inst->loc.file, inst->loc.line,
|
||||
inst->loc.func), {
|
||||
return apply(value(TraditionalFunctionReturn, _));
|
||||
});
|
||||
}
|
||||
|
||||
bool StatusUtils_HasPrev(Status stat)
|
||||
@@ -104,64 +109,96 @@ bool StatusUtils_IsRecursive(Status stat)
|
||||
return (stat.prev && stat.prev == &stat);
|
||||
}
|
||||
|
||||
void StatusUtils_Dump(Status *inst, Status *store, int idx)
|
||||
void StatusUtils_Dump(Status *inst, Status *store)
|
||||
{
|
||||
/* Skip when either stat or stat.prev is unavailable, or, idx is invalid. */
|
||||
svoid((!inst || !store || idx < 0));
|
||||
/* Skip when store is unavailable, or, inst is unavailable,
|
||||
recursive or does not have any predecessor. */
|
||||
svoid(!inst || !store
|
||||
|| StatusUtils_IsRecursive(*inst) || !StatusUtils_HasPrev(*inst));
|
||||
|
||||
store[idx] = *inst;
|
||||
|
||||
StatusUtils_Dump(inst->prev, store, ++idx);
|
||||
*store = *inst->prev;
|
||||
}
|
||||
|
||||
// void StatusUtils_Dump(Status *inst, Status **store, int idx)
|
||||
// {
|
||||
// /* Skip when having invalid inst, store or idx. */
|
||||
// svoid(!inst || !store || idx < 0 || StatusUtils_IsRecursive(*inst));
|
||||
|
||||
// // store[idx] = *inst;
|
||||
// *store[idx] = (Status){
|
||||
// .identity = inst->identity,
|
||||
// .value = inst->value,
|
||||
// .description = inst->description,
|
||||
// .characteristic = inst->characteristic,
|
||||
// .loc = inst->loc,
|
||||
// .prev = inst->prev
|
||||
// };
|
||||
|
||||
// (void)printf("idx: %d\n", idx);
|
||||
|
||||
// StatusUtils_Dump(inst->prev, store, (idx - 1));
|
||||
// }
|
||||
|
||||
int StatusUtils_Depth(Status *stat)
|
||||
{
|
||||
/* Skip unavailable stat. */
|
||||
state((!stat || !stat->prev), -1);
|
||||
|
||||
Status *p = stat; // Include this layer of Status.
|
||||
register int cnt;
|
||||
for (cnt = 0; (!StatusUtils_IsRecursive(*p)
|
||||
&& StatusUtils_HasPrev(*p)); cnt++) {
|
||||
p = p->prev;
|
||||
/* Set up counter. */
|
||||
int cnt = 1;
|
||||
/* Set up current status indication representor. */
|
||||
Status current = *stat;
|
||||
/* Iterate to accumulate. */
|
||||
while (current.prev) {
|
||||
current = *current.prev;
|
||||
cnt += 1;
|
||||
}
|
||||
|
||||
return cnt;
|
||||
|
||||
// Status *current = stat; // Include this layer of Status.
|
||||
// register int cnt;
|
||||
// for (cnt = 0; (!StatusUtils_IsRecursive(*current)
|
||||
// && StatusUtils_HasPrev(*current)); cnt++) {
|
||||
// current = current->prev;
|
||||
// }
|
||||
|
||||
// return cnt;
|
||||
}
|
||||
|
||||
Status Report_Create(Report *inst, Status *stat, FILE *dest, char *initiator,
|
||||
int priority)
|
||||
{
|
||||
/* Skip unavailable parameters. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(stat, apply(error(InvalidParameter, "Given stat was null.")));
|
||||
fails(initiator, apply(error(InvalidParameter, "Given initiator was null.")));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(stat, apply(error(InvalidParameter, "Given stat was null.")));
|
||||
nonull(initiator, apply(error(InvalidParameter, "Given initiator was null.")));
|
||||
state(priority < 0, apply(error(InvalidParameter, "Given priority was negative.")));
|
||||
|
||||
/* Copy and assign. */
|
||||
inst->status = *stat;
|
||||
inst->content = *stat;
|
||||
inst->initiator = calloc(strlen(initiator), sizeof(char));
|
||||
(void)strcpy(inst->initiator, initiator);
|
||||
inst->time = time(NULL);
|
||||
inst->priority = priority;
|
||||
inst->taskprint_status = REPORT_SENDING_TASK_STATUS_PENDING;
|
||||
inst->dest = (dest == NULL ? stdout : dest);
|
||||
inst->level = priority;
|
||||
inst->status = REPORT_SENDING_TASK_STATUS_PENDING;
|
||||
inst->dst = (dest == NULL ? stdout : dest);
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
|
||||
Status Report_CopyOf(Report *inst, Report *other)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(other, apply(error(InvalidParameter, "Given report is unavailable.")));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(other, apply(error(InvalidParameter, "Given report is unavailable.")));
|
||||
|
||||
// Status status;
|
||||
// char *initiator;
|
||||
// time_t time;
|
||||
// ReportSendingPriority priority;
|
||||
// ReportSendingTaskStatus taskprint_status;
|
||||
// ReportLevel priority;
|
||||
// ReportTaskStatus taskprint_status;
|
||||
// FILE *dest;
|
||||
inst->status = other->status;
|
||||
inst->content = other->content;
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
@@ -172,94 +209,98 @@ void Report_Delete(Report *inst)
|
||||
|
||||
free(inst->initiator);
|
||||
inst->initiator = NULL;
|
||||
inst->dest = NULL;
|
||||
inst->priority = 0;
|
||||
inst->status = (Status){};
|
||||
inst->taskprint_status = REPORT_SENDING_TASK_STATUS_NOTFOUND;
|
||||
inst->dst = NULL;
|
||||
inst->level = 0;
|
||||
inst->content = (Status){};
|
||||
inst->status = REPORT_SENDING_TASK_STATUS_NOTFOUND;
|
||||
inst->time = 0;
|
||||
inst = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
Status status;
|
||||
char *initiator;
|
||||
time_t time;
|
||||
ReportLevel priority;
|
||||
ReportTaskStatus taskprint_status;
|
||||
FILE *dest;
|
||||
*/
|
||||
Status Report_Literalise(Report *inst, char *buff)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(buff, apply(UnavailableBuffer));
|
||||
// state(strlen(buff) != LITERALISATION_LENGTH_MAXIMUM,
|
||||
// InvalidLiteralisingBuffer);
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(buff, apply(UnavailableBuffer));
|
||||
|
||||
/* Report literalisation. */
|
||||
int idx = 0;
|
||||
char report_literalising[LITERALISATION_LENGTH_MAXIMUM];
|
||||
char report_literalising[LITERALISATION_LENGTH_MAXIMUM] = EMPTY;
|
||||
|
||||
/** Status literalisation. **/
|
||||
char status_literalising[LITERALISATION_LENGTH_MAXIMUM];
|
||||
(void)Status_Literalise(&inst->status, status_literalising);
|
||||
idx += strlen(status_literalising);
|
||||
/** fin **/
|
||||
char status_literalising[LITERALISATION_LENGTH_MAXIMUM] = EMPTY;
|
||||
|
||||
/** Initiator literalisation. **/
|
||||
idx += strlen(inst->initiator);
|
||||
/** fin **/
|
||||
/* Fault detection on status literalisation. */
|
||||
// settle(Status_LiteraliseForReport(&inst->status, status_literalising),
|
||||
// _.characteristic == STATUS_UNKNOWN, {
|
||||
// nest(_, __, {
|
||||
// /* Skip when ZERO byte were written. (failed to write) */
|
||||
// state(!__.value, apply(
|
||||
// error(value(TraditionalFunctionReturn, __.value),
|
||||
// "ZERO byte were written.")
|
||||
// ));
|
||||
// })
|
||||
// });
|
||||
|
||||
/** Time literalisation. **/
|
||||
char time_literalising[LITERALISATION_LENGTH_MAXIMUM];
|
||||
idx += Utils_LiteraliseInteger(inst->time, time_literalising);
|
||||
/** fin **/
|
||||
/* Traditional function returning handling. */
|
||||
settle(Status_LiteraliseForReport(&inst->content, status_literalising),
|
||||
!_.value, {
|
||||
return apply(annot(RuntimeError, "Failed to literalise status for report."));
|
||||
});
|
||||
|
||||
/** Priority literalisation. **/
|
||||
char priority_literalising[LITERALISATION_LENGTH_MAXIMUM];
|
||||
idx += Utils_LiteraliseInteger(inst->priority, priority_literalising);
|
||||
/** fin **/
|
||||
/* Write result to buffer. */
|
||||
/* Write the report "header". */
|
||||
/* Literalise current time and date. */
|
||||
char datetime[LITERALISATION_LENGTH_MAXIMUM];
|
||||
// settle(strftime(datetime, 64, "%c", localtime(&inst->time)), )
|
||||
|
||||
/** Taskprint_status literalisation. **/
|
||||
char taskprint_status_literalising[LITERALISATION_LENGTH_MAXIMUM];
|
||||
idx += Utils_LiteraliseInteger(inst->taskprint_status, taskprint_status_literalising);
|
||||
/** fin **/
|
||||
// DATETIME [LEVEL] STATUS.IDENTITY (INITIATOR): STATUS.DESCRIPTION
|
||||
state(!snprintf(report_literalising, LITERALISATION_LENGTH_MAXIMUM,
|
||||
REPORT_LITERALISE_FORMAT_HEADER, datetime, inst->level,
|
||||
inst->content.identity, inst->initiator, inst->content.description),
|
||||
apply(annot(NoBytesWereWritten, "Failed to literalise date and time."))
|
||||
);
|
||||
|
||||
/** Dest literalisation. **/
|
||||
char dest_literalising[LITERALISATION_LENGTH_MAXIMUM];
|
||||
idx += Utils_LiteraliseInteger((long long int)inst->dest, dest_literalising);
|
||||
/** fin **/
|
||||
|
||||
if (idx >= LITERALISATION_LENGTH_MAXIMUM) {
|
||||
buff = NULL;
|
||||
return MaximumLiteralisationLengthExceeded;
|
||||
}
|
||||
|
||||
strcpy(report_literalising, status_literalising);
|
||||
strcpy(report_literalising, time_literalising);
|
||||
strcpy(report_literalising, priority_literalising);
|
||||
strcpy(report_literalising, taskprint_status_literalising);
|
||||
strcpy(report_literalising, dest_literalising);
|
||||
|
||||
strcpy(buff, report_literalising);
|
||||
/* fin */
|
||||
/* Write the report "detail". */
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
|
||||
/*
|
||||
thrd_t thread;
|
||||
Report report;
|
||||
time_t elapsed;
|
||||
ReportResult result;
|
||||
*/
|
||||
Status ReportSender_Create(ReportSender *inst, Report *report)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(report, error(UnavailableParameter, "Given report was unavailable."));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(report, error(UnavailableParameter, "Given report was unavailable."));
|
||||
|
||||
thrd_create(&inst->thread, &HANDLER, report);
|
||||
notok(Report_CopyOf(inst->report, report),
|
||||
return error(ErrorStatus, "Cannot copy to create new instance of report.");
|
||||
) // *inst->report = *report;
|
||||
notok(Report_CopyOf(&inst->report, report),
|
||||
return apply(annot(InstanceCreatingFailure,
|
||||
"Cannot copy to create new instance of report."));
|
||||
);
|
||||
inst->report = *report;
|
||||
inst->elapsed = 0;
|
||||
inst->result = REPORT_SENDER_RESULT_PENDING;
|
||||
inst->successful = false;
|
||||
inst->result = REPORT_RESULT_PENDING;
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
|
||||
Status ReportSender_Send(ReportSender *inst, ReportSendingTask task)
|
||||
Status ReportSender_Send(ReportSender *inst, ReportTask task)
|
||||
{
|
||||
// /* Skip when inst or task is unavailable. */
|
||||
// fails(inst,
|
||||
// nonull(inst,
|
||||
// error(UnavailableInstance, "Report sender was given unavailable."));
|
||||
// fails(task, InvalidReportTask);
|
||||
// nonull(task, InvalidReportTask);
|
||||
|
||||
// /* Assign for dest. */
|
||||
// const FILE *dest = (inst->report->dest == NULL ? stdout : inst->report->dest);
|
||||
@@ -284,7 +325,7 @@ Status ReportSender_Send(ReportSender *inst, ReportSendingTask task)
|
||||
// || (inst1->external_param == inst2->external_param);
|
||||
// }
|
||||
|
||||
ReportSendingTaskID THROW(Report report, Location loc)
|
||||
ReportTaskID THROW(Report report, Location loc)
|
||||
{
|
||||
// // /* Create new a instance of ReportSender. */
|
||||
// // ReportSender sender;
|
||||
|
||||
@@ -13,7 +13,11 @@ typedef enum {
|
||||
/* etc. */
|
||||
} StringEncoding;
|
||||
|
||||
typedef Array(Char) String;
|
||||
// typedef Array(Char) String;
|
||||
typedef struct {
|
||||
Array type(Char) data;
|
||||
StringEncoding encoding;
|
||||
} String;
|
||||
|
||||
/* Elementary. */
|
||||
Status String_Create(String *inst, int len);
|
||||
@@ -24,71 +28,75 @@ Status String_SetIdx(String *inst, Char *item, int index);
|
||||
Status String_Literalise(String *inst, String *store);
|
||||
|
||||
/* Extensional. */
|
||||
Status StringUtils_FromInteger(String *inst, int value);
|
||||
Status StringUtils_FromShortInteger(String *inst, short int value);
|
||||
Status StringUtils_FromLongInteger(String *inst, long int value);
|
||||
Status StringUtils_FromLongLongInteger(String *inst, long long int value);
|
||||
Status StringUtils_FromFloat(String *inst, float value);
|
||||
Status StringUtils_FromDouble(String *inst, double value);
|
||||
Status StringUtils_FromLongDouble(String *inst, long double value);
|
||||
Status StringUtils_FromComplexInteger(String *inst, _Complex int value);
|
||||
Status StringUtils_FromComplexShortInteger(String *inst, _Complex short int value);
|
||||
Status StringUtils_FromComplexLongInteger(String *inst, _Complex long int value);
|
||||
Status StringUtils_FromComplexLongLongInteger(String *inst, _Complex long long value);
|
||||
Status StringUtils_FromComplexFloat(String *inst, _Complex float value);
|
||||
Status StringUtils_FromComplexDouble(String *inst, _Complex double value);
|
||||
Status StringUtils_FromComplexLongDouble(String *inst, _Complex long double value);
|
||||
Status StringUtils_FromUnsignedInteger(String *inst, unsigned int value);
|
||||
Status StringUtils_FromUnsignedShortInteger(String *inst, unsigned short int value);
|
||||
Status StringUtils_FromUnsignedLongInteger(String *inst, unsigned long int value);
|
||||
Status StringUtils_FromUnsignedLongLongInteger(String *inst, unsigned long long int value);
|
||||
Status StringUtils_FromUnsignedComplexInteger(String *inst, unsigned _Complex int value);
|
||||
Status StringUtils_FromUnsignedComplexShortInteger(String *inst, unsigned _Complex short int value);
|
||||
Status StringUtils_FromUnsignedComplexLongInteger(String *inst, unsigned _Complex long int value);
|
||||
Status StringUtils_FromUnsignedComplexLongLongInteger(String *inst, unsigned _Complex long long value);
|
||||
Status StringUtils_FromInteger(String *inst, int value, int base);
|
||||
Status StringUtils_FromShortInteger(String *inst, short int value, int base);
|
||||
Status StringUtils_FromLongInteger(String *inst, long int value, int base);
|
||||
Status StringUtils_FromLongLongInteger(String *inst, long long int value, int base);
|
||||
Status StringUtils_FromFloat(String *inst, float value, int base);
|
||||
Status StringUtils_FromDouble(String *inst, double value, int base);
|
||||
Status StringUtils_FromLongDouble(String *inst, long double value, int base);
|
||||
Status StringUtils_FromComplexInteger(String *inst, _Complex int value, int base);
|
||||
Status StringUtils_FromComplexShortInteger(String *inst, _Complex short int value, int base);
|
||||
Status StringUtils_FromComplexLongInteger(String *inst, _Complex long int value, int base);
|
||||
Status StringUtils_FromComplexLongLongInteger(String *inst, _Complex long long value, int base);
|
||||
Status StringUtils_FromComplexFloat(String *inst, _Complex float value, int base);
|
||||
Status StringUtils_FromComplexDouble(String *inst, _Complex double value, int base);
|
||||
Status StringUtils_FromComplexLongDouble(String *inst, _Complex long double value, int base);
|
||||
Status StringUtils_FromUnsignedInteger(String *inst, unsigned int value, int base);
|
||||
Status StringUtils_FromUnsignedShortInteger(String *inst, unsigned short int value, int base);
|
||||
Status StringUtils_FromUnsignedLongInteger(String *inst, unsigned long int value, int base);
|
||||
Status StringUtils_FromUnsignedLongLongInteger(String *inst, unsigned long long int value, int base);
|
||||
Status StringUtils_FromUnsignedComplexInteger(String *inst, unsigned _Complex int value, int base);
|
||||
Status StringUtils_FromUnsignedComplexShortInteger(String *inst, unsigned _Complex short int value, int base);
|
||||
Status StringUtils_FromUnsignedComplexLongInteger(String *inst, unsigned _Complex long int value, int base);
|
||||
Status StringUtils_FromUnsignedComplexLongLongInteger(String *inst, unsigned _Complex long long value, int base);
|
||||
Status StringUtils_FromAddress(String *inst, void *store);
|
||||
Status StringUtils_FromCharBuff(String *inst, char const *buff, int base);
|
||||
Status StringUtils_FromWideCharBuff(String *inst, wchar_t const *wbuff, int base);
|
||||
Status StringUtils_ToInteger(String *inst, int *store);
|
||||
Status StringUtils_ToShortInteger(String *inst, short int *store);
|
||||
Status StringUtils_ToLongInteger(String *inst, long int *store);
|
||||
Status StringUtils_ToLongLongInteger(String *inst, long long int *store);
|
||||
Status StringUtils_ToFloat(String *inst, float *store);
|
||||
Status StringUtils_ToDouble(String *inst, double *store);
|
||||
Status StringUtils_ToLongDouble(String *inst, long double *store);
|
||||
Status StringUtils_ToComplexInteger(String *inst, _Complex int *store);
|
||||
Status StringUtils_ToComplexShortInteger(String *inst, _Complex short int *store);
|
||||
Status StringUtils_ToComplexLongInteger(String *inst, _Complex long int *store);
|
||||
Status StringUtils_ToComplexLongLongInteger(String *inst, _Complex long long *store);
|
||||
Status StringUtils_ToComplexFloat(String *inst, _Complex float *store);
|
||||
Status StringUtils_ToComplexDouble(String *inst, _Complex double *store);
|
||||
Status StringUtils_ToUnsignedInteger(String *inst, unsigned int *store);
|
||||
Status StringUtils_ToUnsignedShortInteger(String *inst, unsigned short int *store);
|
||||
Status StringUtils_ToUnsignedLongInteger(String *inst, unsigned long int *store);
|
||||
Status StringUtils_ToUnsignedLongLongInteger(String *inst, unsigned long long int *store);
|
||||
Status StringUtils_ToUnsignedComplexInteger(String *inst, unsigned _Complex int *store);
|
||||
Status StringUtils_ToUnsignedComplexShortInteger(String *inst, unsigned _Complex short int *store);
|
||||
Status StringUtils_ToUnsignedComplexLongInteger(String *inst, unsigned _Complex long int *store);
|
||||
Status StringUtils_ToUnsignedComplexLongLongInteger(String *inst, unsigned _Complex long long *store);
|
||||
Status StringUtils_FromCharBuff(String *inst, char const *buff);
|
||||
Status StringUtils_FromWideCharBuff(String *inst, wchar_t const *wbuff);
|
||||
Status StringUtils_ToInteger(String *inst, int *store, int base);
|
||||
Status StringUtils_ToShortInteger(String *inst, short int *store, int base);
|
||||
Status StringUtils_ToLongInteger(String *inst, long int *store, int base);
|
||||
Status StringUtils_ToLongLongInteger(String *inst, long long int *store, int base);
|
||||
Status StringUtils_ToFloat(String *inst, float *store, int base);
|
||||
Status StringUtils_ToDouble(String *inst, double *store, int base);
|
||||
Status StringUtils_ToLongDouble(String *inst, long double *store, int base);
|
||||
Status StringUtils_ToComplexInteger(String *inst, _Complex int *store, int base);
|
||||
Status StringUtils_ToComplexShortInteger(String *inst, _Complex short int *store, int base);
|
||||
Status StringUtils_ToComplexLongInteger(String *inst, _Complex long int *store, int base);
|
||||
Status StringUtils_ToComplexLongLongInteger(String *inst, _Complex long long *store, int base);
|
||||
Status StringUtils_ToComplexFloat(String *inst, _Complex float *store, int base);
|
||||
Status StringUtils_ToComplexDouble(String *inst, _Complex double *store, int base);
|
||||
Status StringUtils_ToUnsignedInteger(String *inst, unsigned int *store, int base);
|
||||
Status StringUtils_ToUnsignedShortInteger(String *inst, unsigned short int *store, int base);
|
||||
Status StringUtils_ToUnsignedLongInteger(String *inst, unsigned long int *store, int base);
|
||||
Status StringUtils_ToUnsignedLongLongInteger(String *inst, unsigned long long int *store, int base);
|
||||
Status StringUtils_ToUnsignedComplexInteger(String *inst, unsigned _Complex int *store, int base);
|
||||
Status StringUtils_ToUnsignedComplexShortInteger(String *inst, unsigned _Complex short int *store, int base);
|
||||
Status StringUtils_ToUnsignedComplexLongInteger(String *inst, unsigned _Complex long int *store, int base);
|
||||
Status StringUtils_ToUnsignedComplexLongLongInteger(String *inst, unsigned _Complex long long *store, int base);
|
||||
Status StringUtils_ToAddress(String *inst, void **store);
|
||||
Status StringUtils_ToCharBuff(String *inst, char const *buff, int base);
|
||||
Status StringUtils_ToWideCharBuff(String *inst, wchar_t const *wbuff, int base);
|
||||
Status StringUtils_Format(String *inst, const String *restrict fmt, ...);
|
||||
Status StringUtils_ToCharBuff(String *inst, char const *buff);
|
||||
Status StringUtils_ToWideCharBuff(String *inst, wchar_t const *wbuff);
|
||||
// Status StringUtils_Format(String *inst, const String *restrict fmt, ...);
|
||||
Status StringUtils_Tokenise(String *inst, const String *delim, String *store);
|
||||
Status String_Encode(String *inst, StringEncoding encoding)
|
||||
throws(UnsupportedEncoding EncodingError DecodingError);
|
||||
Status String_Decode(String *inst, StringEncoding encoding);
|
||||
throws(UnsupportedEncoding EncodingError DecodingError);
|
||||
Status String_Encode(String *inst, StringEncoding encoding) throws(UnsupportedEncoding EncodingError DecodingError);
|
||||
Status String_Decode(String *inst, StringEncoding encoding) throws(UnsupportedEncoding EncodingError DecodingError);
|
||||
int StringUtils_Compare(String *a, String *b);
|
||||
|
||||
static Status StringConversionPrecisionError = {
|
||||
.identity = nameof(StringConversionPrecisionError),
|
||||
.value = 1,
|
||||
.description = "Unpreventable precision loss was found during conversion "
|
||||
"between string and raw data.",
|
||||
.characteristic = STATUS_ERROR,
|
||||
.prev = &ImprecisionError
|
||||
.loc = __GLOBAL__,
|
||||
.prev = (Status *)&ImprecisionError
|
||||
};
|
||||
|
||||
// # define string(str) ((String) {\
|
||||
// .data =
|
||||
// })
|
||||
|
||||
typedef Array(int) InfiniteInteger;
|
||||
typedef Array(double) InfiniteFloatingPoint;
|
||||
typedef Array(_Complex double) InfintieComplex;
|
||||
|
||||
@@ -10,35 +10,35 @@ Status String_Create(String *inst, int len)
|
||||
|
||||
Status String_CopyOf(String *inst, String *other)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
|
||||
Status String_Delete(String *inst)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
|
||||
Status String_GetAt(String *inst, Char *store, int index)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
|
||||
Status String_SetAt(String *inst, Char *source, int index)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
|
||||
Status String_Literalise(String *inst, String *store)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
|
||||
0
Utils/include/function.c
Normal file
0
Utils/include/function.c
Normal file
34
Utils/include/function.h
Normal file
34
Utils/include/function.h
Normal file
@@ -0,0 +1,34 @@
|
||||
#ifndef FUNCTION_H
|
||||
# define FUNCTION_H
|
||||
|
||||
# include <Compound/string.h>
|
||||
|
||||
typedef Var Type;
|
||||
|
||||
typedef struct {
|
||||
attr(registered 1) Type type;
|
||||
|
||||
attr(nullity false) String identity;
|
||||
|
||||
attr(alignwith 1)
|
||||
attr(optional true) Type value;
|
||||
} Parameter;
|
||||
|
||||
typedef void * Block;
|
||||
|
||||
typedef struct {
|
||||
Type returns;
|
||||
Array type(Parameter) params;
|
||||
Var type(Block) body;
|
||||
} Function;
|
||||
|
||||
Status Function_Create(Function *inst, Type returns,
|
||||
Array type(Parameter) params, Var type(Block) body);
|
||||
Status Function_CopyOf(Function *inst, Function *other);
|
||||
Status Function_Delete(Function *inst);
|
||||
Status Function_Literalise(Function *inst, String *buff);
|
||||
Status Function_Overwrite(Function *inst, Function *other);
|
||||
bool Function_Equal(Function *inst, Function *other);
|
||||
bool FunctionUtils_IsVariadic(Function *inst);
|
||||
|
||||
#endif /* FUNCTION_H */
|
||||
57
Utils/include/test.c
Normal file
57
Utils/include/test.c
Normal file
@@ -0,0 +1,57 @@
|
||||
#include <Compound/array.h>
|
||||
#include <Compound/catlog.h>
|
||||
#include <Compound/common.h>
|
||||
#include <Compound/memman.h>
|
||||
#include <Compound/status.h>
|
||||
#include <Compound/var.h>
|
||||
|
||||
Status func(void)
|
||||
{
|
||||
return apply(
|
||||
error(ErrorStatus, "This function does not accept any parameters!"));
|
||||
}
|
||||
|
||||
__attribute__((constructor))
|
||||
void __CONSTRUCT__() {
|
||||
cat("Hello, Compound!\n");
|
||||
}
|
||||
|
||||
__attribute__((destructor))
|
||||
void __DESTRUCT__() {}
|
||||
|
||||
Status Main(void)
|
||||
{
|
||||
// Memory mem1;
|
||||
// seek(Memory_Create(&mem1, INT64_MAX), {
|
||||
// print_status(_);
|
||||
// });
|
||||
// seek(Memory_Allocate(&mem1), {
|
||||
// print_status(_);
|
||||
// });
|
||||
// seek(Memory_Allocate(&mem1), {
|
||||
// print_status(_);
|
||||
// });
|
||||
// seek(Memory_Release(&mem1), {
|
||||
// print_status(_);
|
||||
// });
|
||||
// seek(Memory_Release(&mem1), {
|
||||
// print_status(_);
|
||||
// });
|
||||
// seek(Memory_Delete(&mem1), {
|
||||
// print_status(_);
|
||||
// });
|
||||
|
||||
// PrintStatusDump(unknown(normal(MaximumLiteralisationLengthExceeded, ":O"), "OMGIDKWTD", 1));
|
||||
// PrintStatusDump(apply(extend(MaximumLiteralisationLengthExceeded, normal(UnavailableBuffer, "OMGIDKWTD"))));
|
||||
PrintStatusDump(MaximumLiteralisationLengthExceeded);
|
||||
|
||||
return apply(NormalStatus);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
return Main().value;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#ifndef COMPOUND_UTILS_H
|
||||
# define COMPOUND_UTILS_H
|
||||
|
||||
# include <time.h>
|
||||
# include <string.h>
|
||||
# include <stdlib.h>
|
||||
# include <math.h>
|
||||
# include <stdint.h>
|
||||
# include <string.h>
|
||||
# include <time.h>
|
||||
|
||||
# include <Compound/common.h>
|
||||
# include <Compound/const.h>
|
||||
@@ -19,6 +17,8 @@ int Utils_CalcDigits(long long int n);
|
||||
|
||||
int Utils_LiteraliseInteger(long long int n, char *buff);
|
||||
|
||||
int Utils_DateTimeLiteralise(time_t t, char *buff);
|
||||
// int Utils_DateTimeLiteralise(time_t t, char *buff);
|
||||
int Utils_DateTimeLiteralise(time_t timer, char *buff,
|
||||
const char *__restrict format);
|
||||
|
||||
#endif /* COMPOUND_UTILS_H */
|
||||
|
||||
@@ -42,8 +42,8 @@ int Utils_LiteraliseInteger(long long int n, char *buff)
|
||||
return literalising_len;
|
||||
}
|
||||
|
||||
int Utils_DateTimeLiteralise(time_t t, char *buff)
|
||||
int Utils_DateTimeLiteralise(time_t timer, char *buff,
|
||||
const char *__restrict format)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
Status Var_Create(Var *inst, size_t size)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
state(inst->alive, apply(InstanceStillAlive));
|
||||
state(!size,
|
||||
apply(normal(NormalStatus, "Exited with given parameter size as ZERO.")));
|
||||
@@ -17,9 +17,9 @@ Status Var_Create(Var *inst, size_t size)
|
||||
// Status Var_Create(Var *inst, void *addr, size_t size, char *identity)
|
||||
// {
|
||||
// /* Skip when inst is unavailable. */
|
||||
// fails(inst, apply(UnavailableInstance));
|
||||
// nonull(inst, apply(UnavailableInstance));
|
||||
// /* Skip when identity is unavailable. */
|
||||
// fails(identity, NullPointerAccounted);
|
||||
// nonull(identity, NullPointerAccounted);
|
||||
// /* Skip when identity does not pass the examine. */
|
||||
// state(!VarUtils_IsIdentityLegal(identity), IllegalVarIdentity);
|
||||
|
||||
@@ -33,9 +33,9 @@ Status Var_Create(Var *inst, size_t size)
|
||||
Status Var_CopyOf(Var *inst, Var *other)
|
||||
{
|
||||
/* Skip when inst or other is unavailable. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
state(inst->alive, apply(InstanceStillAlive));
|
||||
fails(other, apply(InvalidParameter));
|
||||
nonull(other, apply(InvalidParameter));
|
||||
|
||||
/* Copy members from other. Only has to apply size, no addr is needed. */
|
||||
state(!((inst->addr = malloc(other->size))), apply(InsufficientMemory));
|
||||
|
||||
4
attr.h
4
attr.h
@@ -3,8 +3,8 @@
|
||||
|
||||
# include <Compound/name.h>
|
||||
|
||||
typedef struct _Attribute{
|
||||
int serialNo;
|
||||
typedef struct _Attribute {
|
||||
Name identity; // Numeral accumulative, not literal descriptive.
|
||||
int (*exec)(void *);
|
||||
struct _Attribute *prev;
|
||||
} attr(Executive) Attribute;
|
||||
|
||||
22
catlog.c
22
catlog.c
@@ -7,7 +7,7 @@ Status CatlogMsg_Create(CatlogMsg *inst, CatlogLevel level,
|
||||
char *initiator, char *msg)
|
||||
{
|
||||
/* Skip unavailable instances and parameters. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
state((initiator == NULL || msg == NULL), apply(InvalidParameter));
|
||||
|
||||
inst->time = time(NULL);
|
||||
@@ -21,8 +21,8 @@ Status CatlogMsg_Create(CatlogMsg *inst, CatlogLevel level,
|
||||
Status CatlogMsg_CopyOf(CatlogMsg *inst, CatlogMsg *other)
|
||||
{
|
||||
/* Skip unavailable instances and parameters. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(other, apply(InvalidParameter));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(other, apply(InvalidParameter));
|
||||
|
||||
*inst = *other;
|
||||
|
||||
@@ -45,8 +45,8 @@ bool CatlogMsg_Equals(CatlogMsg *inst, CatlogMsg *other)
|
||||
Status CatlogSender_Create(CatlogSender *inst, CatlogMsg *msg, FILE *dst)
|
||||
{
|
||||
/* Skip unavailable instances and parameters. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(msg, apply(InvalidParameter));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(msg, apply(InvalidParameter));
|
||||
|
||||
/* Copy and assign. */
|
||||
inst->msg = *msg;
|
||||
@@ -60,8 +60,8 @@ Status CatlogSender_Create(CatlogSender *inst, CatlogMsg *msg, FILE *dst)
|
||||
Status CatlogSender_CopyOf(CatlogSender *inst, CatlogSender *other)
|
||||
{
|
||||
/* Skip unavailable instances and parameters. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(other, apply(InvalidParameter));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(other, apply(InvalidParameter));
|
||||
|
||||
/* Copy and assign */
|
||||
inst->msg = other->msg;
|
||||
@@ -89,7 +89,7 @@ bool CatlogSender_Equals(CatlogSender *inst, CatlogSender *other)
|
||||
Status CatlogSender_Send(CatlogSender *inst)
|
||||
{
|
||||
/* Skip unavailable instances and parameters. */
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
|
||||
const int written = fprintf(inst->dst, "%s\n", inst->msg.content);
|
||||
|
||||
@@ -103,9 +103,9 @@ Status CatlogUtils_OpenFile(FILE **fileptr, const char *filepath,
|
||||
const char const *restrict mode)
|
||||
{
|
||||
/* Skip unavailable instances and parameters. */
|
||||
fails(fileptr, apply(UnavailableBuffer));
|
||||
fails(filepath, apply(UnavailableFileName));
|
||||
fails(mode, apply(UnavailableFileAccessMode));
|
||||
nonull(fileptr, apply(UnavailableBuffer));
|
||||
nonull(filepath, apply(UnavailableFileName));
|
||||
nonull(mode, apply(UnavailableFileAccessMode));
|
||||
|
||||
/* Open the file. Return CatCannotOpenFile once failed. */
|
||||
state(!(*fileptr = fopen(filepath, mode)), apply(CatCannotOpenFile));
|
||||
|
||||
144
common.h
144
common.h
@@ -1,67 +1,102 @@
|
||||
#ifndef COMPOUND_COMMON_h
|
||||
# define COMPOUND_COMMON_h
|
||||
// # define __DEBUG__ 1
|
||||
#ifndef COMPOUND_COMMON_H
|
||||
# define COMPOUND_COMMON_H
|
||||
|
||||
# ifdef __DEBUG__
|
||||
# warning DEBUG IS ON
|
||||
# endif /* __DEBUG__ */
|
||||
|
||||
# include <stdlib.h>
|
||||
# include <stdbool.h>
|
||||
|
||||
# define EMPTY {0}
|
||||
|
||||
/* Get the literal. */
|
||||
# define nameof(obj) #obj
|
||||
|
||||
/* Return $n as the return value, once $o is NULL. */
|
||||
# define fails(o, n) { if (!o) return (n); }
|
||||
/* Return n as the return value, once o is NULL. */
|
||||
# define nonull(o, n) { if (!o) return (n); }
|
||||
|
||||
/* Return $e as the return value, once $v equals $e. */
|
||||
/* Return e as the return value, once v equals e. */
|
||||
# define trans(v, e) { if ((v) == (e)) return (e); }
|
||||
|
||||
/* Evaluate given statement while the ptr to $s is not NULL. */
|
||||
/* Evaluate given statement while the ptr to s is not NULL. */
|
||||
# define state(s, n) { if ((s)) return (n); }
|
||||
|
||||
/* Evaluate given statement while the ptr to $s is not NULL. */
|
||||
/* Evaluate given statement while the ptr to s is not NULL. */
|
||||
# define svoid(s) { if ((s)) return; }
|
||||
|
||||
/* Another way to handle if statements more cleanly. */
|
||||
# define solve(s, b) { if (s) b }
|
||||
|
||||
/* Handling expression with its result. */
|
||||
# define when(expr, b) { int _ = expr; if (expr) b }
|
||||
# define when(expr, b) { int _ = expr; if (_) b }
|
||||
|
||||
/* Handling expression with its calculated result. */
|
||||
/* Handling expression with its precalculated result. */
|
||||
# define where(expr, b) { int _ = expr; b }
|
||||
|
||||
/* Execute b whenever finds s is "okay". */
|
||||
# define ok(s, b) { Status _ = s; if (StatusUtils_IsOkay(_)) b }
|
||||
|
||||
/* Execute b whenever finds s is "NOT okay". */
|
||||
# define notok(s, b) { Status _ = s; if (!StatusUtils_IsOkay(_)) b }
|
||||
|
||||
/* Return e when passing a failing e commented with c. */
|
||||
# define fails(e, c) { notok(e, return apply(annot(_, c));) }
|
||||
|
||||
/* Return v when passing a failing e. */
|
||||
# define vfail(e, v) { notok(e, return v;) }
|
||||
|
||||
/* Execute b for handling UnknownStatus (TraditionalFunctionReturn). */
|
||||
# define unsure(s, expr, b) { Status _ = s; \
|
||||
if (_.characteristic < 0 && (expr)) b }
|
||||
|
||||
/* Execute b whatsoever with s stored. */
|
||||
# define seek(s, b) { Status _ = s; b }
|
||||
|
||||
/* Combinates seek and solve. */
|
||||
# define settle(e, s, b) seek(e, solve(s, b))
|
||||
|
||||
/* Clone a new varaible "v2" with "v1". */
|
||||
# define clone(v1, v2) __typeof__(v1) v2 = v1;
|
||||
|
||||
/* Allows different macros using "_" nested with each other. */
|
||||
# define nest(v1, v2, b) { clone(v1, v2) b }
|
||||
|
||||
// # define lambda(param, body, capfmt, ...) {\
|
||||
// /* Duplicate everything from cap. */\
|
||||
// va_list ptr;\
|
||||
// va_start(ptr, capfmt);\
|
||||
// __typeof__(ptr) \
|
||||
// va_end(ptr);\
|
||||
// }
|
||||
|
||||
/* Create a new UnknownStatus on the fly. */
|
||||
# define unknown(e, c, v) ((Status) {\
|
||||
.identity = e.identity,\
|
||||
.identity = nameof(e),\
|
||||
.value = v,\
|
||||
.description = c,\
|
||||
.characteristic = STATUS_UNKNOWN,\
|
||||
.loc = __HERE__,\
|
||||
.loc = e.loc,\
|
||||
.prev = e.prev\
|
||||
})
|
||||
|
||||
/* Create a new NormalStatus on the fly. */
|
||||
# define normal(e, c) ((Status) {\
|
||||
.identity = e.identity,\
|
||||
.identity = nameof(e),\
|
||||
.value = 0,\
|
||||
.description = c,\
|
||||
.characteristic = STATUS_NORMAL,\
|
||||
.loc = __HERE__,\
|
||||
.loc = e.loc,\
|
||||
.prev = e.prev\
|
||||
})
|
||||
|
||||
/* Create a new ErrorStatus on the fly. */
|
||||
# define error(e, c) ((Status) {\
|
||||
.identity = e.identity,\
|
||||
.identity = nameof(e),\
|
||||
.value = e.value,\
|
||||
.description = c,\
|
||||
.characteristic = STATUS_ERROR,\
|
||||
.loc = __HERE__,\
|
||||
.loc = e.loc,\
|
||||
.prev = e.prev\
|
||||
})
|
||||
|
||||
@@ -71,7 +106,7 @@
|
||||
.value = p.value,\
|
||||
.description = e.description,\
|
||||
.characteristic = p.characteristic,\
|
||||
.loc = __HERE__,\
|
||||
.loc = p.loc,\
|
||||
.prev = (Status *)&p\
|
||||
})
|
||||
|
||||
@@ -80,7 +115,7 @@
|
||||
.value = v,\
|
||||
.description = e.description,\
|
||||
.characteristic = e.characteristic,\
|
||||
.loc = __HERE__,\
|
||||
.loc = e.loc,\
|
||||
.prev = (Status *)e.prev\
|
||||
})
|
||||
|
||||
@@ -93,13 +128,24 @@
|
||||
.prev = (Status *)e.prev\
|
||||
})
|
||||
|
||||
/* Create a report in place with $e for base and $c for initiator literal. */
|
||||
# define stamp(e, c) ((Report) {\
|
||||
.status = e,\
|
||||
.initiator = c,\
|
||||
// Reannotate for e.
|
||||
# define annot(e, c) ((Status) {\
|
||||
.identity = e.identity,\
|
||||
.value = e.value,\
|
||||
.description = c,\
|
||||
.characteristic = e.characteristic,\
|
||||
.loc = e.loc,\
|
||||
.prev = (Status *)e.prev\
|
||||
})
|
||||
|
||||
/* Create a report on the fly. */
|
||||
# define stamp(e, ini) ((Report) {\
|
||||
.content = e,\
|
||||
.initiator = ini,\
|
||||
.time = time(NULL),\
|
||||
.priority = REPORT_SENDING_PRIORITY_NORMAL,\
|
||||
.taskprint_status = REPORT_SENDING_TASK_STATUS_PENDING\
|
||||
.level = REPORT_SENDING_PRIORITY_NORMAL,\
|
||||
.status = REPORT_SENDING_TASK_STATUS_PENDING,\
|
||||
.dst = stdout\
|
||||
})
|
||||
|
||||
# define cat(s) {\
|
||||
@@ -110,45 +156,6 @@
|
||||
CatlogSender_Send(&sender);\
|
||||
}
|
||||
|
||||
// /**
|
||||
// * @brief Forcibly return desired value $v once $s is not $k.
|
||||
// * @return $v once state for $s is false.
|
||||
// * @note "force" stands for "Forcible value"
|
||||
// * @note 's' stands for "Statement"
|
||||
// * @note 'k' stands for "Key Value", the value that is targeted to detect.
|
||||
// * @note 'v' stands for "Desire Value", the value that desires.
|
||||
// */
|
||||
// # define force(s, k, v) solve((s) != (k), v)
|
||||
|
||||
// # define sforce(s, k, v) solve((!Status_Equal(s, k)), v)
|
||||
|
||||
// # define print_status(s) {\
|
||||
// Status _ = s;\
|
||||
// char buff[LITERALISATION_LENGTH_MAXIMUM];\
|
||||
// notok(Status_Literalise(&_, buff), {\
|
||||
// (void)printf("Failed to literalise a status\n");\
|
||||
// });\
|
||||
// (void)printf("%s\n", buff);\
|
||||
// }
|
||||
|
||||
// # define print_status(s) {\
|
||||
// char buff[LITERALISATION_LENGTH_MAXIMUM];\
|
||||
// (void)Status_Literalise(&s, buff);\
|
||||
// (void)fprintf(stderr, "%s\n", buff);\
|
||||
// }
|
||||
|
||||
// # define print_statusdump(s) {\
|
||||
// Status _ = s;\
|
||||
// const int dump_len = StatusUtils_Depth(&_);\
|
||||
// Status dump[dump_len];\
|
||||
// StatusUtils_Dump(&_, dump, 0);\
|
||||
// for (register int i = 0; i < dump_len; i++) {\
|
||||
// /* TODO(william): Replace following line with coloured-term-output function. */\
|
||||
// (void)printf("\e[1m[%d/%d]\e[0m\n", i, dump_len - 1);\
|
||||
// print_status(dump[i]);\
|
||||
// }\
|
||||
// }
|
||||
|
||||
# define strnil(s) (!s ? ("(null)") : s)
|
||||
|
||||
# define type(T)
|
||||
@@ -175,10 +182,10 @@ typedef struct {
|
||||
Coordination end;
|
||||
} Selection;
|
||||
|
||||
typedef struct {
|
||||
void *addr;
|
||||
size_t sz;
|
||||
} MemoryInst;
|
||||
// typedef struct {
|
||||
// void *addr;
|
||||
// size_t sz;
|
||||
// } MemoryInst;
|
||||
|
||||
typedef Coordination ArrayIndexerRange;
|
||||
typedef bool _Bit;
|
||||
@@ -193,7 +200,6 @@ typedef bool _Bit;
|
||||
|
||||
# define LITERALISATION_LENGTH_MAXIMUM 0xFFFFL
|
||||
|
||||
|
||||
/* Only effect (probably) when formal Attribute is defined.
|
||||
* __ATTRIBUTABLE indicates this field is used for further process by Attribute.
|
||||
* Or, to put this way, this field has attributions not used so far, but
|
||||
@@ -203,4 +209,4 @@ typedef bool _Bit;
|
||||
# define __ATTRIBUTABLE__
|
||||
# define attr(a)
|
||||
|
||||
#endif /* NO COMPOUND_COMMON_h */
|
||||
#endif /* COMPOUND_COMMON_H */
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
Status NameScope_Create(NameScope *inst)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
|
||||
/* Create instances for members from inst. */
|
||||
state(StatusUtils_IsOkay(NameScope_EmptyName(&inst->latest)),
|
||||
@@ -17,8 +17,8 @@ Status NameScope_Create(NameScope *inst)
|
||||
|
||||
Status NameScope_CopyOf(NameScope *inst, NameScope *other)
|
||||
{
|
||||
fails(inst, apply(UnavailableInstance));
|
||||
fails(other, apply(UnavailableParameter));
|
||||
nonull(inst, apply(UnavailableInstance));
|
||||
nonull(other, apply(UnavailableParameter));
|
||||
|
||||
/* Copy and assign. */
|
||||
other->latest = inst->latest;
|
||||
|
||||
Reference in New Issue
Block a user