Help with Pro*C/C++ precompiler error

Question

Hello.
I have a little experience working with Pro*C/C++ and now I am trying to learn more by my own.
I think this is an easy question. I am trying to precompile the Thread_example1.pc code from Pro*C/C++ Precompiler Programmer's Guide, Release 9.2 (I am trying it in a windows machine because I have pthreads for windows installed, so that I have commented the DCE_THREADS references).
The thing is I am not able to precompile the code (I have tried several precompiler options).
Now I am getting the error (I am sorry it is in Spanish):
Error semßntico en la lÝnea 126, columna 32, archivo d:\Ejercicios_ProC\MultithreadExample\Thread_example1.pc:
EXEC SQL CONTEXT ALLOCATE :ctx;
...............................1
PCC-S-02322, se ha encontrado un identificador no definido
The thing is that it is defined (outside a EXEC SQL DECLARE section but the precompiler CODE is set to default that does not need to be inside).
If I declare it inside a EXEC SQL DECLARE section I get:
Error semßntico en la lÝnea 105, columna 18, archivo d:\Ejercicios_ProC\MultithreadExample\Thread_example1.pc:
sql_context ctx[THREADS];
.................1
PCC-S-02322, se ha encontrado un identificador no definido
I have also tried writing EXEC SQL CONTEXT USE :ctx[THREADS]; just before the declare section but I get the same error than before.
Can someone help me?

Answer 1

Hmm, try the updated one (mltthrd1.pc). I've tried it (and a converted-to-pthread version on Linux). Both work fine. What version of Pro*C are you using?
NAME
  MltThrd1
FUNCTION
NOTES
  32-bit Pro*C/C++ Multithreaded sample program from Pro*C/C++ User's Guide.
Requirements
  The program requires a table ACCOUNTS to be in the schema
  SCOTT/TIGER. The description of ACCOUNTS is.
SQL> desc accounts
Name                  Null?   Type
ACCOUNT                       NUMBER(10)
BALANCE                       NUMBER(12,2)
For proper execution, the table should be filled with the
accounts 10001 to 10008.
     shsu: run MltThrd1.sql first.
OWNER
DATE
MODIFIED
  rahmed     10/10/96 - ported for WIN32 port.
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sqlca.h>
#define CONNINFO "SCOTT/TIGER"
#define THREADS 3
EXEC SQL BEGIN DECLARE SECTION;
     struct parameters
          sql_context * ctx;
          int thread_id;
     typedef struct parameters parameters;
     struct record_log
          char action;
          unsigned int from_account;
          unsigned int to_account;
          double amount;
     typedef struct record_log record_log;
EXEC SQL END DECLARE SECTION;
/* Function prototypes   */
void err_report(struct sqlca);
void do_transaction(parameters *);
void get_transaction(record_log**);
void logon(sql_context,char *);
void logoff(sql_context);
record_log records[]= { { 'M', 10001, 10002, 12.50 },
               { 'M', 10001, 10003, 25.00 },
               { 'M', 10001, 10003, 123.00 },
               { 'M', 10001, 10003, 125.00 },
               { 'M', 10002, 10006, 12.23 },
               { 'M', 10007, 10008, 225.23 },
               { 'M', 10002, 10008, 0.70 },
               { 'M', 10001, 10003, 11.30 },
               { 'M', 10003, 10002, 47.50 },
               { 'M', 10002, 10006, 125.00 },
               { 'M', 10007, 10008, 225.00 },
               { 'M', 10002, 10008, 0.70 },
               { 'M', 10001, 10003, 11.00 },
               { 'M', 10003, 10002, 47.50 },
               { 'M', 10002, 10006, 125.00 },
               { 'M', 10007, 10008, 225.00 },
               { 'M', 10002, 10008, 0.70 },
               { 'M', 10001, 10003, 11.00 },
               { 'M', 10003, 10002, 47.50 },
               { 'M', 10008, 10001, 1034.54}};
static unsigned int trx_nr=0;
HANDLE hMutex;
void main()
     EXEC SQL BEGIN DECLARE SECTION;
          sql_context ctx[THREADS];
     EXEC SQL END DECLARE SECTION;  
     HANDLE thread[THREADS];
     parameters params[THREADS];
     int j;
     DWORD ThreadId ;
     /* Initialize a process in which to spawn threads. */
     EXEC SQL ENABLE THREADS;
     EXEC SQL WHENEVER SQLERROR DO err_report(sqlca);
     /* Create THREADS sessions by connecting THREADS times, each
     connection in a separate runtime context. */
     for(i=0; i<THREADS; i++){
          printf("Start Session %d....\n",i);
          EXEC SQL CONTEXT ALLOCATE :ctx[j];
          logon(ctx[j],CONNINFO);
     /* Create mutex for transaction retrieval.
        Created an unnamed/unowned mutex. */
     hMutex=CreateMutex(NULL,FALSE,NULL);
     if (!hMutex){
          printf("Can't initialize mutex\n");
          exit(1);
     /* Spawn threads. */
     for(i=0; i<THREADS; i++){
          params[j].ctx=ctx[j];
          params[j].thread_id=i;
          printf("Thread %d... ",i);
          thread[j]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)do_transaction,
                                 &params[j],0,&ThreadId);
          if (!thread[j])
               printf("Cant create thread %d\n",i);
          else
               printf("Created\n");
     /* Logoff sessions. */
     for(i=0;i<THREADS;i++){
          printf("Waiting for Thread %d to stop....",i); /* waiting for thread to end */
          if(WaitForSingleObject(
                         thread[j],                       /* handle of thread  */
                         INFINITE) != WAIT_OBJECT_0)      /* time-out interval */
               printf("Error waiting for thread % to terminate\n", i);
          else
               printf("Thread %d stopped\n",i);
          printf("Stop Session %d....\n",i);
          logoff(ctx[j]);
          EXEC SQL CONTEXT FREE :ctx[j];
} /* end main() */
* Function: do_transaction()
* Description: This function executes one transaction out of
*                          the records array. The records array is managed
*                          by get_transaction().
void do_transaction(parameters *params)
struct sqlca sqlca;
EXEC SQL BEGIN DECLARE SECTION;
     record_log *trx;
EXEC SQL END DECLARE SECTION;
sql_context ctx;
ctx = params->ctx;
     /* Done all transactions ? */
     while (trx_nr < (sizeof(records)/sizeof(record_log))){
          get_transaction(&trx);
          EXEC SQL WHENEVER SQLERROR DO err_report(sqlca);
          /* Use the specified SQL context to perform the executable SQL
          statements that follow. */
          EXEC SQL CONTEXT USE :ctx;
          printf("Thread %d executing transaction # %d\n",params->thread_id,trx_nr);
          switch(trx->action){
               case 'M':       EXEC SQL UPDATE ACCOUNTS
                              SET BALANCE=BALANCE+:trx->amount
                              WHERE ACCOUNT=:trx->to_account;
                              EXEC SQL UPDATE ACCOUNTS
                              SET BALANCE=BALANCE-:trx->amount
                              WHERE ACCOUNT=:trx->from_account;
                              break;
               default:
                              break;
          EXEC SQL COMMIT;
* Function: err_report()
* Description: This routine prints the most recent error.
void err_report(struct sqlca sqlca)
     if (sqlca.sqlcode < 0)
          printf("\n%.*s\n\n",sqlca.sqlerrm.sqlerrml,sqlca.sqlerrm.sqlerrmc);
     exit(1);
* Function: logon()
* Description: This routine logs on to Oracle.
void logon(sql_context ctx,char *conninfo){
     EXEC SQL BEGIN DECLARE SECTION;
          char connstr[20];
     EXEC SQL END DECLARE SECTION;
     EXEC SQL CONTEXT USE :ctx;
     strcpy(&connstr[0],(char*)conninfo);
     EXEC SQL CONNECT :connstr;
* Function: logoff()
* Description: This routine logs off from Oracle.
void logoff(sql_context ctx)
     EXEC SQL CONTEXT USE :ctx;
     EXEC SQL COMMIT WORK RELEASE;
* Function: get_transaction()
* Description: This functions manages the records array.
void get_transaction(record_log** temp)
DWORD dwWaitResult;
     /* Request ownership of mutex. */
     dwWaitResult=WaitForSingleObject(
                         hMutex,      /* handle of mutex   */
                         INFINITE);       /* time-out interval */
     switch (dwWaitResult) {
    /* The thread got mutex ownership. */
    case WAIT_OBJECT_0:
                    *temp = &records[trx_nr];
                    trx_nr++;
                    /* Release ownership of the mutex object. */
     if (! ReleaseMutex(hMutex))
                         printf("Not able to release mutex\n");
     break;
    /* Cannot get mutex ownership due to time-out. */
    case WAIT_TIMEOUT:
                         printf("Cannot get mutex ownership due to time-out\n");
    /* Got ownership of the abandoned mutex object. */
    case WAIT_ABANDONED:
                         printf("Got ownership of the abandoned mutex object\n");
}