error C1004

[jonatan]

Hello All,

I am making a program and need the grt_main.c but i try to compile have the error c1004.Please help me how to solve it?
Thank you.
--------------------Configuration: pre - Win32 Debug--------------------
Compiling...
pre.c
c:\matlab6p5\wo rk\penat\grt_ma in.c(661) : fatal error C1004: unexpected end of file found
Error executing cl.exe.

This code grt_main.c :

/* $Revision: 1.68 $
* Copyright 1994-2002 The MathWorks, Inc.
*
* File : grt_main.c
*
* Abstract:
* A Generic "Real-Time (single tasking or pseudo-multitasking,
* statically allocated data)" main that runs under most
* operating systems.
*
* This file may be a useful starting point when targeting a new
* processor or microcontroller .
*
*
* Compiler specified defines:
* RT - Required.
* MODEL=modelname - Required.
* NUMST=# - Required. Number of sample times.
* NCSTATES=# - Required. Number of continuous states.
* TID01EQ=1 or 0 - Optional. Only define to 1 if sample time task
* id's 0 and 1 have equal rates.
* MULTITASKING - Optional. (use MT for a synonym).
* SAVEFILE - Optional (non-quoted) name of .mat file to create.
* Default is <MODEL>.mat
* BORLAND - Required if using Borland C/C++
*/

#include <float.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "tmwtypes.h "
#include "rtmodel.h"
#include "rt_sim.h"
#include "rt_logging .h"
#include "rt_nonfinite.h "
#include "rt_mxclassid.h "

/*#include "stdafx.h"*/



/* Signal Handler header */
#ifdef BORLAND
#include <signal.h>
#include <float.h>
#endif

#include "ext_work.h "

/*=========*
* Defines *
*=========*/

#ifndef TRUE
#define FALSE (0)
#define TRUE (1)
#endif

#ifndef EXIT_FAILURE
#define EXIT_FAILURE 1
#endif
#ifndef EXIT_SUCCESS
#define EXIT_SUCCESS 0
#endif

#define QUOTE1(name) #name
#define QUOTE(name) QUOTE1(name) /* need to expand name */


#ifndef __RT_SIM__
#define __RT_SIM__

#ifndef RT
# error "must define RT"
#endif

#ifndef MODEL
# error "must define MODEL"
#endif

#ifndef NUMST
# error "must define number of sample times, NUMST"
#endif

#ifndef NCSTATES
# error "must define NCSTATES"
#endif

#ifndef SAVEFILE
# define MATFILE2(file) #file ".mat"
# define MATFILE1(file) MATFILE2(file)
# define MATFILE MATFILE1(MODEL)
#else
# define MATFILE QUOTE(SAVEFILE)
#endif

#define RUN_FOREVER -1.0

#define EXPAND_CONCAT(n ame1,name2) name1 ## name2
#define CONCAT(name1,na me2) EXPAND_CONCAT(n ame1,name2)
#define RT_MODEL CONCAT(MODEL,_r tModel)

/*============== ======*
* External functions *
*============== ======*/
extern RT_MODEL *MODEL(void);

extern void MdlInitializeSi zes(void);
extern void MdlInitializeSa mpleTimes(void) ;
extern void MdlStart(void);
extern void MdlOutputs(int_ T tid);
extern void MdlUpdate(int_T tid);
extern void MdlTerminate(vo id);

#if NCSTATES > 0
extern void rt_ODECreateInt egrationData(RT WSolverInfo *si);
extern void rt_ODEUpdateCon tinuousStates(R TWSolverInfo *si);

# define rt_CreateIntegr ationData(S) \
rt_ODECreateInt egrationData(rt mGetRTWSolverIn fo(S));
# define rt_UpdateContin uousStates(S) \
rt_ODEUpdateCon tinuousStates(r tmGetRTWSolverI nfo(S));
# else
# define rt_CreateIntegr ationData(S) \
rtsiSetSolverNa me(rtmGetRTWSol verInfo(S),"Fix edStepDiscrete" );
# define rt_UpdateContin uousStates(S) \
rtmSetT(S, rtsiGetSolverSt opTime(rtmGetRT WSolverInfo(S)) );
#endif


/*============== =============== =====*
* Global data local to this module *
*============== =============== =====*/

static struct {
int_T stopExecutionFl ag;
int_T isrOverrun;
int_T overrunFlags[NUMST];
const char_T *errmsg;
} GBLbuf;


#ifdef EXT_MODE
# define rtExtModeSingle TaskUpload(S) \
{ \
int stIdx; \
rtExtModeUpload CheckTrigger(); \
for (stIdx=0; stIdx<NUMST; stIdx++) { \
if (rtmIsSampleHit (S, stIdx, 0 /*unused*/)) { \
rtExtModeUpload (stIdx,rtmGetTa skTime(S,stIdx) ); \
} \
} \
}
#else
# define rtExtModeSingle TaskUpload(S) /* Do nothing */
#endif

/*============== ===*
* Local functions *
*============== ===*/

#ifdef BORLAND
/* Implemented for BC++ only*/

typedef void (*fptr)(int, int);

/* Function: divideByZero =============== =============== =============== ========
*
* Abstract: Traps the error Division by zero and prints a warning
* Also catches other FP errors, but does not identify them
* specifically.
*/
void divideByZero(in t sigName, int sigType)
{
signal(SIGFPE, (fptr)divideByZ ero);
if ((sigType == FPE_ZERODIVIDE) ||(sigType == FPE_INTDIV0)){
printf("*** Warning: Division by zero\n\n");
return;
}
else{
printf("*** Warning: Floating Point error\n\n");
return;
}
} /* end divideByZero */

#endif /* BORLAND */

#if !defined(MULTIT ASKING) /* SINGLETASKING */

/* Function: rtOneStep =============== =============== =============== ===========
*
* Abstract:
* Perform one step of the model. This function is modeled such that
* it could be called from an interrupt service routine (ISR) with minor
* modifications.
*/
static void rt_OneStep(RT_M ODEL *S)
{
real_T tnext;

/*************** *************** *************** **
* Check and see if base step time is too fast *
*************** *************** *************** **/

if (GBLbuf.isrOver run++) {
GBLbuf.stopExec utionFlag = 1;
return;
}

/*************** *************** *************** **
* Check and see if error status has been set *
*************** *************** *************** **/

if (rtmGetErrorSta tus(S) != NULL) {
GBLbuf.stopExec utionFlag = 1;
return;
}

/* enable interrupts here */

rtExtModeOneSte p(rtmGetRTWExtM odeInfo(S),
(boolean_T *)&rtmGetStopRe quested(S));

tnext = rt_SimGetNextSa mpleHit();
rtsiSetSolverSt opTime(rtmGetRT WSolverInfo(S), tnext);

MdlOutputs(0);

rtExtModeSingle TaskUpload(S);

GBLbuf.errmsg = rt_UpdateTXYLog Vars(rtmGetRTWL ogInfo(S),
rtmGetTPtr(S));
if (GBLbuf.errmsg != NULL) {
GBLbuf.stopExec utionFlag = 1;
return;
}

MdlUpdate(0);
rt_SimUpdateDis creteTaskSample Hits(rtmGetNumS ampleTimes(S),
rtmGetTimingDat a(S),
rtmGetSampleHit Ptr(S),
rtmGetTPtr(S));

if (rtmGetSampleTi me(S,0) == CONTINUOUS_SAMP LE_TIME) {
rt_UpdateContin uousStates(S);
}

GBLbuf.isrOverr un--;

rtExtModeCheckE ndTrigger();

} /* end rtOneStep */

#else /* MULTITASKING */

# if TID01EQ == 1
# define FIRST_TID 1
# else
# define FIRST_TID 0
# endif

/* Function: rtOneStep =============== =============== =============== ===========
*
* Abstract:
* Perform one step of the model. This function is modeled such that
* it could be called from an interrupt service routine (ISR) with minor
* modifications.
*
* This routine is modeled for use in a multitasking environment and
* therefore needs to be fully re-entrant when it is called from an
* interrupt service routine.
*
* Note:
* Error checking is provided which will only be used if this routine
* is attached to an interrupt.
*
*/
static void rt_OneStep(RT_M ODEL *S)
{
int_T eventFlags[NUMST];
int_T i;
real_T tnext;
int_T *sampleHit = rtmGetSampleHit Ptr(S);

/*************** *************** *************** **
* Check and see if base step time is too fast *
*************** *************** *************** **/

if (GBLbuf.isrOver run++) {
GBLbuf.stopExec utionFlag = 1;
return;
}

/*************** *************** *************** **
* Check and see if error status has been set *
*************** *************** *************** **/

if (rtmGetErrorSta tus(S) != NULL) {
GBLbuf.stopExec utionFlag = 1;
return;
}
/* enable interrupts here */

rtExtModeOneSte p(rtmGetRTWExtM odeInfo(S),
(boolean_T *)&rtmGetStopRe quested(S));

/*************** *************** *************** *************** ************
* Update discrete events and buffer event flags locally so that ISR is *
* re-entrant. *
*************** *************** *************** *************** ************/

tnext = rt_SimUpdateDis creteEvents(rtm GetNumSampleTim es(S),
rtmGetTimingDat a(S),
rtmGetSampleHit Ptr(S),
rtmGetPerTaskSa mpleHitsPtr(S)) ;
rtsiSetSolverSt opTime(rtmGetRT WSolverInfo(S), tnext);
for (i=FIRST_TID+1; i < NUMST; i++) {
eventFlags[i] = sampleHit[i];
}

/*************** *************** *************
* Step the model for the base sample time *
*************** *************** *************/

MdlOutputs(FIRS T_TID);

rtExtModeUpload CheckTrigger();
rtExtModeUpload (FIRST_TID,rtmG etTaskTime(S, FIRST_TID));

GBLbuf.errmsg = rt_UpdateTXYLog Vars(rtmGetRTWL ogInfo(S),
rtmGetTPtr(S));
if (GBLbuf.errmsg != NULL) {
GBLbuf.stopExec utionFlag = 1;
return;
}

MdlUpdate(FIRST _TID);

if (rtmGetSampleTi me(S,0) == CONTINUOUS_SAMP LE_TIME) {
rt_UpdateContin uousStates(S);
}
else {
rt_SimUpdateDis creteTaskTime(r tmGetTPtr(S),
rtmGetTimingDat a(S), 0);
}

#if FIRST_TID == 1
rt_SimUpdateDis creteTaskTime(r tmGetTPtr(S),
rtmGetTimingDat a(S),1);
#endif


/*************** *************** *************** *************** ************
* Model step complete for base sample time, now it is okay to *
* re-interrupt this ISR. *
*************** *************** *************** *************** ************/

GBLbuf.isrOverr un--;


/*************** *************** ***************
* Step the model for any other sample times *
*************** *************** ***************/

for (i=FIRST_TID+1; i<NUMST; i++) {
if (eventFlags[i]) {
if (GBLbuf.overrun Flags[i]++) { /* Are we sampling too fast for */
GBLbuf.stopExec utionFlag=1; /* sample time "i"? */
return;
}

MdlOutputs(i);

rtExtModeUpload (i, rtmGetTaskTime( S,i));

MdlUpdate(i);

rt_SimUpdateDis creteTaskTime(r tmGetTPtr(S),
rtmGetTimingDat a(S),i);

/* Indicate task complete for sample time "i" */
GBLbuf.overrunF lags[i]--;
}
}

rtExtModeCheckE ndTrigger();

} /* end rtOneStep */

#endif /* MULTITASKING */


static void displayUsage (void)
{
(void) printf("usage: %s -tf <finaltime> -w -port <TCPport>\n",QU OTE(MODEL));
(void) printf("argumen ts:\n");
(void) printf(" -tf <finaltime> - overrides final time specified in "
"Simulink (inf for no limit).\n");
(void) printf(" -w - waits for Simulink to start model "
"in External Mode.\n");
(void) printf(" -port <TCPport> - overrides 17725 default port in "
"External Mode, valid range 256 to 65535.\n");
}

/*============== =====*
* Visible functions *
*============== =====*/


/* Function: main =============== =============== =============== =============== =
*
* Abstract:
* Execute model on a generic target such as a workstation.
*/
int_T main(int_T argc, const char_T *argv[])
{
RT_MODEL *S;
const char *status;
real_T finaltime = -2.0;

int_T oldStyle_argc;
const char_T *oldStyle_argv[5];

/*************** ***************
* MathError Handling for BC++ *
*************** ***************/
#ifdef BORLAND
signal(SIGFPE, (fptr)divideByZ ero);
#endif

/*************** ****
* Parse arguments *
*************** ****/

if ((argc > 1) && (argv[1][0] != '-')) {
/* old style */
if ( argc > 3 ) {
displayUsage();
exit(EXIT_FAILU RE);
}

oldStyle_argc = 1;
oldStyle_argv[0] = argv[0];

if (argc >= 2) {
oldStyle_argc = 3;

oldStyle_argv[1] = "-tf";
oldStyle_argv[2] = argv[1];
}

if (argc == 3) {
oldStyle_argc = 5;

oldStyle_argv[3] = "-port";
oldStyle_argv[4] = argv[2];

}

argc = oldStyle_argc;
argv = oldStyle_argv;

}

{
/* new style: */
double tmpDouble;
char_T tmpStr2[200];
int_T count = 1;
int_T parseError = FALSE;

/*
* Parse the standard RTW parameters. Let all unrecognized parameters
* pass through to external mode for parsing. NULL out all args handled
* so that the external mode parsing can ignore them.
*/
while(count < argc) {
const char_T *option = argv[count++];

/* final time */
if ((strcmp(option , "-tf") == 0) && (count != argc)) {
const char_T *tfStr = argv[count++];

sscanf(tfStr, "%200s", tmpStr2);
if (strcmp(tmpStr2 , "inf") == 0) {
tmpDouble = RUN_FOREVER;
} else {
char_T tmpstr[2];

if ( (sscanf(tmpStr2 ,"%lf%1s", &tmpDouble, tmpstr) != 1) ||
(tmpDouble < 0.0) ) {
(void)printf("f inaltime must be a positive, real value or inf\n");
parseError = TRUE;
break;
}
}
finaltime = (real_T) tmpDouble;

argv[count-2] = NULL;
argv[count-1] = NULL;
}
}

if (parseError) {
(void)printf("\ nUsage: %s -option1 val1 -option2 val2 -option3 "
"...\n\n", QUOTE(MODEL));
(void)printf("\ t-tf 20 - sets final time to 20 seconds\n");

exit(EXIT_FAILU RE);
}

rtExtModeParseA rgs(argc, argv, NULL);

/*
* Check for unprocessed ("unhandled" ) args.
*/
{
int i;
for (i=1; i<argc; i++) {
if (argv[i] != NULL) {
printf("Unexpec ted command line argument: %s\n",argv[i]);
exit(EXIT_FAILU RE);
}
}
}
}

/*************** *************
* Initialize global memory *
*************** *************/
(void)memset(&G BLbuf, 0, sizeof(GBLbuf)) ;

/*************** *********
* Initialize the model *
*************** *********/
rt_InitInfAndNa N(sizeof(real_T ));

S = MODEL();
if (rtmGetErrorSta tus(S) != NULL) {
(void)fprintf(s tderr,"Error during model registration: %s\n",
rtmGetErrorStat us(S));
exit(EXIT_FAILU RE);
}
if (finaltime >= 0.0 || finaltime == RUN_FOREVER) rtmSetTFinal(S, finaltime);

MdlInitializeSi zes();
MdlInitializeSa mpleTimes();

status = rt_SimInitTimin gEngine(rtmGetN umSampleTimes(S ),
rtmGetStepSize( S),
rtmGetSampleTim ePtr(S),
rtmGetOffsetTim ePtr(S),
rtmGetSampleHit Ptr(S),
rtmGetSampleTim eTaskIDPtr(S),
rtmGetTStart(S) ,
&rtmGetSimTimeS tep(S),
&rtmGetTimingDa ta(S));

if (status != NULL) {
(void)fprintf(s tderr,
"Failed to initialize sample time engine: %s\n", status);
exit(EXIT_FAILU RE);
}
rt_CreateIntegr ationData(S);

GBLbuf.errmsg = rt_StartDataLog ging(rtmGetRTWL ogInfo(S),
rtmGetTFinal(S) ,
rtmGetStepSize( S),
&rtmGetErrorSta tus(S));
if (GBLbuf.errmsg != NULL) {
(void)fprintf(s tderr,"Error starting data logging: %s\n",GBLbuf.er rmsg);
return(EXIT_FAI LURE);
}

rtExtModeCheckI nit();
rtExtModeWaitFo rStartMsg(rtmGe tRTWExtModeInfo (S),
(boolean_T *)&rtmGetStopRe quested(S));

(void)printf("\ n** starting the model **\n");

MdlStart();
if (rtmGetErrorSta tus(S) != NULL) {
GBLbuf.stopExec utionFlag = 1;
}

/*************** *************** *************** *************** *************
* Execute the model. You may attach rtOneStep to an ISR, if so replace *
* the call to rtOneStep (below) with a call to a background task *
* application. *
*************** *************** *************** *************** *************/

if (rtmGetTFinal(S ) == RUN_FOREVER) {
printf ("\n**May run forever. Model stop time set to infinity.**\n") ;
}

while (!GBLbuf.stopEx ecutionFlag &&
(rtmGetTFinal(S ) == RUN_FOREVER ||
rtmGetTFinal(S)-rtmGetT(S) > rtmGetT(S)*DBL_ EPSILON)) {

rtExtModePauseI fNeeded(rtmGetR TWExtModeInfo(S ),
(boolean_T *)&rtmGetStopRe quested(S));

if (rtmGetStopRequ ested(S)) break;
rt_OneStep(S);
}

if (!GBLbuf.stopEx ecutionFlag && !rtmGetStopRequ ested(S)) {
/* Execute model last time step */
rt_OneStep(S);
}

/*************** *****
* Cleanup and exit *
*************** *****/

rt_StopDataLogg ing(MATFILE,rtm GetRTWLogInfo(S ));

rtExtModeShutdo wn();

if (GBLbuf.errmsg) {
(void)fprintf(s tderr,"%s\n",GB Lbuf.errmsg);
exit(EXIT_FAILU RE);
}

if (GBLbuf.isrOver run) {
(void)fprintf(s tderr,
"%s: ISR overrun - base sampling rate is too fast\n",
QUOTE(MODEL));
exit(EXIT_FAILU RE);
}

if (rtmGetErrorSta tus(S) != NULL) {
(void)fprintf(s tderr,"%s\n", rtmGetErrorStat us(S));
exit(EXIT_FAILU RE);
}
#ifdef MULTITASKING
else {
int_T i;
for (i=1; i<NUMST; i++) {
if (GBLbuf.overrun Flags[i]) {
(void)fprintf(s tderr,
"%s ISR overrun - sampling rate is too fast for "
"sample time index %d\n", QUOTE(MODEL), i);
exit(EXIT_FAILU RE);
}
}
}
#endif

MdlTerminate();
return(EXIT_SUC CESS);

/* end main */


/* EOF: grt_main.c */

[Studlyami]

you probably forgot a closing bracket ( } ) somewhere. check over your code again and make sure each { has a } associated with it.

[Studlyami]

please post comments regarding this problem in here

looking at code that you posted

#ifndef __RT_SIM__
#define __RT_SIM__
//no endif for this ifndef
 

#ifdef MULTITASKING //bottom of file
    else {
//is this else suppose to be #else
 

[weaknessforcats]

cl.exe is Microsoft's compiler.

It doesn't like the final line to have any data in it.

Go through all of your files and be sure there is a null line (enter key only) at the end of each file. Do this in both header and source files.

[jonatan]

cl.exe is Microsoft's compiler.

It doesn't like the final line to have any data in it.

Go through all of your files and be sure there is a null line (enter key only) at the end of each file. Do this in both header and source files.

Thanks for your help. Error already settle about error c1004. Now my problem how to fill RT, NUMST=#, NCSTATES=#, MODEL (can be seen in abstract grt_main.c - compiler specified defines). i am trying to fill of RT,NUMST=#, NCSTATES=# using "string/number" and MODEL is name of file in MATLAB but still have error.

c:\matlab6p5\wo rk\robot\grt_ma in.c(82) : fatal error C1189: #error : "1" --> i am trying fill RT =1

Could you explain with me how to solve them, because important for me.
Thank you so much.

-Jonatan-

[weaknessforcats]

You are using a preprocessor definition (in an ifdef or ifndef) without ever having #define the definition.

[jonatan]

You are using a preprocessor definition (in an ifdef or ifndef) without ever having #define the definition.

Sir, what should to do, because these code i got from matlab c:matlab6p5/rtw/c/grt/grt_main.c. Do you have suggestion for me?
Thank You

[gpraghuram]

Sir, what should to do, because these code i got from matlab c:matlab6p5/rtw/c/grt/grt_main.c. Do you have suggestion for me?
Thank You

I added the following at the end of the code

}
#endif

Now it is telling that it is not able to find the header files.


Raghuram

[jonatan]

I added the following at the end of the code

}
#endif

Now it is telling that it is not able to find the header files.


Raghuram

Sir, grt_main.c is not able to find the header files.
Is it possible the code from simulink-matlab especially grt_main.c (generic real time) can to run on vc++? because to much error in grt_main.c. Actually code grt_main.c is the code of Matlab.

[gpraghuram]

Sir, grt_main.c is not able to find the header files.
Is it possible the code from simulink-matlab especially grt_main.c (generic real time) can to run on vc++? because to much error in grt_main.c. Actually code grt_main.c is the code of Matlab.

You should have all the header files with you as you have the source code grt_main.c
If not you have to get the same and try to compile it.

Raghuram