reckon.h

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Raven Computing
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

 
#pragma once
 
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
 
#include "reckon_export.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define RECKON_NUM_SUPPORTED_FORMATS 21

#define RECKON_MK_FRMT_OPT(frmt) (1ULL << (frmt))

#define RECKON_ENV_VAR_DEBUG "RECKON_DEBUG"

typedef enum RcnTextFormat {

    RCN_TEXT_UNFORMATTED,

    RCN_TEXT_MARKDOWN,

    RCN_TEXT_XML,

    RCN_TEXT_FXML,

    RCN_TEXT_JSON,

    RCN_TEXT_CSS,

    RCN_TEXT_HTML,

    RCN_TEXT_SQL,

    RCN_TEXT_CMAKE,

    RCN_TEXT_MAKE,

    RCN_TEXT_YAML,

    RCN_LANG_ASSEMBLY,

    RCN_LANG_C,

    RCN_LANG_JAVA,

    RCN_LANG_PYTHON,

    RCN_LANG_CPP,

    RCN_LANG_JAVASCRIPT,

    RCN_LANG_TYPESCRIPT,

    RCN_LANG_R,

    RCN_LANG_BATCH,

    RCN_LANG_BASH,
 
} RcnTextFormat;

typedef enum RcnErrorCode {

    RCN_ERR_NONE,

    RCN_ERR_UNSUPPORTED_FORMAT,

    RCN_ERR_INVALID_INPUT,

    RCN_ERR_INPUT_TOO_LARGE,

    RCN_ERR_SYNTAX_ERROR,

    RCN_ERR_ALLOC_FAILURE,

    RCN_ERR_UNKNOWN
 
} RcnErrorCode;

typedef struct RcnResultState {

    RcnErrorCode errorCode;

    const char* errorMessage;

    bool ok;
 
} RcnResultState;

typedef uint64_t RcnCount;

typedef struct RcnCountResult {

    RcnCount count;

    RcnResultState state;
 
} RcnCountResult;

typedef struct RcnCountResultGroup {

    RcnCount logicalLines;

    RcnCount codeLines;

    RcnCount physicalLines;

    RcnCount words;

    RcnCount characters;

    RcnCount sourceSize;

    RcnResultState state;

    bool isProcessed;

    bool hasLogicalLines;

    bool hasCodeLines;
 
} RcnCountResultGroup;

typedef struct RcnSourceText {

    char* text;

    size_t size;
 
} RcnSourceText;

typedef enum RcnFileOpStatus {

    RCN_FILE_OP_OK,

    RCN_FILE_OP_INVALID_PATH,

    RCN_FILE_OP_FILE_NOT_FOUND,

    RCN_FILE_OP_IO_ERROR,

    RCN_FILE_OP_ALLOC_FAILURE,

    RCN_FILE_OP_FILE_TOO_LARGE,

    RCN_FILE_OP_UNKNOWN_ERROR
 
} RcnFileOpStatus;

typedef struct RcnSourceFile {

    char* path;

    char* name;

    char* extension;

    RcnSourceText content;

    bool isContentRead;

    bool ignore;

    RcnFileOpStatus status;
 
} RcnSourceFile;

typedef struct RcnSourceFormatDetection {

    RcnTextFormat format;

    bool isSupportedFormat;
 
} RcnSourceFormatDetection;

typedef struct RcnCountResultSet {

    RcnSourceFile* files;

    RcnCountResultGroup* results;

    size_t size;

    size_t sizeProcessed;
 
} RcnCountResultSet;

typedef struct RcnCountStatistics {

    RcnCount totalLogicalLines;

    RcnCount totalCodeLines;

    RcnCount totalPhysicalLines;

    RcnCount totalWords;

    RcnCount totalCharacters;

    RcnCount totalSourceSize;

    RcnCount logicalLines[RECKON_NUM_SUPPORTED_FORMATS];

    RcnCount codeLines[RECKON_NUM_SUPPORTED_FORMATS];

    RcnCount physicalLines[RECKON_NUM_SUPPORTED_FORMATS];

    RcnCount words[RECKON_NUM_SUPPORTED_FORMATS];

    RcnCount characters[RECKON_NUM_SUPPORTED_FORMATS];

    RcnCount sourceSize[RECKON_NUM_SUPPORTED_FORMATS];

    RcnCountResultSet count;

    RcnResultState state;
 
} RcnCountStatistics;

typedef enum RcnCountOption {

    RCN_OPT_COUNT_CHARACTERS = 0x01,

    RCN_OPT_COUNT_WORDS = 0x02,

    RCN_OPT_COUNT_PHYSICAL_LINES = 0x04,

    RCN_OPT_COUNT_LOGICAL_LINES = 0x08,

    RCN_OPT_COUNT_CODE_LINES = 0x10,
 
} RcnCountOption;

typedef enum RcnFormatOption {

    RCN_OPT_TEXT_UNFORMATTED = RECKON_MK_FRMT_OPT(RCN_TEXT_UNFORMATTED),

    RCN_OPT_TEXT_MARKDOWN = RECKON_MK_FRMT_OPT(RCN_TEXT_MARKDOWN),

    RCN_OPT_TEXT_XML = RECKON_MK_FRMT_OPT(RCN_TEXT_XML),

    RCN_OPT_TEXT_FXML = RECKON_MK_FRMT_OPT(RCN_TEXT_FXML),

    RCN_OPT_TEXT_JSON = RECKON_MK_FRMT_OPT(RCN_TEXT_JSON),

    RCN_OPT_TEXT_CSS = RECKON_MK_FRMT_OPT(RCN_TEXT_CSS),

    RCN_OPT_TEXT_HTML = RECKON_MK_FRMT_OPT(RCN_TEXT_HTML),

    RCN_OPT_TEXT_SQL = RECKON_MK_FRMT_OPT(RCN_TEXT_SQL),
   
    RCN_OPT_TEXT_CMAKE = RECKON_MK_FRMT_OPT(RCN_TEXT_CMAKE),

    RCN_OPT_TEXT_MAKE = RECKON_MK_FRMT_OPT(RCN_TEXT_MAKE),

    RCN_OPT_TEXT_YAML = RECKON_MK_FRMT_OPT(RCN_TEXT_YAML),

    RCN_OPT_LANG_ASSEMBLY = RECKON_MK_FRMT_OPT(RCN_LANG_ASSEMBLY),

    RCN_OPT_LANG_C = RECKON_MK_FRMT_OPT(RCN_LANG_C),

    RCN_OPT_LANG_JAVA = RECKON_MK_FRMT_OPT(RCN_LANG_JAVA),

    RCN_OPT_LANG_PYTHON = RECKON_MK_FRMT_OPT(RCN_LANG_PYTHON),

    RCN_OPT_LANG_CPP = RECKON_MK_FRMT_OPT(RCN_LANG_CPP),

    RCN_OPT_LANG_JAVASCRIPT = RECKON_MK_FRMT_OPT(RCN_LANG_JAVASCRIPT),

    RCN_OPT_LANG_TYPESCRIPT = RECKON_MK_FRMT_OPT(RCN_LANG_TYPESCRIPT),

    RCN_OPT_LANG_R = RECKON_MK_FRMT_OPT(RCN_LANG_R),

    RCN_OPT_LANG_BATCH = RECKON_MK_FRMT_OPT(RCN_LANG_BATCH),

    RCN_OPT_LANG_BASH = RECKON_MK_FRMT_OPT(RCN_LANG_BASH),
 
} RcnFormatOption;

typedef struct RcnStatOptions {

    uint32_t operations;

    uint32_t formats;

    bool stopOnError;

    bool keepFileContent;

    bool strict;

    bool useMultiThreading;
 
} RcnStatOptions;

RECKON_EXPORT RcnCountStatistics* rcnCreateCountStatistics(const char* path);

RECKON_EXPORT RcnCountStatistics* rcnAllocCountStatistics(size_t size);

RECKON_EXPORT void rcnFreeCountStatistics(RcnCountStatistics* stats);

RECKON_EXPORT void rcnCount(RcnCountStatistics* stats, RcnStatOptions options);

RECKON_EXPORT RcnCountResult rcnCountLogicalLines(
    RcnTextFormat language,
    RcnSourceText sourceCode
);

RECKON_EXPORT RcnCountResult rcnCountLogicalLinesStrict(
    RcnTextFormat language,
    RcnSourceText sourceCode
);

RECKON_EXPORT RcnSourceText rcnMarkLogicalLinesInFile(const char* path);

RECKON_EXPORT RcnSourceText rcnMarkLogicalLinesInSourceText(
    RcnTextFormat language,
    RcnSourceText sourceCode
);

RECKON_EXPORT void rcnFreeSourceText(RcnSourceText* source);

RECKON_EXPORT RcnCountResult rcnCountLinesOfCode(
    RcnTextFormat language,
    RcnSourceText sourceCode
);

RECKON_EXPORT RcnCountResult rcnCountPhysicalLines(RcnSourceText source);

RECKON_EXPORT RcnCountResult rcnCountWords(RcnSourceText source);

RECKON_EXPORT RcnCountResult rcnCountCharacters(RcnSourceText source);

RECKON_EXPORT RcnSourceFormatDetection rcnDetectSourceFormat(
    const RcnSourceFile* file
);

RECKON_EXPORT const char* rcnGetTextFormatLabel(RcnTextFormat format);

RECKON_EXPORT bool rcnIsLlcCountingSupported(RcnTextFormat format);

RECKON_EXPORT bool rcnIsLocCountingSupported(RcnTextFormat format);
 
#ifdef __cplusplus
}
#endif