Exemplo n.º 1
0
  void TurboCode::doEncode_term(const itpp::bvec &input, itpp::bvec *output) const
  {
    itpp::bvec parity1, tailbits1, tailParity1;
    rsc1_.GenParity(input, &parity1);
    rsc1_.Terminate(&tailbits1, &tailParity1);
    
    itpp::bvec interleaved = Interleave(input, interleaver_);
    itpp::bvec parity2, tailbits2, tailParity2;
    rsc2_.GenParity(interleaved, &parity2);
    rsc2_.Terminate(&tailbits2, &tailParity2);
    
    itpp::bvec t_output(3*interleaver_.size());
    for (int i = 0; i < interleaver_.size(); ++i){
      t_output[3*i] = input[i];
      t_output[3*i + 1] = parity1[i];
      t_output[3*i + 2] = parity2[i];
    } // for i

    itpp::bvec codeTail1(2*tailbits1.size());
    for (int i = 0; i < tailbits1.size(); ++i){
      codeTail1[2*i] = tailbits1[i];
      codeTail1[2*i + 1] = tailParity1[i];
    } // for i
    *output = itpp::concat(t_output, codeTail1);
    
    itpp::bvec codeTail2(2*tailbits2.size());
    for (int i = 0; i < tailbits2.size(); ++i){
      codeTail2[2*i] = tailbits2[i];
      codeTail2[2*i + 1] = tailParity2[i];
    } // for i
    *output = itpp::concat(*output, codeTail2);
  }
Exemplo n.º 2
0
    main ()	/* test case */

    {
    struct ECB ecb;
    COUNT lines, columns;
    CODE type, term, code;
    TEXT string[STRINGSIZ+1];
    TEXT	*str;

    t_init(&lines, &columns, &type);
    t_clear();
    printf("lines, columns, type = %d, %d, %d\n",
	   lines, columns, type);
    t_output(10, 30, "line 10, column 30");
    t_write("\nnon-CRT write to next line\n", T_STDCC);
    t_input(20, 10, string, &term);
    printf("Terminator = %s\n",  (term == T_CR) ? "(return)" : "(escape)");
    t_highlight (string);
    t_output(22, 10, string);	/* echo */
    t_lclear (22, 15);		/* clear original except 5 character */
    t_write ("hit left, right, up, down, GOLD, or any key");
    code = t_gettok ();
    if (code == T_LEFT) str = "LEFT";
    else if (code == T_RIGHT) str = "RIGHT";
    else if (code == T_UP) str = "UP";
    else if (code == T_DOWN) str = "DOWN";
    else if (code == T_GOLD) str = "GOLD";
    else if (code == T_UNKNOWN) str = "UNKNOWN";
    else 
        {
        string[0] = code;
        string[1] = EOS;
        str = string;
        }    
    t_write (str, T_STDCC);	
    for (;;)
	{
	t_bell();		/* bell every time controlc hit */
        t_write(" ", T_STDCC);	/* flush			*/
        t_attn(&ecb);
	while (!e_occur(&ecb))  /* loop till event		*/
	    ;
	}    
    exit ();
    }
int
main (int argc, char **argv)
{
  struct commandline cmd;

  (void) memset ((char *) &cmd, 0, sizeof (struct commandline));
  clear_args ();
  if (!parseargs (argc, argv, &cmd) || !cmd.infile)
    usage ();

  if (cmd.cflag || cmd.hflag || cmd.tflag)
    checkfiles (cmd.infile, cmd.outfile);
  else
    checkfiles (cmd.infile, NULL);

  if (cmd.cflag) {
    c_output (cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
  }
  else if (cmd.hflag) {
    h_output (cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
  }
  else if (cmd.tflag) {
    t_output (cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
  }
  else {
    /* the rescans are required, since cpp may effect input */
    c_output (cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
    reinitialize ();
    h_output (cmd.infile, "-DRPC_HDR", EXTEND, ".h");
    reinitialize ();
    t_output (cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.c");
  }
#ifdef __MSDOS__
  if (dos_cppfile != NULL) {
    (void) fclose (fin);
    (void) unlink (dos_cppfile);
  }
#endif
  exit (nonfatalerrors);
  /* NOTREACHED */
}
Exemplo n.º 4
0
Arquivo: wrtmsg.c Projeto: E-LLP/VICAR
FUNCTION  VOID  wrtpmt
(
    TEXT	msg[]				/* IN: prompt message */
  
 )
    {
    IMPORT  COUNT  termlines;		/* number of lines on crt screen */
    IMPORT  CODE   termtype;		/* terminal type */

 
    if (termtype == T_CRT)			/* terminal is CRT */
	{
	t_lclear(termlines - PMTLIN, 1);			/* clear prompt line */
        t_output((termlines - PMTLIN), 1, msg);		/* write prompt  */
	}
    else
	t_write(msg, T_PROMPT);			/* write to terminal */ 
    return;
    }
Exemplo n.º 5
0
Arquivo: wrtmsg.c Projeto: E-LLP/VICAR
FUNCTION  VOID  wrttxt
(
    FUNINT	line,			/* IN: line number to write to */
    FUNINT	col,			/* IN: column number to write to */
    TEXT	text[],			/* IN: message text */
    FUNINT	blank			/* IN: True if rest to be blanked */

 )
    {
    IMPORT  CODE   termtype;		/* terminal type */

    if (termtype == T_CRT)
	{
	if (blank) t_lclear(line, 1);		/* write a blank line */
        t_output(line, col, text);		/* output with no cleanup */
	}
    else 
	t_write(text, T_STDCC);			/* write with carriage return */
    return;
    }
Exemplo n.º 6
0
int
main(int argc, const char **argv)
{
	struct commandline cmd;

	memset(&cmd, 0, sizeof (struct commandline));
	clear_args();
	if (!parseargs(argc, argv, &cmd))
		usage();
	/*
	 * Only the client and server side stubs are likely to be customized,
	 *  so in that case only, check if the outfile exists, and if so,
	 *  print an error message and exit.
	 */
	if (cmd.Ssflag || cmd.Scflag || cmd.makefileflag)
		checkfiles(cmd.infile, cmd.outfile);
	else
		checkfiles(cmd.infile, NULL);

	if (cmd.cflag) {
		c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
	} else if (cmd.hflag) {
		h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile,
		    cmd.hflag);
	} else if (cmd.lflag) {
		l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
	} else if (cmd.sflag || cmd.mflag || (cmd.nflag)) {
		s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
			cmd.outfile, cmd.mflag, cmd.nflag);
	} else if (cmd.tflag) {
		t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
	} else if  (cmd.Ssflag) {
		svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND,
			cmd.outfile);
	} else if (cmd.Scflag) {
		clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND,
			    cmd.outfile);
	} else if (cmd.makefileflag) {
		mkfile_output(&cmd);
	} else {
		/* the rescans are required, since cpp may effect input */
		c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
		reinitialize();
		h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h", cmd.hflag);
		reinitialize();
		l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");
		reinitialize();
		if (inetdflag || !tirpcflag)
			s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,
			"_svc.c", cmd.mflag, cmd.nflag);
		else
			s_output(allnc, allnv, cmd.infile, "-DRPC_SVC",
				EXTEND, "_svc.c", cmd.mflag, cmd.nflag);
		if (tblflag) {
			reinitialize();
			t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");
		}

		if (allfiles) {
			reinitialize();
			svc_output(cmd.infile, "-DRPC_SERVER", EXTEND,
				"_server.c");
			reinitialize();
			clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND,
				"_client.c");

		}
		if (allfiles || (cmd.makefileflag == 1)){
			reinitialize();
			mkfile_output(&cmd);
		}
	}

	exit(nonfatalerrors);
	/* NOTREACHED */
}
Exemplo n.º 7
0
int
main(int argc, char **argv)
{
	struct commandline cmd;

	(void) memset((char *) &cmd, 0, sizeof(struct commandline));
	clear_args();
	if (!parseargs(argc, argv, &cmd))
		usage();

	if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag ||
		cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag) {
		checkfiles(cmd.infile, cmd.outfile);
	} else
		checkfiles(cmd.infile, NULL);

	if (cmd.cflag) {
		c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
	} else if (cmd.hflag) {
		h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
	} else if (cmd.lflag) {
		l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
	} else if (cmd.sflag || cmd.mflag || (cmd.nflag)) {
		s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
			cmd.outfile, cmd.mflag, cmd.nflag);
	} else if (cmd.tflag) {
		t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
	} else if (cmd.Ssflag) {
		svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile);
	} else if (cmd.Scflag) {
		clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile);
	} else {
		/* the rescans are required, since cpp may effect input */
		c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
		reinitialize();
		h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h");
		reinitialize();
		l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");
		reinitialize();
		if (inetdflag || !tirpcflag)
			s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,
				"_svc.c", cmd.mflag, cmd.nflag);
		else
			s_output(allnc, allnv, cmd.infile, "-DRPC_SVC",
				EXTEND, "_svc.c", cmd.mflag, cmd.nflag);
		if (tblflag) {
			reinitialize();
			t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");
		}
		if (allfiles) {
			reinitialize();
			svc_output(cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c");
		}
		if (allfiles) {
			reinitialize();
			clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c");
		}
	}
	exit(nonfatalerrors);
	/* NOTREACHED */
}