maxicode.c

This is program with source code to convert ascii text files to the maxicode barcode standard.

   index = 0;

   while(end_of_text == FALSE  )
    {
     new_char = instring[jj];
     new_charp1 = instring[jj+1];
     new_charp2 = instring[jj+2];
     new_charp3 = instring[jj+3];
     new_charp4 = instring[jj+4];

     if ( new_char == NULLCHAR)
       {
	 end_of_text = TRUE;
       }

     jj += 1;

     if (debug) { printf("New char = %c \n",new_char); }

     value1 = get_cvalue_codeset( new_char, &type1 );
     value2 = get_cvalue_codeset( new_charp1, &type2);     
     value3 = get_cvalue_codeset( new_charp2, &type3);
     value4 = get_cvalue_codeset( new_charp3, &type4);

     if (debug)
       {
        printf(" value1 = %d  type1 = %d \n", value1, type1);
        printf(" prev_value = %d  prev_type = %d \n", prev_value, prev_type);
       }
     if ( (type1 & prev_type) > 0)  // some overlap
      {
	   if (debug)
               { 
         printf("Some overlap  value1 = %d prev_value = %d \n",value1,prev_value);
                }
          
           if ( type1 < 4)
             {
	       put_back(value1);
             }
	   if ( type1 == 4 )  // C set
             {
	       if (ccount == 1)
                 {
		   put_back(60);  // lock in C
                   put_back(value1);
                   ccount = 0;
                 }
               else
                 {
                   put_back(value1);
                 }
             }

	   if ( type1 == 8 )  // D set
             {
	       if (dcount == 1)
                 {
		   put_back(60);  // lock in D
                   put_back(value1);
                   dcount = 0;
                 }
                else
                 {
                   put_back(value1);
                 }
             }

	   if ( type1 == 16 )  // E set
             {
	       if (ecount == 1)
                 {
		   put_back(60);  // lock in E
                   put_back(value1);
                   ecount = 0;
                 }
                else
                 {
                   put_back(value1);
                 }
             }

      }

     else    // no overlap, must do a shift or lock in
      {
        this_prev_type = prev_type;

	if (debug) { printf("No overlap- this_prev_type = %d \n",
                        this_prev_type); }

	// check for triple shift
	// previous codes set was B and new codeset = A

	if(( type1 == 1) && ( prev_type == 2))
          {
	    // two more available chars
            if (( new_char != NULLCHAR) && ( new_charp1 != NULLCHAR)
		&& (new_charp2 != NULLCHAR))
              {
                if (( type2 == 1) && (type3 == 1))  // two more A codesets
                  {
                    if (( type4 == 2) || ( new_charp4 == NULLCHAR))
		      {
			// do triple shift
			put_back(57);
                        put_back(value1);
                        put_back(value2);
                        put_back(value3);
                        jj += 2;
                      }
                  }
                    
	      }
            else
	      {
               // one more available chars

               if (( new_char != NULLCHAR) && ( new_charp1 != NULLCHAR))
                {
                 if ( type2 == 1)  // one more A codeset
                  {
                    if (( type3 == 2) || ( new_charp3 == NULLCHAR))
		      {
			// do double shift
			put_back(56);
                        put_back(value1);
                        put_back(value2);
                        jj += 1;
                      }
                   }
                 else  // at least two chars first is A,
		   {
                     if ( type2 == 2)   // second is B so just shift
                       {
		        put_back(59); // codeset A shift
                        put_back(value1);
                       }
                     else      // other is C D or E
		       {
                         put_back(59);
                         put_back(value1);
                       }
                   }              
                }
               else   // this is the last character in the string
		 {
		   put_back(59);
                   put_back(value1);
                 }
              }
          }
        
	if(( type1 == 1) && ( prev_type > 2))  // c,d or e to A
          {
            put_back(58);      // Latch to A
	    put_back(value1);
          }
        
	if(( type1 == 2) && ( prev_type == 1))  // A to B
          {
            if (( type2 == 2) && ( new_charp1 != NULLCHAR)) // more than one B
              {
                put_back(63);    // latch to B if more than one
	        put_back(value1);
              }
            else
              {
                put_back(59);   // shift to B
	       put_back(value1);
              }
	  }

	if(( type1 == 2) && ( prev_type > 2))  // C, D, E to B
          {
            
               put_back(63);   // Latch to B
	       put_back(value1);
            
	  }

	if(( type1 == 4) && ( prev_type < 4))  // A or B, to C
          {
            
               put_back(60);   // Shift to C
	       put_back(value1);
               ccount = 1;
	  }

	if(( type1 == 8) && ( prev_type < 4))  // A or B, to D
          {
            
               put_back(61);   // Shift to D
	       put_back(value1);
               dcount = 1;
	  }

	if(( type1 == 16) && ( prev_type < 4))  // A or B, to E
          {
            
               put_back(62);   // Shift to E
	       put_back(value1);
               ecount = 1;
	  }

	if(( type1 == 4) && ( prev_type == 8))  // D to C
          {
            
               put_back(60);   // Shift to C
	       put_back(value1);
               ccount = 1;
	  }

	if(( type1 == 4) && ( prev_type == 16))  // E to C
          {
            
               put_back(60);   // Shift to C
	       put_back(value1);
               ccount = 1;
	  }

	if(( type1 == 8) && ( prev_type == 4))  // C to D
          {
            
               put_back(61);   // Shift to D
	       put_back(value1);
               dcount = 1;
	  }

	if(( type1 == 8) && ( prev_type == 16))  //  E to D
          {
            
               put_back(61);   // Shift to D
	       put_back(value1);
               dcount = 1;
	  }

	if(( type1 == 16) && ( prev_type == 4))  // C to E
          {
            
               put_back(62);   // Shift to E
	       put_back(value1);
               dcount = 1;
	  }

	if(( type1 == 16) && ( prev_type == 8))  //  D to E
          {
            
               put_back(62);   // Shift to E
	       put_back(value1);
               ecount = 1;
	  }


      }    /* overlap */

     if (instring[jj] == NULLCHAR)
       {
	end_of_text = TRUE;
       }

    }   /* while end of text == false */

    if ( index % 2 == 1)
      {
        symbol_char_array[index] = 29;
        index += 1;
      }

    for ( ii = 0; ii < ( index / 2) ; ii += 1)
      {
        value2 = ( 30 * symbol_char_array[2 * ii] )
                     + symbol_char_array[(2*ii) + 1];
        if ( debug) {
              printf("Makeing symbol - %d , %d , %d \n", ii, 
                         symbol_char_array[2 * ii],
		     symbol_char_array[( 2*ii) + 1]); }
                   
        put_back( value2 );
      
      }

  }

void test_do_text_str()
{

  char tstring[120];

  secondary_msg = TRUE;
  sec_codeindex = 0;

  tstring[0] = 'A';
  tstring[1] = 'B';
  tstring[2] = 'C';
  tstring[3] = NULLCHAR;

  do_text_string(tstring);

  // test 2 Shift A

  secondary_msg = TRUE;
  sec_codeindex = 0;

  tstring[0] = 'a';
  tstring[1] = 'a';
  tstring[2] = 'B';
  tstring[3] = NULLCHAR;

  do_text_string(tstring);

  // test 3 Shift A

  secondary_msg = TRUE;
  sec_codeindex = 0;

  tstring[0] = 'a';
  tstring[1] = 'a';
  tstring[2] = 'a';
  tstring[3] = 'B';
  tstring[4] = NULLCHAR;

  do_text_string(tstring);

  // test  Shift A to Shift B

  secondary_msg = TRUE;
  sec_codeindex = 0;

  tstring[0] = 'a';
  tstring[1] = 'A';
  tstring[2] = 'b';
  tstring[3] = 'B';
  tstring[4] = 'c';
  tstring[5] = 'C';
  tstring[6] = NULLCHAR;

  do_text_string(tstring);

  secondary_msg = TRUE;
  sec_codeindex = 0;

  tstring[0] = 'A';
  tstring[1] = 'a';
  tstring[2] = 'B';
  tstring[3] = 'b';
  tstring[4] = 'C';
  tstring[5] = 'c';
  tstring[6] = NULLCHAR;

  do_text_string(tstring);

} //test_do_text_str 

void test_ecc_secondary()
  {
 int j;
 int save_val;
 int save_val2;
 int save_val3;
 int save_val4;

 int k;
 int this_error;
 int this_error2;
 int this_error3;

 int randint;
 int randint2;
 int randint3;
 int randint4;

 int randloc2;
 int randloc3;
 int randloc4;
 int randloc;

 int difval;
 int difval2;
 int difval3;
 int difval4;
 int datalen;
 int msg_len;
 int ecclen;

 // first test good data and ecc, check to see that syndromes are all
 // zero

  data[0] = 47;
  data[1] = 40;
  data[2] = 57;
  data[3] = 03;
  data[4] = 01;
  data[5] = 19;
  data[6] = 41;
  data[7] = 47;
  data[8] = 1;
  data[9] = 8;
  data[10] = 19;
  data[11] = 18;
  data[12] = 41;
  data[13] = 33;

 
  for ( j = 14; j < 42; j += 1)
    {
      data[j] = 33;
    }

  datalen = 42;
  ecclen = 20;

  msg_len = datalen + ecclen;

  generateEC( data, datalen, ecclen);  // do odd ecc

  syndromes( data, msg_len, ecclen/2 );    // total data = 42 data + 10 syndromes */

  for (j = 0; j < 20; j += 1)
    {
      data[j+42] = ecc_results[j];
    }

  for (j = 0; j < msg_len; j += 1)  // no erasures
    {
      erase_posit[j] = 0;
    }

  // eras_dec_rs ( data, erasures, number_of_erasures, data length
  //                        syndrome_length);

  eras_dec_rs( data, erase_posit, 0 , msg_len, ecclen/2 );   

  save_val = data[0];

  data[0] = 5;  // cause an error in the recieved data...

  syndromes( data, msg_len, ecclen/2);    // total data = 42

 
  for (j = 0; j < 41; j += 1)
    {
      erase_posit[j] = 0;
    }

  // do one error at data[0]

  printf("before data[0] = %d \n", data[0]);

  
  eras_dec_rs( data, erase_posit, 0, msg_len, ecclen/2);   

  printf("after data[0] = %d \n", data[0]);

  data[0] =  save_val;

  printf("Testing a single error in each location \n");

  for ( k = 0 ; k < (msg_len) ; k += 1)
    {
      this_error = data[k] - 5;
      save_val = data[k];
      data[k] = 5;         // cause error at location k
   
      printf("Data [k=%d] = %d  \n",k, data[k]);
      
      syndromes( data,msg_len, ecclen/2);
  
      eras_dec_rs( data, erase_posit, 0, msg_len, ecclen/2 );
      
      if (data[k] != save_val)
        {
	  printf(" Error at k = %d data[k] = %d save = %d \n", 
		 k , data[k], save_val );
        }
      data[k] = save_val;
    }

  printf("Testing a single random error at data[5] \n");

  // test random single errors

  for ( k = 0 ; k < 100 ; k += 1)
    {
      randint = random();
      randint = randint & NN;
      difval = randint % NN;

      if ( difval > data[5])
        {
          
         this_error = difval - data[5];
	}
      else
	{
	  this_error = data[5] - difval;
        }

      save_val = data[5];
      data[5] = difval;    // cause error at location k
      
   
      printf("Data [5] = %d \n", data[5]);
   
      syndromes( data, msg_len, ecclen/2);
  
      eras_dec_rs( data, erase_posit, 0, msg_len, ecclen/2 );
      
      if (data[5] != save_val)
        {
	  printf(" Error at k = %d data[k] = %d save = %d \n", 
		 k , data[5], save_val );
        }
      data[5] = save_val;
    }

  printf(" Testing simple double errors \n");

  // simple double errors



  // one random error at 0 and error of 1 at 1

  for ( k = 0 ; k < 100 ; k += 1)
    {

       randint = random();
      randint = randint & NN;
      difval = randint % (NN+1);

      if ( difval > data[0])
        {
          
         this_error = difval - data[0];
	}
      else
	{
	  this_error = data[0] - difval;
        }

      save_val = data[0];
      data[0] = difval;    // cause error at location k
    
      save_val2 = data[1];
      data[1] = 1;
   
      printf("Data [0,1] = %d %d \n", data[0], data[1]);

      syndromes( data, msg_len, ecclen/2);
  
      eras_dec_rs( data, erase_posit, 0, msg_len, ecclen/2 );
      
      if ( (data[0] != save_val) | ( data[1] != save_val2))
        {
	  printf(" Error at k = %d data[0] = %d save = %d \n", 
		 k , data[0], save_val );
          printf(" Error2 at k = %d data[1] = %d save = %d \n", 
		 k , data[1], save_val2 );
        }
      data[0] = save_val;
      data[1] = save_val2;
    }

  printf("Testing double errors, one at random location one at data[1] \n");

  // random error at random loc and error at 1

  for ( k = 0 ; k < 100 ; k += 1)
    {

       randint = random();
      randint = randint & NN;
      difval = randint % (NN+1);

      randloc = random();
      randloc = randloc % 62;

      if (randloc == 1)
	{