dmtxencodescheme.c

Go to the documentation of this file.

 
#include <assert.h>
 
#include "dmtx.h"
#include "dmtxstatic.h"
 
/* Verify stream is using expected scheme */
#define CHKSCHEME(s)                                            \
    {                                                           \
        if (stream->currentScheme != (s)) {                     \
            streamMarkFatal(stream, DmtxErrorUnexpectedScheme); \
            return;                                             \
        }                                                       \
    }
 
/* CHKERR should follow any call that might alter stream status */
#define CHKERR                                      \
    {                                               \
        if (stream->status != DmtxStatusEncoding) { \
            return;                                 \
        }                                           \
    }
 
/* CHKSIZE should follows typical calls to findSymbolSize()  */
#define CHKSIZE                                          \
    {                                                    \
        if (sizeIdx == DmtxUndefined) {                  \
            streamMarkInvalid(stream, DmtxErrorUnknown); \
            return;                                      \
        }                                                \
    }
 
static int encodeSingleScheme(DmtxByteList *input, DmtxByteList *output, int sizeIdxRequest, DmtxScheme scheme,
                              int fnc1)
{
    DmtxEncodeStream stream;
 
    stream = streamInit(input, output);
    stream.fnc1 = fnc1;
 
    /* 1st FNC1 special case, encode before scheme switch */
    if (fnc1 != DmtxUndefined && (int)(input->b[0]) == fnc1) {
        streamInputAdvanceNext(&stream);
        appendValueAscii(&stream, DmtxValueFNC1);
    }
 
    /* Continue encoding until complete */
    while (stream.status == DmtxStatusEncoding) {
        encodeNextChunk(&stream, scheme, DmtxEncodeNormal, sizeIdxRequest);
    }
 
    /* Verify encoding completed and all inputs were consumed */
    if (stream.status != DmtxStatusComplete || streamInputHasNext(&stream)) {
        return DmtxUndefined;
    }
 
    return stream.sizeIdx;
}
 
static void encodeNextChunk(DmtxEncodeStream *stream, int scheme, int option, int sizeIdxRequest)
{
    /* Special case: Prevent X12 from entering state with no way to unlatch */
    if (stream->currentScheme != DmtxSchemeX12 && scheme == DmtxSchemeX12) {
        if (partialX12ChunkRemains(stream)) {
            scheme = DmtxSchemeAscii;
        }
    }
 
    /* Change to target scheme if necessary */
    if (stream->currentScheme != scheme) {
        encodeChangeScheme(stream, scheme, DmtxUnlatchExplicit);
        CHKERR;
        CHKSCHEME(scheme);
    }
 
    /* Special case: Edifact may be done before writing first word */
    if (scheme == DmtxSchemeEdifact) {
        completeIfDoneEdifact(stream, sizeIdxRequest);
    }
    CHKERR;
 
    switch (stream->currentScheme) {
        case DmtxSchemeAscii:
            encodeNextChunkAscii(stream, option);
            CHKERR;
            completeIfDoneAscii(stream, sizeIdxRequest);
            CHKERR;
            break;
        case DmtxSchemeC40:
        case DmtxSchemeText:
        case DmtxSchemeX12:
            encodeNextChunkCTX(stream, sizeIdxRequest);
            CHKERR;
            completeIfDoneCTX(stream, sizeIdxRequest);
            CHKERR;
            break;
        case DmtxSchemeEdifact:
            encodeNextChunkEdifact(stream);
            CHKERR;
            completeIfDoneEdifact(stream, sizeIdxRequest);
            CHKERR;
            break;
        case DmtxSchemeBase256:
            encodeNextChunkBase256(stream);
            CHKERR;
            completeIfDoneBase256(stream, sizeIdxRequest);
            CHKERR;
            break;
        default:
            streamMarkFatal(stream, DmtxErrorUnknown);
            break;
    }
}
 
static void encodeChangeScheme(DmtxEncodeStream *stream, DmtxScheme targetScheme, int unlatchType)
{
    /* Nothing to do */
    if (stream->currentScheme == targetScheme) {
        return;
    }
 
    /* Every latch must go through ASCII */
    switch (stream->currentScheme) {
        case DmtxSchemeC40:
        case DmtxSchemeText:
        case DmtxSchemeX12:
            if (unlatchType == DmtxUnlatchExplicit) {
                appendUnlatchCTX(stream);
                CHKERR;
            }
            break;
        case DmtxSchemeEdifact:
            if (unlatchType == DmtxUnlatchExplicit) {
                appendValueEdifact(stream, DmtxValueEdifactUnlatch);
                CHKERR;
            }
            break;
        default:
            /* Nothing to do for ASCII or Base 256 */
            DmtxAssert(stream->currentScheme == DmtxSchemeAscii || stream->currentScheme == DmtxSchemeBase256);
            break;
    }
    stream->currentScheme = DmtxSchemeAscii;
 
    /* Anything other than ASCII (the default) requires a latch */
    switch (targetScheme) {
        case DmtxSchemeC40:
            appendValueAscii(stream, DmtxValueC40Latch);
            CHKERR;
            break;
        case DmtxSchemeText:
            appendValueAscii(stream, DmtxValueTextLatch);
            CHKERR;
            break;
        case DmtxSchemeX12:
            appendValueAscii(stream, DmtxValueX12Latch);
            CHKERR;
            break;
        case DmtxSchemeEdifact:
            appendValueAscii(stream, DmtxValueEdifactLatch);
            CHKERR;
            break;
        case DmtxSchemeBase256:
            appendValueAscii(stream, DmtxValueBase256Latch);
            CHKERR;
            break;
        default:
            /* Nothing to do for ASCII */
            CHKSCHEME(DmtxSchemeAscii);
            break;
    }
    stream->currentScheme = targetScheme;
 
    /* Reset new chain length to zero */
    stream->outputChainWordCount = 0;
    stream->outputChainValueCount = 0;
 
    /* Insert header byte if just latched to Base256 */
    if (targetScheme == DmtxSchemeBase256) {
        updateBase256ChainHeader(stream, DmtxUndefined);
        CHKERR;
    }
}
 
static int getRemainingSymbolCapacity(int outputLength, int sizeIdx)
{
    int capacity;
    int remaining;
 
    if (sizeIdx == DmtxUndefined) {
        remaining = DmtxUndefined;
    } else {
        capacity = dmtxGetSymbolAttribute(DmtxSymAttribSymbolDataWords, sizeIdx);
        remaining = capacity - outputLength;
    }
 
    return remaining;
}