//
// 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 "smssend.hpp"
#include "mwservices.h"
#include "libmatlbm.hpp"
#include "libmwsglm.hpp"
#include "unitable.hpp"

static mxChar _array1_[13] = { 0xcae4, 0xc8eb, 0xb6cc, 0xcffb, 0xcfa2, '(',
                               '7', '0', 0xb8f6, 0xbaba, 0xd7d6, ')', 0xa3ba };
static mwArray _mxarray0_ = mclInitializeString(13, _array1_);

static mxChar _array3_[3] = { 'S', 'M', 'S' };
static mwArray _mxarray2_ = mclInitializeString(3, _array3_);
static mwArray _mxarray4_ = mclInitializeDouble(1.0);

static mxChar _array6_[7] = { 0xb6cc, 0xcffb, 0xcfa2,
                              0xb9fd, 0xb3a4, 0x005c, 'n' };
static mwArray _mxarray5_ = mclInitializeString(7, _array6_);

static mxChar _array8_[16] = { 0xcae4, 0xc8eb, 0xb6d4, 0xb7bd, 0xb5e7,
                               0xbbb0, 0xbac5, 0xc2eb, '(', '1', '1',
                               0xcebb, 0xcafd, 0xd7d6, ')', 0xa3ba };
static mwArray _mxarray7_ = mclInitializeString(16, _array8_);

static mxChar _array10_[10] = { 0xb5e7, 0xbbb0, 0xbac5, 0xc2eb, 0xb3a4,
                                0xb6c8, 0xb2bb, 0xb6d4, 0x005c, 'n' };
static mwArray _mxarray9_ = mclInitializeString(10, _array10_);

static mxChar _array12_[2] = { '8', '6' };
static mwArray _mxarray11_ = mclInitializeString(2, _array12_);

static mxChar _array14_[1] = { 'F' };
static mwArray _mxarray13_ = mclInitializeString(1, _array14_);
static mwArray _mxarray15_ = mclInitializeDouble(2.0);
static mwArray _mxarray16_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
static mwArray _mxarray17_ = mclInitializeDouble(127.0);
static mwArray _mxarray18_ = mclInitializeDouble(32896.0);

static mxChar _array20_[22] = { '0', '0', '1', '1', '0', '0', '0', 'D',
                                '9', '1', '%', 's', '0', '0', '0', '8',
                                'A', 'A', '%', '0', '2', 'X' };
static mwArray _mxarray19_ = mclInitializeString(22, _array20_);

static mxChar _array22_[4] = { '%', '0', '4', 'X' };
static mwArray _mxarray21_ = mclInitializeString(4, _array22_);

static mxChar _array24_[4] = { 'c', 'o', 'm', '1' };
static mwArray _mxarray23_ = mclInitializeString(4, _array24_);

static mxChar _array26_[10] = { 'T', 'e', 'r', 'm', 'i',
                                'n', 'a', 't', 'o', 'r' };
static mwArray _mxarray25_ = mclInitializeString(10, _array26_);

static mxChar _array28_[2] = { 'C', 'R' };
static mwArray _mxarray27_ = mclInitializeString(2, _array28_);

static mxChar _array30_[7] = { 'T', 'i', 'm', 'e', 'o', 'u', 't' };
static mwArray _mxarray29_ = mclInitializeString(7, _array30_);
static mwArray _mxarray31_ = mclInitializeDouble(3.0);

static mxChar _array33_[9] = { 'A', 'T', '+', 'C', 'M', 'G', 'F', '=', '0' };
static mwArray _mxarray32_ = mclInitializeString(9, _array33_);

static mxChar _array35_[10] = { 'A', 'T', '+', 'C', 'M',
                                'G', 'F', '=', '%', 'd' };
static mwArray _mxarray34_ = mclInitializeString(10, _array35_);

static mxChar _array37_[6] = { '%', 's', 0x005c, 'x', 'l', 'a' };
static mwArray _mxarray36_ = mclInitializeString(6, _array37_);

void InitializeModule_smssend() {
}

void TerminateModule_smssend() {
}

static void Msmssend();

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

//
// The function "smssend" contains the normal interface for the "smssend"
// M-function from file "h:\matlab65\work\shouji\smssend.m" (lines 1-52). This
// function processes any input arguments and passes them to the implementation
// version of the function, appearing above.
//
void smssend() {
    Msmssend();
}

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

//
// The function "Msmssend" is the implementation version of the "smssend"
// M-function from file "h:\matlab65\work\shouji\smssend.m" (lines 1-52). 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 smssend
//
static void Msmssend() {
    mwLocalFunctionTable save_local_function_table_
      = &_local_function_table_smssend;
    mwArray cmd = mwArray::UNDEFINED;
    mwArray s = mwArray::UNDEFINED;
    mwArray serial = mwArray::UNDEFINED;
    mwArray sms = mwArray::UNDEFINED;
    mwArray n = mwArray::UNDEFINED;
    mwArray i = mwArray::UNDEFINED;
    mwArray uni = mwArray::UNDEFINED;
    mwArray gb = mwArray::UNDEFINED;
    mwArray p = mwArray::UNDEFINED;
    mwArray phone = mwArray::UNDEFINED;
    mwArray ans = mwArray::UNDEFINED;
    mwArray msg = mwArray::UNDEFINED;
    mwArray gut = mwArray::UNDEFINED;
    //
    // gut=unitable;
    //
    gut = unitable();
    //
    // msg=inputdlg('輸入短消息(70個漢字)：','SMS');
    //
    msg = Ninputdlg(1, _mxarray0_, _mxarray2_);
    //
    // msg=msg{1};
    //
    msg = mwVv(msg, "msg").cell(_mxarray4_);
    //
    // if length(msg)>1000
    //
    if (mclLengthInt(mwVv(msg, "msg")) > 1000) {
        //
        // fprintf('短消息過長\n');
        //
        ans.EqAns(Nfprintf(0, _mxarray5_, mwVarargin()));
        //
        // return;
        //
        goto return_;
    //
    // end
    //
    }
    //
    // phone=inputdlg('輸入對方電話號碼(11位數字)：','SMS');
    //
    phone = Ninputdlg(1, _mxarray7_, _mxarray2_);
    //
    // phone=phone{1};
    //
    phone = mwVv(phone, "phone").cell(_mxarray4_);
    //
    // if length(phone)~=11
    //
    if (mclLengthInt(mwVv(phone, "phone")) != 11) {
        //
        // fprintf('電話號碼長度不對\n');
        //
        ans.EqAns(Nfprintf(0, _mxarray9_, mwVarargin()));
        //
        // return;
        //
        goto return_;
    //
    // end
    //
    }
    //
    // phone=['86' phone 'F'];
    //
    phone = horzcat(mwVarargin(_mxarray11_, mwVv(phone, "phone"), _mxarray13_));
    //
    // p=phone;
    //
    p = mwVv(phone, "phone");
    //
    // p(1:2:end-1)=phone(2:2:end);
    //
    mclArrayAssign(
      &p,
      mclArrayRef(
        mwVv(phone, "phone"),
        colon(
          _mxarray15_,
          _mxarray15_,
          end(mwVv(phone, "phone"), _mxarray4_, _mxarray4_))),
      colon(
        _mxarray4_,
        _mxarray15_,
        end(mwVv(p, "p"), _mxarray4_, _mxarray4_) - _mxarray4_));
    //
    // p(2:2:end)=phone(1:2:end-1);
    //
    mclArrayAssign(
      &p,
      mclArrayRef(
        mwVv(phone, "phone"),
        colon(
          _mxarray4_,
          _mxarray15_,
          end(mwVv(phone, "phone"), _mxarray4_, _mxarray4_) - _mxarray4_)),
      colon(
        _mxarray15_, _mxarray15_, end(mwVv(p, "p"), _mxarray4_, _mxarray4_)));
    //
    // 
    // gb=double(msg);
    //
    gb = double_func(mwVv(msg, "msg"));
    //
    // uni=gb;
    //
    uni = mwVv(gb, "gb");
    //
    // for i=1:length(gb)
    //
    {
        int v_ = mclForIntStart(1);
        int e_ = mclLengthInt(mwVv(gb, "gb"));
        if (v_ > e_) {
            i = _mxarray16_;
        } else {
            //
            // if gb(i)>127
            // n=find(gb(i)-32896==gut(:,1));
            // uni(i)=gut(n,2);
            // end
            // end
            //
            for (; ; ) {
                if (mclGtBool(
                      mclIntArrayRef(mwVv(gb, "gb"), v_), _mxarray17_)) {
                    n
                      = find(
                          mclIntArrayRef(mwVv(gb, "gb"), v_) - _mxarray18_
                          == mclArrayRef(
                               mwVv(gut, "gut"), colon(), _mxarray4_));
                    mclIntArrayAssign(
                      &uni,
                      mclArrayRef(mwVv(gut, "gut"), mwVv(n, "n"), _mxarray15_),
                      v_);
                }
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            i = v_;
        }
    }
    //
    // 
    // sms=sprintf('0011000D91%s0008AA%02X',p,2*length(uni));
    //
    sms
      = sprintf(
          _mxarray19_,
          mwVarargin(
            mwVv(p, "p"),
            svDoubleScalarTimes(
              2.0, (double) mclLengthInt(mwVv(uni, "uni")))));
    //
    // uni=sprintf('%04X',uni);
    //
    uni = sprintf(_mxarray21_, mwVarargin(mwVv(uni, "uni")));
    //
    // sms=[sms uni];
    //
    sms = horzcat(mwVarargin(mwVv(sms, "sms"), mwVv(uni, "uni")));
    //
    // 
    // s=serial('com1','Terminator','CR','Timeout',3);
    //
    s
      = mwVv(serial, "serial")(
          _mxarray23_, _mxarray25_, _mxarray27_, _mxarray29_, _mxarray31_);
    //
    // fopen(s);
    //
    ans.EqAns(fopen(mwVv(s, "s")));
    //
    // try
    //
    try {
        //
        // cmd='AT+CMGF=0';
        //
        cmd = _mxarray32_;
        //
        // fprintf(s,cmd)
        //
        ans.EqPrintAns(Nfprintf(0, mwVv(s, "s"), mwVarargin(mwVv(cmd, "cmd"))));
    //
    // catch
    //
    } catch(mwException e_) {
    //
    // end
    //
    }
    //
    // 
    // try
    //
    try {
        //
        // cmd=sprintf('AT+CMGF=%d',length(sms)/2-1);
        //
        cmd
          = sprintf(
              _mxarray34_,
              mwVarargin(
                svDoubleScalarMinus(
                  svDoubleScalarRdivide(
                    (double) mclLengthInt(mwVv(sms, "sms")), 2.0),
                  1.0)));
        //
        // fprintf(s,cmd)
        //
        ans.EqPrintAns(Nfprintf(0, mwVv(s, "s"), mwVarargin(mwVv(cmd, "cmd"))));
    //
    // catch
    //
    } catch(mwException e_) {
    //
    // end
    //
    }
    //
    // 
    // try
    //
    try {
        //
        // cmd=sprintf('%s\xla',sms);
        //
        cmd = sprintf(_mxarray36_, mwVarargin(mwVv(sms, "sms")));
        //
        // fprintf(s,cmd);
        //
        ans.EqAns(Nfprintf(0, mwVv(s, "s"), mwVarargin(mwVv(cmd, "cmd"))));
    //
    // catch
    //
    } catch(mwException e_) {
    //
    // end
    //
    }
    //
    // fclose(s)
    //
    ans.EqPrintAns(fclose(mwVv(s, "s")));
    return_:;
}