//
// MATLAB Compiler: 3.0
// Date: Tue Mar 29 17:47:22 2005
// Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
// "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
// "array_indexing:on" "-O" "optimize_conditionals:on" "-B" "sglcpp" "-p" "-W"
// "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
// "libmwsglm.mlib" "smssend" 
//
#include "unitable.hpp"
#include "libmatlbm.hpp"
static mwArray _mxarray0_ = mclInitializeDouble(7445.0);
static mwArray _mxarray1_ = mclInitializeDouble(2.0);
static mwArray _mxarray2_ = mclInitializeDouble(1.0);

static mxChar _array4_[10] = { 'G', 'B', '2', '3', '1',
                               '2', '.', 'T', 'X', 'T' };
static mwArray _mxarray3_ = mclInitializeString(10, _array4_);

static mxChar _array6_[2] = { 'r', 't' };
static mwArray _mxarray5_ = mclInitializeString(2, _array6_);

static mxChar _array8_[1] = { '#' };
static mwArray _mxarray7_ = mclInitializeString(1, _array8_);

static mxChar _array10_[2] = { '%', 'x' };
static mwArray _mxarray9_ = mclInitializeString(2, _array10_);

void InitializeModule_unitable() {
}

void TerminateModule_unitable() {
}

static mwArray Munitable(int nargout_);

_mexLocalFunctionTable _local_function_table_unitable
  = { 0, (mexFunctionTableEntry *)NULL };

//
// The function "unitable" contains the normal interface for the "unitable"
// M-function from file "h:\matlab65\work\shouji\unitable.m" (lines 1-19). This
// function processes any input arguments and passes them to the implementation
// version of the function, appearing above.
//
mwArray unitable() {
    int nargout = 1;
    mwArray uni = mwArray::UNDEFINED;
    uni = Munitable(nargout);
    return uni;
}

//
// The function "mlxUnitable" contains the feval interface for the "unitable"
// M-function from file "h:\matlab65\work\shouji\unitable.m" (lines 1-19). The
// feval function calls the implementation version of unitable through this
// function. This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
void mlxUnitable(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mplhs[1];
        mclCppUndefineArrays(1, mplhs);
        if (nlhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: unitable Line: 1 Column: "
                  "1 The function \"unitable\" was called with mor"
                  "e than the declared number of outputs (1).")));
        }
        if (nrhs > 0) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: unitable Line: 1 Column: "
                  "1 The function \"unitable\" was called with mor"
                  "e than the declared number of inputs (0).")));
        }
        mplhs[0] = Munitable(nlhs);
        plhs[0] = mplhs[0].FreezeData();
    }
    MW_END_MLX();
}

//
// The function "Munitable" is the implementation version of the "unitable"
// M-function from file "h:\matlab65\work\shouji\unitable.m" (lines 1-19). It
// contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function uni=unitable
//
static mwArray Munitable(int nargout_) {
    mwLocalFunctionTable save_local_function_table_
      = &_local_function_table_unitable;
    mwArray uni = mwArray::UNDEFINED;
    mwArray ans = mwArray::UNDEFINED;
    mwArray x = mwArray::UNDEFINED;
    mwArray s = mwArray::UNDEFINED;
    mwArray fin = mwArray::UNDEFINED;
    mwArray i = mwArray::UNDEFINED;
    //
    // uni=zeros(7445,2);
    //
    uni = zeros(mwVarargin(_mxarray0_, _mxarray1_));
    //
    // i=1;
    //
    i = _mxarray2_;
    //
    // fin=fopen('GB2312.TXT','rt');
    //
    fin = fopen(_mxarray3_, _mxarray5_);
    //
    // while 1
    //
    for (;;) {
        //
        // s=fgets(fin);
        //
        s = fgets(mwVv(fin, "fin"));
        //
        // if(feof(fin))
        //
        if (tobool(feof(mwVv(fin, "fin")))) {
            //
            // break;
            //
            break;
        //
        // end
        //
        }
        //
        // 
        // if s(1)=='#'
        //
        if (mclEqBool(mclIntArrayRef(mwVv(s, "s"), 1), _mxarray7_)) {
            //
            // continue;
            //
            continue;
        //
        // end
        //
        }
        //
        // 
        // x=sscanf(s,'%x',2);
        //
        x = sscanf(mwVv(s, "s"), _mxarray9_, _mxarray1_);
        //
        // uni(i,:)=x';
        //
        mclArrayAssign(&uni, ctranspose(mwVv(x, "x")), mwVv(i, "i"), colon());
        //
        // i=i+1;
        //
        i = mwVv(i, "i") + _mxarray2_;
    //
    // end
    //
    }
    //
    // fclose(fin);
    //
    ans.EqAns(fclose(mwVv(fin, "fin")));
    mwValidateOutput(uni, 1, nargout_, "uni", "unitable");
    return uni;
}