OpenCores
URL https://opencores.org/ocsvn/reed_solomon_codec_generator/reed_solomon_codec_generator/trunk

Subversion Repositories reed_solomon_codec_generator

[/] [reed_solomon_codec_generator/] [trunk/] [source/] [RsDecodeDegree.cpp] - Blame information for rev 2

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 issei 
//===================================================================
2 
// Module Name : RsDecodeDegree
3 
// File Name   : RsDecodeDegree.cpp
4 
// Function    : RTL Decoder Degree Module generation
5 
//
6 
// Revision History:
7 
// Date          By           Version    Change Description
8 
//===================================================================
9 
// 2009/02/03  Gael Sapience     1.0       Original
10 
//
11 
//===================================================================
12 
// (C) COPYRIGHT 2009 SYSTEM LSI CO., Ltd.
13 
//
14 
#include <stdio.h>
15 
#include <stdlib.h>
16 
#include <iostream>
17 
#include<windows.h>
18 
#include<fstream>
19 
#include <string.h>
20 
using namespace std;
21 
 
22 
 
23 
FILE  *OutFileDegree;
24 
 
25 
 
26 
void RsDecodeDegree(int DataSize, int TotalSize, int PrimPoly, int bitSymbol, int ErasureOption, int pathFlag, int lengthPath, char *rootFolderPath) {
27 
 
28 
 
29 
   //---------------------------------------------------------------
30 
   // C++ variables
31 
   //---------------------------------------------------------------
32 
   int syndromeLength;
33 
   int ii;
34 
   int degreeOrder;
35 
   int stopPointer;
36 
   int comparator;
37 
   char *strRsDecodeDegree;
38 
   syndromeLength = TotalSize - DataSize;
39 
 
40 
 
41 
   if (ErasureOption == 0)
42 
   {
43 
      stopPointer = (syndromeLength/2)+1;
44 
      comparator = syndromeLength/2;
45 
   }else{
46 
      stopPointer = syndromeLength;
47 
      comparator = syndromeLength;
48 
   }
49 
 
50 
   //---------------------------------------------------------------
51 
   // open file
52 
   //---------------------------------------------------------------
53 
   strRsDecodeDegree = (char *)calloc(lengthPath + 22,  sizeof(char));
54 
   if (pathFlag == 0) {
55 
        strRsDecodeDegree[0] = '.';
56 
   }else{
57 
      for(ii=0; ii<lengthPath; ii++){
58 
         strRsDecodeDegree[ii] = rootFolderPath[ii];
59 
      }
60 
   }
61 
   strcat(strRsDecodeDegree, "/rtl/RsDecodeDegree.v");
62 
 
63 
   OutFileDegree = fopen(strRsDecodeDegree,"w");
64 
 
65 
 
66 
 
67 
   //---------------------------------------------------------------
68 
   // Ports Declaration
69 
   //---------------------------------------------------------------
70 
   fprintf(OutFileDegree, "//===================================================================\n");
71 
   fprintf(OutFileDegree, "// Module Name : RsDecodeDegree\n");
72 
   fprintf(OutFileDegree, "// File Name   : RsDecodeDegree.v\n");
73 
   fprintf(OutFileDegree, "// Function    : Rs Decoder Degree Module\n");
74 
   fprintf(OutFileDegree, "// \n");
75 
   fprintf(OutFileDegree, "// Revision History:\n");
76 
   fprintf(OutFileDegree, "// Date          By           Version    Change Description\n");
77 
   fprintf(OutFileDegree, "//===================================================================\n");
78 
   fprintf(OutFileDegree, "// 2009/02/03  Gael Sapience     1.0       Original\n");
79 
   fprintf(OutFileDegree, "//\n");
80 
   fprintf(OutFileDegree, "//===================================================================\n");
81 
   fprintf(OutFileDegree, "// (C) COPYRIGHT 2009 SYSTEM LSI CO., Ltd.\n");
82 
   fprintf(OutFileDegree, "//\n\n\n");
83 
 
84 
   fprintf(OutFileDegree, "module RsDecodeDegree(\n");
85 
 
86 
//   for(ii=0; ii<syndromeLength; ii++){
87 
   for(ii=0; ii<stopPointer; ii++){
88 
      fprintf(OutFileDegree, "   polynom_%d,\n", ii);
89 
   }
90 
   fprintf(OutFileDegree, "   degree\n");
91 
   fprintf(OutFileDegree, ");\n\n\n");
92 
 
93 
 
94 
//   for(ii=0; ii<syndromeLength; ii++){
95 
   for(ii=0; ii<stopPointer; ii++){
96 
      if (ii < 10) {
97 
         fprintf(OutFileDegree, "   input  [%d:0]   polynom_%d;    // polynom %d\n",bitSymbol-1, ii, ii);
98 
      }else{
99 
         fprintf(OutFileDegree, "   input  [%d:0]   polynom_%d;   // polynom %d\n",bitSymbol-1, ii, ii);
100 
      }
101 
   }
102 
 
103 
 
104 
   int degreeIdx;
105 
 
106 
 
107 
//   if (syndromeLength > 2047) {
108 
   if (comparator > 2047) {
109 
      fprintf(OutFileDegree, "   output [11:0]   degree;       // polynom degree\n");
110 
      degreeIdx = 12;
111 
   }
112 
//   else if (syndromeLength > 1023) {
113 
   else if (comparator > 1023) {
114 
      fprintf(OutFileDegree, "   output [10:0]   degree;       // polynom degree\n");
115 
      degreeIdx = 11;
116 
   }
117 
//   else if (syndromeLength > 511) {
118 
   else if (comparator > 511) {
119 
      fprintf(OutFileDegree, "   output [9:0]   degree;       // polynom degree\n");
120 
      degreeIdx = 10;
121 
   }
122 
//   else if (syndromeLength > 255) {
123 
   else if (comparator > 255) {
124 
      fprintf(OutFileDegree, "   output [8:0]   degree;       // polynom degree\n");
125 
      degreeIdx = 9;
126 
   }
127 
//   else if (syndromeLength > 127) {
128 
   else if (comparator > 127) {
129 
      fprintf(OutFileDegree, "   output [7:0]   degree;       // polynom degree\n");
130 
      degreeIdx = 8;
131 
   }
132 
//   else if (syndromeLength > 63) {
133 
   else if (comparator > 63) {
134 
      fprintf(OutFileDegree, "   output [6:0]   degree;       // polynom degree\n");
135 
      degreeIdx = 7;
136 
   }
137 
//   else if (syndromeLength > 31) {
138 
   else if (comparator > 31) {
139 
      fprintf(OutFileDegree, "   output [5:0]   degree;       // polynom degree\n");
140 
      degreeIdx = 6;
141 
   }
142 
//   else if (syndromeLength > 15) {
143 
   else if (comparator > 15) {
144 
      fprintf(OutFileDegree, "   output [4:0]   degree;       // polynom degree\n");
145 
      degreeIdx = 5;
146 
   }
147 
//   else if (syndromeLength > 7) {
148 
   else if (comparator > 7) {
149 
      fprintf(OutFileDegree, "   output [3:0]   degree;       // polynom degree\n");
150 
      degreeIdx = 4;
151 
   }
152 
//   else if (syndromeLength > 3) {
153 
   else if (comparator > 3) {
154 
      fprintf(OutFileDegree, "   output [2:0]   degree;       // polynom degree\n");
155 
      degreeIdx = 3;
156 
   }
157 
   else {
158 
      fprintf(OutFileDegree, "   output [1:0]   degree;       // polynom degree\n");
159 
      degreeIdx = 2;
160 
   }
161 
   fprintf(OutFileDegree, "\n\n\n");
162 
 
163 
 
164 
   //------------------------------------------------------------------------
165 
   //- registers
166 
   //------------------------------------------------------------------------
167 
   fprintf(OutFileDegree, "   //------------------------------------------------------------------------\n");
168 
   fprintf(OutFileDegree, "   //- registers\n");
169 
   fprintf(OutFileDegree, "   //------------------------------------------------------------------------\n");
170 
 
171 
 /*  if (syndromeLength > 2047) {
172 
      fprintf(OutFileDegree, "   reg  [11:0]   degree;\n");
173 
      degreeOrder = 12;
174 
   }
175 
   else if (syndromeLength > 1023) {
176 
      fprintf(OutFileDegree, "   reg  [10:0]   degree;\n");
177 
      degreeOrder = 11;
178 
   }
179 
   else if (syndromeLength > 511) {
180 
      fprintf(OutFileDegree, "   reg  [9:0]   degree;\n");
181 
      degreeOrder = 10;
182 
   }
183 
   else if (syndromeLength > 255) {
184 
      fprintf(OutFileDegree, "   reg  [8:0]   degree;\n");
185 
      degreeOrder = 9;
186 
   }
187 
   else if (syndromeLength > 127) {
188 
      fprintf(OutFileDegree, "   reg  [7:0]   degree;\n");
189 
      degreeOrder = 8;
190 
   }
191 
   else if (syndromeLength > 63) {
192 
      fprintf(OutFileDegree, "   reg  [6:0]   degree;\n");
193 
      degreeOrder = 7;
194 
   }
195 
   else if (syndromeLength > 31) {
196 
      fprintf(OutFileDegree, "   reg  [5:0]   degree;\n");
197 
      degreeOrder = 6;
198 
   }
199 
   else if (syndromeLength > 15) {
200 
      fprintf(OutFileDegree, "   reg  [4:0]   degree;\n");
201 
      degreeOrder = 5;
202 
   }
203 
   else if (syndromeLength > 7) {
204 
      fprintf(OutFileDegree, "   reg  [3:0]   degree;\n");
205 
      degreeOrder = 4;
206 
   }
207 
   else if (syndromeLength > 3) {
208 
      fprintf(OutFileDegree, "   reg  [2:0]   degree;\n");
209 
      degreeOrder = 3;
210 
   }
211 
   else {
212 
      fprintf(OutFileDegree, "   reg  [1:0]   degree;\n");
213 
      degreeOrder = 2;
214 
   }
215 
 
216 
   for(ii=1; ii<syndromeLength; ii++){
217 
      fprintf(OutFileDegree, "   wire         flag%d;\n", ii);
218 
   }
219 
   fprintf(OutFileDegree, "\n\n");
220 
   for(ii=1; ii<syndromeLength; ii++){
221 
      fprintf(OutFileDegree, "   assign flag%d = (polynom_%d [%d:0] == %d'd0) ? 1'b0 : 1'b1;\n", ii, ii,bitSymbol-1,bitSymbol);
222 
   }
223 
   fprintf(OutFileDegree, "\n\n\n");
224 
 
225 
 
226 
   //------------------------------------------------------------------------
227 
   //- degree
228 
   //------------------------------------------------------------------------
229 
   fprintf(OutFileDegree, "   //------------------------------------------------------------------------\n");
230 
   fprintf(OutFileDegree, "   //- degree\n");
231 
   fprintf(OutFileDegree, "   //------------------------------------------------------------------------\n");
232 
 
233 
   fprintf(OutFileDegree, "    always @ ( flag1");
234 
   if (syndromeLength > 2) {
235 
      for(ii=2; ii<syndromeLength; ii++){
236 
         fprintf(OutFileDegree, ", flag%d", ii);
237 
      }
238 
   }
239 
 
240 
   fprintf(OutFileDegree, " ) begin\n");
241 
 
242 
   //------------------------------------------------------------------------
243 
   //------------------------------------------------------------------------
244 
   fprintf(OutFileDegree, "      if((flag%d==1'b0)", syndromeLength/2);
245 
   for(ii=((syndromeLength/2)+1); ii<syndromeLength; ii++){
246 
      fprintf(OutFileDegree, " && (flag%d==1'b0)", ii);
247 
   }
248 
   fprintf(OutFileDegree, " ) begin\n");
249 
 
250 
 
251 
 
252 
   //------------------------------------------------------------------------
253 
   //------------------------------------------------------------------------
254 
   if ((syndromeLength/2)-1 > 0) {
255 
      fprintf(OutFileDegree, "         if (flag%d==1'b1) begin\n", (syndromeLength/2)-1);
256 
   }
257 
   else {
258 
      fprintf(OutFileDegree, "         if (flag%d==1'b1) begin\n", 1);
259 
   }
260 
 
261 
   fprintf(OutFileDegree, "            degree <= %d'd%d;\n", degreeOrder,(syndromeLength/2)-1);
262 
   fprintf(OutFileDegree, "         end\n");
263 
 
264 
 
265 
   //------------------------------------------------------------------------
266 
   //------------------------------------------------------------------------
267 
   for(ii=((syndromeLength/2)-2); ii>0; ii--){
268 
      fprintf(OutFileDegree, "         else\n");
269 
      fprintf(OutFileDegree, "         if (flag%d==1'b1) begin\n", ii);
270 
      fprintf(OutFileDegree, "            degree <= %d'd%d;\n",degreeOrder, ii);
271 
      fprintf(OutFileDegree, "         end\n");
272 
   }
273 
   fprintf(OutFileDegree, "         else begin\n");
274 
   fprintf(OutFileDegree, "            degree <= %d'd0;\n", degreeOrder);
275 
   fprintf(OutFileDegree, "         end\n");
276 
   fprintf(OutFileDegree, "      end\n");
277 
   fprintf(OutFileDegree, "      else begin\n");
278 
   fprintf(OutFileDegree, "         if (flag%d==1'b1) begin\n", (syndromeLength-1));
279 
   fprintf(OutFileDegree, "            degree <= %d'd%d;\n", degreeOrder, syndromeLength-1);
280 
   fprintf(OutFileDegree, "         end\n");
281 
 
282 
 
283 
 
284 
   //------------------------------------------------------------------------
285 
   //------------------------------------------------------------------------
286 
   if (((syndromeLength)-2) > (syndromeLength/2)) {
287 
      for(ii=((syndromeLength)-2); ii>(syndromeLength/2); ii--){
288 
         fprintf(OutFileDegree, "         else\n");
289 
         fprintf(OutFileDegree, "         if (flag%d==1'b1) begin\n", ii);
290 
         fprintf(OutFileDegree, "            degree <= %d'd%d;\n", degreeOrder, ii);
291 
         fprintf(OutFileDegree, "         end\n");
292 
      }
293 
   }
294 
   fprintf(OutFileDegree, "         else begin\n");
295 
   fprintf(OutFileDegree, "            degree <= %d'd%d;\n", degreeOrder, (syndromeLength/2));
296 
   fprintf(OutFileDegree, "         end\n");
297 
   fprintf(OutFileDegree, "      end\n");
298 
   fprintf(OutFileDegree, "   end\n");
299 
*/
300 
 
301 
 
302 
   //---------------------------------------------------------------
303 
   //---------------------------------------------------------------
304 
   //---------------------------------------------------------------
305 
   //---------------------------------------------------------------
306 
   int ChallengerNb;
307 
   int LoopCount;
308 
   LoopCount = 0;
309 
   ChallengerNb = syndromeLength;
310 
   int oddFlag;
311 
   oddFlag = 0;
312 
 
313 
 
314 
 
315 
   if (ErasureOption == 0) {
316 
      ChallengerNb = (syndromeLength/2)+ 1;
317 
   }else{
318 
      ChallengerNb = syndromeLength;
319 
   }
320 
 
321 
 
322 
   int *WinnerIdx;
323 
   int *StepIdx;
324 
   int *NextWinnerIdx;
325 
   int *NextStepIdx;
326 
   int LastStep;
327 
   int LastIdx;
328 
 
329 
   LastStep = 0;
330 
   LastIdx  = 0;
331 
 
332 
   WinnerIdx     = new int [syndromeLength];
333 
   StepIdx       = new int [syndromeLength];
334 
   NextWinnerIdx = new int [syndromeLength];
335 
   NextStepIdx   = new int [syndromeLength];
336 
 
337 
   for(ii=0; ii<syndromeLength; ii++){
338 
      WinnerIdx     [ii] = 0;
339 
      StepIdx       [ii] = 0;
340 
      NextWinnerIdx [ii] = 0;
341 
      NextStepIdx   [ii] = 0;
342 
   }
343 
 
344 
   while (ChallengerNb > 1) {
345 
 
346 
      fprintf(OutFileDegree, "//---------------------------------------------------------------\n");
347 
      fprintf(OutFileDegree, "//- step %d\n", LoopCount);
348 
//      for(ii=0; ii<syndromeLength; ii++){
349 
//         fprintf(OutFileDegree, "//winner%dStep%d \n", WinnerIdx [ii], StepIdx   [ii]);
350 
//      }
351 
//      for(ii=0; ii<syndromeLength; ii++){
352 
//         fprintf(OutFileDegree, "//Nextwinner%dStep%d \n", NextWinnerIdx [ii], NextStepIdx   [ii]);
353 
//      }
354 
      fprintf(OutFileDegree, "//---------------------------------------------------------------\n");
355 
 
356 
 
357 
      //---------------------------------------------------------------
358 
      //
359 
      //---------------------------------------------------------------
360 
      if (LoopCount == 0){
361 
         if (ErasureOption == 1) {
362 
            for(ii=0; ii<(syndromeLength/2); ii++){
363 
               fprintf(OutFileDegree, "wire [%d:0]   winner%dStep%d;\n", degreeIdx-1, ii, LoopCount);
364 
               fprintf(OutFileDegree, "assign winner%dStep%d =", ii, LoopCount);
365 
               fprintf(OutFileDegree, "(polynom_%d [%d:0] == %d'd0) ? ", (ii*2)+1,bitSymbol-1,bitSymbol );
366 
               fprintf(OutFileDegree, "((polynom_%d [%d:0] == %d'd0) ? %d'd0 : %d'd%d)", (ii*2),bitSymbol-1,bitSymbol, degreeIdx,degreeIdx, ii*2 );
367 
               fprintf(OutFileDegree, ":  %d'd%d;\n", degreeIdx,(ii*2)+1 );
368 
 
369 
               LastStep = ii;
370 
               LastIdx  = LoopCount;
371 
 
372 
               WinnerIdx [ii] = ii;
373 
               StepIdx   [ii] = LoopCount;
374 
            }
375 
         }else{
376 
            for(ii=0; ii<(syndromeLength/4); ii++){
377 
               fprintf(OutFileDegree, "wire [%d:0]   winner%dStep%d;\n", degreeIdx-1, ii, LoopCount);
378 
               fprintf(OutFileDegree, "assign winner%dStep%d =", ii, LoopCount);
379 
               fprintf(OutFileDegree, "(polynom_%d [%d:0] == %d'd0) ? ", (ii*2)+1,bitSymbol-1,bitSymbol );
380 
               fprintf(OutFileDegree, "((polynom_%d [%d:0] == %d'd0) ? %d'd0 : %d'd%d)", (ii*2),bitSymbol-1,bitSymbol, degreeIdx,degreeIdx, ii*2 );
381 
               fprintf(OutFileDegree, ":  %d'd%d;\n", degreeIdx,(ii*2)+1 );
382 
 
383 
               LastStep = ii;
384 
               LastIdx  = LoopCount;
385 
 
386 
               WinnerIdx [ii] = ii;
387 
               StepIdx   [ii] = LoopCount;
388 
            }
389 
               fprintf(OutFileDegree, "wire [%d:0]   winner%dStep%d;\n", degreeIdx-1, (syndromeLength/4), LoopCount);
390 
               fprintf(OutFileDegree, "assign winner%dStep%d =", (syndromeLength/4), LoopCount);
391 
               if ( ((ii*2)) < (syndromeLength/2)){
392 
                  fprintf(OutFileDegree, "(polynom_%d [%d:0] == %d'd0) ? ", (ii*2)+1,bitSymbol-1,bitSymbol );
393 
                  fprintf(OutFileDegree, "((polynom_%d [%d:0] == %d'd0) ? %d'd0 : %d'd%d)", (ii*2),bitSymbol-1,bitSymbol, degreeIdx,degreeIdx, ii*2 );
394 
               fprintf(OutFileDegree, ":  %d'd%d;\n", degreeIdx,(ii*2)+1 );
395 
               }else{
396 
//                  fprintf(OutFileDegree, "(polynom_%d [%d:0] == %d'd0) ? %d'd0 : %d'd%d;\n", (syndromeLength/2),bitSymbol-1,bitSymbol , bitSymbol, degreeIdx, (syndromeLength/2));
397 
                  fprintf(OutFileDegree, "(polynom_%d [%d:0] == %d'd0) ? %d'd0 : %d'd%d;\n", (syndromeLength/2),bitSymbol-1,bitSymbol , degreeIdx, degreeIdx, (syndromeLength/2));
398 
               }
399 
               LastStep = (syndromeLength/4);
400 
               LastIdx  = LoopCount;
401 
 
402 
               WinnerIdx [(syndromeLength/4)] = ii;
403 
               StepIdx   [(syndromeLength/4)] = LoopCount;
404 
 
405 
         }
406 
      }
407 
      //---------------------------------------------------------------
408 
      //---------------------------------------------------------------
409 
      else{
410 
         for(ii=0; ii<(ChallengerNb/2); ii++){
411 
            fprintf(OutFileDegree, "wire [%d:0]   winner%dStep%d;\n", degreeIdx-1, ii, LoopCount);
412 
            fprintf(OutFileDegree, "assign winner%dStep%d =", ii, LoopCount);
413 
            fprintf(OutFileDegree, "( winner%dStep%d [%d:0] < winner%dStep%d  [%d:0]) ? ", WinnerIdx[(ii*2)+1], StepIdx[(ii*2)+1],degreeIdx-1, WinnerIdx[(ii*2)], StepIdx[(ii*2)],degreeIdx-1);
414 
            fprintf(OutFileDegree, "winner%dStep%d  [%d:0]", WinnerIdx[(ii*2)], StepIdx[(ii*2)],degreeIdx-1);
415 
            fprintf(OutFileDegree, ":  winner%dStep%d  [%d:0];\n", WinnerIdx[(ii*2)+1], StepIdx[(ii*2)+1] ,degreeIdx-1);
416 
 
417 
            NextWinnerIdx [ii] = ii;
418 
            NextStepIdx   [ii] = LoopCount;
419 
            LastStep = ii;
420 
            LastIdx  = LoopCount;
421 
         }
422 
 
423 
 
424 
 
425 
      //---------------------------------------------------------------
426 
      //---------------------------------------------------------------
427 
      if (ChallengerNb % 2 == 0){
428 
         for(ii=0; ii<syndromeLength; ii++){
429 
            WinnerIdx [ii] = 0;
430 
            StepIdx   [ii] = 0;
431 
         }
432 
         for(ii=0; ii<syndromeLength; ii++){
433 
            WinnerIdx [ii] = NextWinnerIdx [ii];
434 
            StepIdx   [ii] = NextStepIdx   [ii];
435 
         }
436 
         for(ii=0; ii<syndromeLength; ii++){
437 
            NextWinnerIdx [ii] = 0;
438 
            NextStepIdx   [ii] = 0;
439 
         }
440 
      }else{
441 
      //---------------------------------------------------------------
442 
      //---------------------------------------------------------------
443 
            NextWinnerIdx [ChallengerNb/2] = WinnerIdx [ChallengerNb-1];
444 
            NextStepIdx   [ChallengerNb/2] = StepIdx   [ChallengerNb-1];
445 
 
446 
 
447 
            for(ii=0; ii<syndromeLength; ii++){
448 
               WinnerIdx [ii] = 0;
449 
               StepIdx   [ii] = 0;
450 
            }
451 
            for(ii=0; ii<syndromeLength; ii++){
452 
              WinnerIdx [ii] = NextWinnerIdx [ii];
453 
              StepIdx   [ii] = NextStepIdx   [ii];
454 
            }
455 
            for(ii=0; ii<syndromeLength; ii++){
456 
               NextWinnerIdx [ii] = 0;
457 
               NextStepIdx   [ii] = 0;
458 
            }
459 
 
460 
      }
461 
 
462 
      }
463 
 
464 
 
465 
 
466 
      //---------------------------------------------------------------
467 
      // Challenger Nb update
468 
      //---------------------------------------------------------------
469 
      if (ChallengerNb % 2 == 0){
470 
         ChallengerNb = ChallengerNb/2;
471 
      }else{
472 
         ChallengerNb = ((ChallengerNb-1)/2)+1;
473 
         oddFlag = 1;
474 
      }
475 
      LoopCount +=1;
476 
 
477 
   }
478 
 
479 
 
480 
 
481 
   fprintf(OutFileDegree, "//---------------------------------------------------------------\n");
482 
   fprintf(OutFileDegree, "//---------------------------------------------------------------\n");
483 
 
484 
/*
485 
   if (syndromeLength > 2047) {
486 
      fprintf(OutFileDegree, "   wire  [11:0]   degreeBETA;\n");
487 
   }
488 
   else if (syndromeLength > 1023) {
489 
      fprintf(OutFileDegree, "   wire  [10:0]   degreeBETA;\n");
490 
   }
491 
   else if (syndromeLength > 511) {
492 
      fprintf(OutFileDegree, "   wire  [9:0]   degreeBETA;\n");
493 
   }
494 
   else if (syndromeLength > 255) {
495 
      fprintf(OutFileDegree, "   wire  [8:0]   degreeBETA;\n");
496 
   }
497 
   else if (syndromeLength > 127) {
498 
      fprintf(OutFileDegree, "   wire  [7:0]   degreeBETA;\n");
499 
   }
500 
   else if (syndromeLength > 63) {
501 
      fprintf(OutFileDegree, "   wire  [6:0]   degreeBETA;\n");
502 
   }
503 
   else if (syndromeLength > 31) {
504 
      fprintf(OutFileDegree, "   wire  [5:0]   degreeBETA;\n");
505 
   }
506 
   else if (syndromeLength > 15) {
507 
      fprintf(OutFileDegree, "   wire  [4:0]   degreeBETA;\n");
508 
   }
509 
   else if (syndromeLength > 7) {
510 
      fprintf(OutFileDegree, "   wire  [3:0]   degreeBETA;\n");
511 
   }
512 
   else if (syndromeLength > 3) {
513 
      fprintf(OutFileDegree, "   wire  [2:0]   degreeBETA;\n");
514 
   }
515 
   else {
516 
      fprintf(OutFileDegree, "   wire  [1:0]   degreeBETA;\n");
517 
   }
518 
   */
519 
//    fprintf(OutFileDegree, "assign degreeBETA [%d:0] =  winner%dStep%d [%d:0] ;\n", degreeIdx-1, LastStep, LastIdx, degreeIdx-1);
520 
    fprintf(OutFileDegree, "assign degree [%d:0] =  winner%dStep%d [%d:0] ;\n", degreeIdx-1, LastStep, LastIdx, degreeIdx-1);
521 
 
522 
 
523 
 
524 
   //---------------------------------------------------------------
525 
   //---------------------------------------------------------------
526 
   //---------------------------------------------------------------
527 
   //---------------------------------------------------------------
528 
   //---------------------------------------------------------------
529 
   //---------------------------------------------------------------
530 
   fprintf(OutFileDegree, "\n\n\n");
531 
   fprintf(OutFileDegree, "endmodule\n");
532 
 
533 
 
534 
   //---------------------------------------------------------------
535 
   // close file
536 
   //---------------------------------------------------------------
537 
   fclose(OutFileDegree);
538 
 
539 
 
540 
   //---------------------------------------------------------------
541 
   // automatically convert Dos mode To Unix mode
542 
   //---------------------------------------------------------------
543 
        char ch;
544 
        char temp[MAX_PATH]="\0";
545 
 
546 
        //Open the file for reading in binarymode.
547 
        ifstream fp_read(strRsDecodeDegree, ios_base::in | ios_base::binary);
548 
        sprintf(temp, "%s.temp", strRsDecodeDegree);
549 
        //Create a temporary file for writing in the binary mode. This
550 
        //file will be created in the same directory as the input file.
551 
        ofstream fp_write(temp, ios_base::out | ios_base::trunc | ios_base::binary);
552 
 
553 
        while(fp_read.eof() != true)
554 
        {
555 
                fp_read.get(ch);
556 
                //Check for CR (carriage return)
557 
                if((int)ch == 0x0D)
558 
                        continue;
559 
                if (!fp_read.eof())fp_write.put(ch);
560 
        }
561 
 
562 
        fp_read.close();
563 
        fp_write.close();
564 
        //Delete the existing input file.
565 
        remove(strRsDecodeDegree);
566 
        //Rename the temporary file to the input file.
567 
        rename(temp, strRsDecodeDegree);
568 
        //Delete the temporary file.
569 
        remove(temp);
570 
 
571 
 
572 
   //---------------------------------------------------------------
573 
   // clean string
574 
   //---------------------------------------------------------------
575 
   free(strRsDecodeDegree);
576 
 
577 
 
578 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.