Mercurial > hg > Members > tobaru > CbC_xv6

comparison src/gearsTools/generate_stub.pl @ 52:214d21c891c7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rename to cbc __ncode is not handled as interfaces
author kono
date Mon, 03 Jun 2019 18:12:44 +0900
parents 9647d79fe97e
children d419660ad71d
comparison
equal deleted inserted replaced
51:fadfd62d6b14 52:214d21c891c7
66 # 66 #
67 # goto nodeStack->push((union Data*)node, stackTest3); 67 # goto nodeStack->push((union Data*)node, stackTest3);
68 # 68 #
69 # generated meta level code 69 # generated meta level code
70 # 70 #
71 # Gearef(context, Stack)->stack = (union Data*)nodeStack; 71 # Gearef(cbc_context, Stack)->stack = (union Data*)nodeStack;
72 # Gearef(context, Stack)->data = (union Data*)node; 72 # Gearef(cbc_context, Stack)->data = (union Data*)node;
73 # Gearef(context, Stack)->next = C_stackTest3; 73 # Gearef(cbc_context, Stack)->next = C_stackTest3;
74 # goto meta(context, nodeStack->push); 74 # goto meta(cbc_context, nodeStack->push);
75 75
76 sub getDataGear { 76 sub getDataGear {
77 my ($filename) = @_; 77 my ($filename) = @_;
78 my ($codeGearName, $name, $inTypedef); 78 my ($codeGearName, $name, $inTypedef);
79 open my $fd,"<",$filename or die("can't open $filename $!"); 79 open my $fd,"<",$filename or die("can't open $filename $!");
220 } 220 }
221 } 221 }
222 222
223 sub generateStub { 223 sub generateStub {
224 my($fd,$prevCodeGearName,$dataGearName) = @_; 224 my($fd,$prevCodeGearName,$dataGearName) = @_;
225 print $fd "__code ", $prevCodeGearName ,"_stub(struct Context* context) {\n"; 225 print $fd "__code ", $prevCodeGearName ,"_stub(struct Context* cbc_context) {\n";
226 print $fd $dataGearName; 226 print $fd $dataGearName;
227 print $fd "\n} \n\n"; 227 print $fd "\n} \n\n";
228 return 1; 228 return 1;
229 } 229 }
230 230
237 } 237 }
238 push @{$dataGearVar{$codeGearName}}, $varname1; 238 push @{$dataGearVar{$codeGearName}}, $varname1;
239 push @{$dataGearVarType{$codeGearName}}, $typeName; 239 push @{$dataGearVarType{$codeGearName}}, $typeName;
240 if ($typeName eq $implementation) { 240 if ($typeName eq $implementation) {
241 # get implementation 241 # get implementation
242 $dataGearName{$codeGearName} .= "\t$typeName* $varName = ($typeName*)GearImpl(context, $interface, $varName);\n"; 242 $dataGearName{$codeGearName} .= "\t$typeName* $varName = ($typeName*)GearImpl(cbc_context, $interface, $varName);\n";
243 } else { 243 } else {
244 # interface var 244 # interface var
245 for my $ivar (keys %{$var{$interface}}) { 245 for my $ivar (keys %{$var{$interface}}) {
246 # input data gear field 246 # input data gear field
247 if ($varName eq $ivar) { 247 if ($varName eq $ivar) {
248 if ($typeName eq $var{$interface}->{$ivar}) { 248 if ($typeName eq $var{$interface}->{$ivar}) {
249 if ($output) { 249 if ($output) {
250 $dataGearName{$codeGearName} .= "\t$typeName$ptrType* O_$varName = &Gearef(context, $interface)->$varName;\n"; 250 $dataGearName{$codeGearName} .= "\t$typeName$ptrType* O_$varName = &Gearef(cbc_context, $interface)->$varName;\n";
251 $outputVar{$codeGearName} .= "\t$typeName$ptrType $varName = *O_$varName;\n"; 251 $outputVar{$codeGearName} .= "\t$typeName$ptrType $varName = *O_$varName;\n";
252 return 1; 252 return 1;
253 } 253 }
254 $dataGearName{$codeGearName} .= "\t$typeName$ptrType $varName = Gearef(context, $interface)->$varName;\n"; 254 $dataGearName{$codeGearName} .= "\t$typeName$ptrType $varName = Gearef(cbc_context, $interface)->$varName;\n";
255 return 1; 255 return 1;
256 } 256 }
257 } 257 }
258 } 258 }
259 259
260 # interface continuation 260 # interface continuation
261 for my $cName (keys %{$code{$interface}}) { 261 for my $cName (keys %{$code{$interface}}) {
262 if ($varName eq $cName) { 262 if ($varName eq $cName) {
263 # continuation field 263 # continuation field
264 $dataGearName{$codeGearName} .= "\tenum Code $varName = Gearef(context, $interface)->$varName;\n"; 264 $dataGearName{$codeGearName} .= "\tenum Code $varName = Gearef(cbc_context, $interface)->$varName;\n";
265 return 1; 265 return 1;
266 } 266 }
267 } 267 }
268 268
269 # par goto var 269 # par goto var
271 # input data gear field 271 # input data gear field
272 if ($varName eq $var) { 272 if ($varName eq $var) {
273 my ($type, $count) = split(/\s/, $codeGear{$codeGearName}->{"var"}->{$var}); 273 my ($type, $count) = split(/\s/, $codeGear{$codeGearName}->{"var"}->{$var});
274 if ($typeName eq $type) { 274 if ($typeName eq $type) {
275 if ($output) { 275 if ($output) {
276 $dataGearName{$codeGearName} .= "\t$typeName$ptrType* O_$varName = ($typeName $ptrType*)&context->data[context->odg + $count];\n"; 276 $dataGearName{$codeGearName} .= "\t$typeName$ptrType* O_$varName = ($typeName $ptrType*)&cbc_context->data[cbc_context->odg + $count];\n";
277 $outputVar{$codeGearName} .= "\t$typeName$ptrType $varName = *O_$varName;\n"; 277 $outputVar{$codeGearName} .= "\t$typeName$ptrType $varName = *O_$varName;\n";
278 return 1; 278 return 1;
279 } 279 }
280 $dataGearName{$codeGearName} .= "\t$typeName$ptrType $varName = &context->data[context->idg + $count]->$typeName;\n"; 280 $dataGearName{$codeGearName} .= "\t$typeName$ptrType $varName = &cbc_context->data[cbc_context->idg + $count]->$typeName;\n";
281 return 1; 281 return 1;
282 } 282 }
283 } 283 }
284 } 284 }
285 285
286 # par goto continuation 286 # par goto continuation
287 for my $cName (keys %{$codeGear{$codeGearName}->{"code"}}) { 287 for my $cName (keys %{$codeGear{$codeGearName}->{"code"}}) {
288 if ($varName eq $cName) { 288 if ($varName eq $cName) {
289 # continuation field 289 # continuation field
290 $dataGearName{$codeGearName} .= "\tenum Code $varName = context->next;\n"; 290 $dataGearName{$codeGearName} .= "\tenum Code $varName = cbc_context->next;\n";
291 return 1; 291 return 1;
292 } 292 }
293 } 293 }
294 294
295 # par goto continuation 295 # par goto continuation
296 # global or local variable case 296 # global or local variable case
297 if ($typeName eq "Code") { 297 if ($typeName eq "Code") {
298 $dataGearName{$codeGearName} .= "\tenum $typeName$ptrType $varName = Gearef(context, $interface)->$varName;\n"; 298 $dataGearName{$codeGearName} .= "\tenum $typeName$ptrType $varName = Gearef(cbc_context, $interface)->$varName;\n";
299 return 1; 299 return 1;
300 } 300 }
301 $dataGearName{$codeGearName} .= "\t$typeName$ptrType $varName = Gearef(context, $typeName);\n"; 301 $dataGearName{$codeGearName} .= "\t$typeName$ptrType $varName = Gearef(cbc_context, $typeName);\n";
302 return 1; 302 return 1;
303 } 303 }
304 } 304 }
305 305
306 sub generateDataGear { 306 sub generateDataGear {
330 my $prevCodeGearName; 330 my $prevCodeGearName;
331 my $inTypedef = 0; 331 my $inTypedef = 0;
332 my $inStub = 0; 332 my $inStub = 0;
333 my $hasParGoto = 0; 333 my $hasParGoto = 0;
334 my $inMain = 0 ; 334 my $inMain = 0 ;
335 my $inCode = 0 ;
335 my %stub; 336 my %stub;
336 my $codeGearName; 337 my $codeGearName;
337 my %localVarType; 338 my %localVarType;
339 my %localCode;
338 340
339 while (<$in>) { 341 while (<$in>) {
340 if (! $inTypedef && ! $inStub && ! $inMain) { 342 if (! $inTypedef && ! $inStub && ! $inMain) {
341 if (/^typedef struct (\w+) \{/) { 343 if (/^typedef struct (\w+) \{/) {
342 $inTypedef = 1; 344 $inTypedef = 1;
344 $inMain = 1; 346 $inMain = 1;
345 } elsif(/^#interface "(.*)"/) { 347 } elsif(/^#interface "(.*)"/) {
346 my $interfaceHeader = $1; 348 my $interfaceHeader = $1;
347 # #interface not write 349 # #interface not write
348 next unless ($interfaceHeader =~ /context.h/); 350 next unless ($interfaceHeader =~ /context.h/);
351 } elsif (/^\s\s*_\_code (\w+)\((.*)\)(.*)/) {
352 $localCode{$1} = 1;
353 } elsif (/^\s\s*_\_code *\(\s*\*\s*(\w+)\)\((.*)\)(.*)/) {
354 $localCode{$1} = 1;
349 } elsif (/^\_\_code (\w+)\((.*)\)(.*)/) { 355 } elsif (/^\_\_code (\w+)\((.*)\)(.*)/) {
356 $inCode = 1;
357 %localCode = {};
350 %localVarType = {}; 358 %localVarType = {};
351 $codeGearName = $1; 359 $codeGearName = $1;
352 my $args = $2; 360 my $args = $2;
353 my $tail = $3; 361 my $tail = $3;
354 if ($codeGearName =~ /_stub$/) { 362 if ($codeGearName =~ /_stub$/) {
374 # __code next(...) ---> enum Code next 382 # __code next(...) ---> enum Code next
375 $prevCodeGearName = $codeGearName; 383 $prevCodeGearName = $codeGearName;
376 $dataGearVar{$codeGearName} = []; 384 $dataGearVar{$codeGearName} = [];
377 $outputVar{$codeGearName} = ""; 385 $outputVar{$codeGearName} = "";
378 $outputArgs{$codeGearName} = {}; 386 $outputArgs{$codeGearName} = {};
379 my $newArgs = "struct Context *context,"; 387 my $newArgs = "struct Context *cbc_context,";
380 if ($args=~/^struct Context\s*\*\s*context/) { 388 if ($args=~/^struct Context\s*\*\s*cbc_context/) {
381 $newArgs = ""; 389 $newArgs = "";
382 } 390 }
383 if (!$args){ 391 if (!$args){
384 $newArgs = "struct Context *context"; 392 $newArgs = "struct Context *cbc_context";
385 } 393 }
386 while($args) { 394 while($args) {
387 if ($args =~ s/(^\s*,\s*)//) { 395 if ($args =~ s/(^\s*,\s*)//) {
388 $newArgs .= $1; 396 $newArgs .= $1;
389 } 397 }
425 $newArgs .= $args; 433 $newArgs .= $args;
426 last; 434 last;
427 } 435 }
428 } 436 }
429 # generate goto statement from stub to the CodeGear in the buffer 437 # generate goto statement from stub to the CodeGear in the buffer
430 $dataGearName{$codeGearName} .= "\tgoto $codeGearName(context"; 438 $dataGearName{$codeGearName} .= "\tgoto $codeGearName(cbc_context";
431 for my $arg ( @{$dataGearVar{$codeGearName}}) { 439 for my $arg ( @{$dataGearVar{$codeGearName}}) {
432 $dataGearName{$codeGearName} .= ", $arg"; 440 $dataGearName{$codeGearName} .= ", $arg";
433 } 441 }
434 $dataGearName{$codeGearName} .= ");"; 442 $dataGearName{$codeGearName} .= ");";
435 # generate CodeGear header with new arguments 443 # generate CodeGear header with new arguments
437 if ($outputVar{$codeGearName} ne "") { 445 if ($outputVar{$codeGearName} ne "") {
438 # output data var can be use before write 446 # output data var can be use before write
439 # it should be initialze by gearef 447 # it should be initialze by gearef
440 print $fd $outputVar{$codeGearName}; 448 print $fd $outputVar{$codeGearName};
441 } 449 }
450 next;
451 } elsif (! $inCode) {
452 print $fd $_;
442 next; 453 next;
443 } elsif (/^(.*)goto (\w+)\-\>(\w+)\((.*)\);/) { 454 } elsif (/^(.*)goto (\w+)\-\>(\w+)\((.*)\);/) {
444 # handling goto statement 455 # handling goto statement
445 # convert it to the meta call form with two arugments, that is context and enum Code 456 # convert it to the meta call form with two arugments, that is context and enum Code
446 my $prev = $1; 457 my $prev = $1;
447 my $next = $2; 458 my $next = $2;
448 my $method = $3; 459 my $method = $3;
449 my $tmpArgs = $4; 460 my $tmpArgs = $4;
450 $tmpArgs =~ s/\(.*\)/\(\)/; 461 $tmpArgs =~ s/\(.*\)/\(\)/;
451 my @args = split(/,/,$tmpArgs); 462 my @args = split(/,/,$tmpArgs);
463 if (! defined $dataGearVarType{$codeGearName}) {
464 print $fd $_ ;
465 next ;
466 }
452 my @types = @{$dataGearVarType{$codeGearName}}; 467 my @types = @{$dataGearVarType{$codeGearName}};
453 my $ntype; 468 my $ntype;
454 my $ftype; 469 my $ftype;
455 for my $v (@{$dataGearVar{$codeGearName}}) { 470 for my $v (@{$dataGearVar{$codeGearName}}) {
456 my $t = shift @types; 471 my $t = shift @types;
461 } 476 }
462 if (!defined $ntype) { 477 if (!defined $ntype) {
463 $ntype = $localVarType{$next}; 478 $ntype = $localVarType{$next};
464 $ftype = lcfirst($ntype); 479 $ftype = lcfirst($ntype);
465 } 480 }
466 print $fd "\tGearef(context, $ntype)->$ftype = (union Data*) $next;\n"; 481 print $fd "\tGearef(cbc_context, $ntype)->$ftype = (union Data*) $next;\n";
467 # Put interface argument 482 # Put interface argument
468 my $prot = $code{$ntype}->{$method}; 483 my $prot = $code{$ntype}->{$method};
469 my $i = 1; 484 my $i = 1;
470 for my $arg (@args) { 485 for my $arg (@args) {
471 my $pType; 486 my $pType;
476 $pType = $1; 491 $pType = $1;
477 $pName = $2; 492 $pName = $2;
478 $arg =~ s/^(\s)*(\w+)/$2/; 493 $arg =~ s/^(\s)*(\w+)/$2/;
479 if ($pType =~ s/\_\_code$//) { 494 if ($pType =~ s/\_\_code$//) {
480 if ($arg =~ /(\w+)\(.*\)/) { 495 if ($arg =~ /(\w+)\(.*\)/) {
481 print $fd "\tGearef(context, $ntype)->$pName = $1;\n"; 496 print $fd "\tGearef(cbc_context, $ntype)->$pName = $1;\n";
482 } else { 497 } else {
483 print $fd "\tGearef(context, $ntype)->$pName = C_$arg;\n"; 498 print $fd "\tGearef(cbc_context, $ntype)->$pName = C_$arg;\n";
484 } 499 }
485 } elsif ($pType =~ /Data\**$/){ 500 } elsif ($pType =~ /Data\**$/){
486 print $fd "\tGearef(context, $ntype)->$pName = (union $pType) $arg;\n"; 501 print $fd "\tGearef(cbc_context, $ntype)->$pName = (union $pType) $arg;\n";
487 } else { 502 } else {
488 print $fd "\tGearef(context, $ntype)->$pName = $arg;\n"; 503 print $fd "\tGearef(cbc_context, $ntype)->$pName = $arg;\n";
489 } 504 }
490 $i++; 505 $i++;
491 } 506 }
492 print $fd "${prev}context->before = C_$codeGearName;\n"; 507 # print $fd "${prev}cbc_context->before = C_$codeGearName;\n";
493 print $fd "${prev}goto meta(context, $next->$method);\n"; 508 print $fd "${prev}goto meta(cbc_context, $next->$method);\n";
494 next; 509 next;
495 } elsif(/^(.*)par goto (\w+)\((.*)\);/) { 510 } elsif(/^(.*)par goto (\w+)\((.*)\);/) {
496 # handling par goto statement 511 # handling par goto statement
497 # convert it to the parallel 512 # convert it to the parallel
498 my $prev = $1; 513 my $prev = $1;
513 if (! $hasParGoto) { 528 if (! $hasParGoto) {
514 $hasParGoto = 1; 529 $hasParGoto = 1;
515 print $fd "${prev}struct Element* element;\n"; 530 print $fd "${prev}struct Element* element;\n";
516 } 531 }
517 my $initTask = << "EOFEOF"; 532 my $initTask = << "EOFEOF";
518 ${prev}context->task = NEW(struct Context); 533 ${prev}cbc_context->task = NEW(struct Context);
519 ${prev}initContext(context->task); 534 ${prev}initContext(cbc_context->task);
520 ${prev}context->task->next = C_$codeGearName; 535 ${prev}cbc_context->task->next = C_$codeGearName;
521 ${prev}context->task->idgCount = $inputCount; 536 ${prev}cbc_context->task->idgCount = $inputCount;
522 ${prev}context->task->idg = context->task->dataNum; 537 ${prev}cbc_context->task->idg = cbc_context->task->dataNum;
523 ${prev}context->task->maxIdg = context->task->idg + $inputCount; 538 ${prev}cbc_context->task->maxIdg = cbc_context->task->idg + $inputCount;
524 ${prev}context->task->odg = context->task->maxIdg; 539 ${prev}cbc_context->task->odg = cbc_context->task->maxIdg;
525 ${prev}context->task->maxOdg = context->task->odg + $outputCount; 540 ${prev}cbc_context->task->maxOdg = cbc_context->task->odg + $outputCount;
526 EOFEOF 541 EOFEOF
527 print $fd $initTask; 542 print $fd $initTask;
528 if (@iterateCounts) { 543 if (@iterateCounts) {
529 print $fd "${prev}context->task->iterate = 0;\n"; 544 print $fd "${prev}cbc_context->task->iterate = 0;\n";
530 my $len = @iterateCounts; 545 my $len = @iterateCounts;
531 if ($len == 1) { 546 if ($len == 1) {
532 print $fd "${prev}context->task->iterator = createMultiDimIterator(context, $iterateCounts[0], 1, 1);\n"; 547 print $fd "${prev}cbc_context->task->iterator = createMultiDimIterator(cbc_context, $iterateCounts[0], 1, 1);\n";
533 } elsif ($len == 2) { 548 } elsif ($len == 2) {
534 print $fd "${prev}context->task->iterator = createMultiDimIterator(context, $iterateCounts[0], $iterateCounts[1], 1);\n"; 549 print $fd "${prev}cbc_context->task->iterator = createMultiDimIterator(cbc_context, $iterateCounts[0], $iterateCounts[1], 1);\n";
535 } elsif ($len == 3) { 550 } elsif ($len == 3) {
536 print $fd "${prev}context->task->iterator = createMultiDimIterator(context, $iterateCounts[0], $iterateCounts[1], $iterateCounts[2]);\n"; 551 print $fd "${prev}cbc_context->task->iterator = createMultiDimIterator(cbc_context, $iterateCounts[0], $iterateCounts[1], $iterateCounts[2]);\n";
537 } 552 }
538 } 553 }
539 for my $dataGear (@dataGears) { 554 for my $dataGear (@dataGears) {
540 print $fd "${prev}GET_META($dataGear)->wait = createSynchronizedQueue(context);\n"; 555 print $fd "${prev}GET_META($dataGear)->wait = createSynchronizedQueue(cbc_context);\n";
541 } 556 }
542 for my $i (0..$inputCount-1) { 557 for my $i (0..$inputCount-1) {
543 print $fd "${prev}context->task->data[context->task->idg+$i] = (union Data*)@dataGears[$i];\n"; 558 print $fd "${prev}cbc_context->task->data[cbc_context->task->idg+$i] = (union Data*)@dataGears[$i];\n";
544 } 559 }
545 for my $i (0..$outputCount-1) { 560 for my $i (0..$outputCount-1) {
546 print $fd "${prev}context->task->data[context->task->odg+$i] = (union Data*)@dataGears[$inputCount+$i];\n"; 561 print $fd "${prev}cbc_context->task->data[cbc_context->task->odg+$i] = (union Data*)@dataGears[$inputCount+$i];\n";
547 } 562 }
548 my $putTask = << "EOFEOF"; 563 my $putTask = << "EOFEOF";
549 ${prev}element = &ALLOCATE(context, Element)->Element; 564 ${prev}element = &ALLOCATE(cbc_context, Element)->Element;
550 ${prev}element->data = (union Data*)context->task; 565 ${prev}element->data = (union Data*)cbc_context->task;
551 ${prev}element->next = context->taskList; 566 ${prev}element->next = cbc_context->taskList;
552 ${prev}context->taskList = element; 567 ${prev}cbc_context->taskList = element;
553 EOFEOF 568 EOFEOF
554 print $fd $putTask; 569 print $fd $putTask;
555 next; 570 next;
556 } elsif (/^(.*)goto (\w+)\((.*)\);/) { 571 } elsif (/^(.*)goto (\w+)\((.*)\);/) {
557 # handling goto statement 572 # handling goto statement
558 # convert it to the meta call form with two arugments, that is context and enum Code 573 # convert it to the meta call form with two arugments, that is context and enum Code
559 my $prev = $1; 574 my $prev = $1;
560 my $next = $2; 575 my $next = $2;
561 my @args = split(/,/, $3); 576 my @args = split(/,/, $3);
562 my $v = 0; 577 my $v = 0;
578 if (defined $localCode{$next}) {
579 print $fd $_; next;
580 }
563 for my $n ( @{$dataGearVar{$codeGearName}} ) { 581 for my $n ( @{$dataGearVar{$codeGearName}} ) {
564 # continuation arguments 582 # continuation arguments
565 $v = 1 if ( $n eq $next); 583 $v = 1 if ( $n eq $next);
566 } 584 }
567 if ($v || defined $code{$interface}->{$next}) { 585 if ($v || defined $code{$interface}->{$next}) {
570 for my $arg ( @{$outputArgs{$codeGearName}->{$next}} ) { 588 for my $arg ( @{$outputArgs{$codeGearName}->{$next}} ) {
571 my $v = shift(@args); 589 my $v = shift(@args);
572 print $fd "\t*O_$arg = $v;\n"; 590 print $fd "\t*O_$arg = $v;\n";
573 } 591 }
574 if ($hasParGoto) { 592 if ($hasParGoto) {
575 print $fd "${prev}Gearef(context, TaskManager)->taskList = context->taskList;\n"; 593 print $fd "${prev}Gearef(cbc_context, TaskManager)->taskList = cbc_context->taskList;\n";
576 print $fd "${prev}Gearef(context, TaskManager)->next1 = C_$next;\n"; 594 print $fd "${prev}Gearef(cbc_context, TaskManager)->next1 = C_$next;\n";
577 print $fd "${prev}goto meta(context, C_$next);\n"; 595 print $fd "${prev}goto meta(cbc_context, C_$next);\n";
578 } else { 596 } else {
579 print $fd "${prev}context->before = C_$codeGearName;\n"; 597 # print $fd "${prev}cbc_context->before = C_$codeGearName;\n";
580 print $fd "${prev}goto meta(context, $next);\n"; 598 print $fd "${prev}goto meta(cbc_context, $next);\n";
581 } 599 }
582 next; 600 next;
583 } 601 }
584 if ($hasParGoto) { 602 if ($hasParGoto) {
585 print $fd "${prev}Gearef(context, TaskManager)->taskList = context->taskList;\n"; 603 print $fd "${prev}Gearef(cbc_context, TaskManager)->taskList = cbc_context->taskList;\n";
586 print $fd "${prev}Gearef(context, TaskManager)->next1 = C_$next;\n"; 604 print $fd "${prev}Gearef(cbc_context, TaskManager)->next1 = C_$next;\n";
587 print $fd "${prev}goto parGotoMeta(context, C_$next);\n"; 605 print $fd "${prev}goto parGotoMeta(cbc_context, C_$next);\n";
588 next; 606 next;
589 } elsif ($next eq "meta") { 607 } elsif ($next eq "meta") {
590 print $fd $_; 608 print $fd $_;
591 next; 609 next;
592 } else { 610 } else {
593 print $fd "${prev}context->before = C_$codeGearName;\n"; 611 # print $fd "${prev}cbc_context->before = C_$codeGearName;\n";
594 print $fd "${prev}goto meta(context, C_$next);\n"; 612 print $fd "${prev}goto meta(cbc_context, C_$next);\n";
595 next; 613 next;
596 } 614 }
597 } elsif(/^.*(struct|union)?\s(\w+)\*\s(\w+)\s?[=;]/) { 615 } elsif(/^.*(struct|union)?\s(\w+)\*\s(\w+)\s?[=;]/) {
598 my $type = $2; 616 my $type = $2;
599 my $varName = $3; 617 my $varName = $3;
600 $localVarType{$varName} = $type; 618 $localVarType{$varName} = $type;
601 s/new\s+(\w+)\(\)/\&ALLOCATE(context, \1)->\1/g; # replacing new 619 s/new\s+(\w+)\(\)/\&ALLOCATE(cbc_context, \1)->\1/g; # replacing new
602 } elsif(/^}/) { 620 } elsif(/^}/) {
603 $hasParGoto = 0; 621 $hasParGoto = 0;
604 } else { 622 } else {
605 s/new\s+(\w+)\(\)/\&ALLOCATE(context, \1)->\1/g; # replacing new 623 s/new\s+(\w+)\(\)/\&ALLOCATE(cbc_context, \1)->\1/g; # replacing new
606 } 624 }
607 # gather type name and type 625 # gather type name and type
608 } elsif ($inMain) { 626 } elsif ($inMain) {
609 if (/^(.*)goto start_code\(main_context\);/) { 627 if (/^(.*)goto start_code\(main_context\);/) {
610 print $fd $_; 628 print $fd $_;
612 } elsif (/^(.*)goto (\w+)\((.*)\);/) { 630 } elsif (/^(.*)goto (\w+)\((.*)\);/) {
613 my $prev = $1; 631 my $prev = $1;
614 my $next = $2; 632 my $next = $2;
615 print $fd "${prev}struct Context* main_context = NEW(struct Context);\n"; 633 print $fd "${prev}struct Context* main_context = NEW(struct Context);\n";
616 print $fd "${prev}initContext(main_context);\n"; 634 print $fd "${prev}initContext(main_context);\n";
617 print $fd "${prev}main_context->next = C_$next;\n"; 635 print $fd "${prev}main_cbc_context->next = C_$next;\n";
618 print $fd "${prev}goto start_code(main_context);\n"; 636 print $fd "${prev}goto start_code(main_context);\n";
619 next; 637 next;
620 } 638 }
621 } 639 }
622 if (/^}/) { 640 if (/^}/) {
623 $inStub = 0; 641 $inStub = 0;
624 $inTypedef = 0; 642 $inTypedef = 0;
625 $inMain = 0; 643 $inMain = 0;
644 $inCode = 0;
626 } 645 }
627 print $fd $_; 646 print $fd $_;
628 } 647 }
629 if (defined $prevCodeGearName) { 648 if (defined $prevCodeGearName) {
630 if (!defined $stub{$prevCodeGearName."_stub"}) { 649 if (!defined $stub{$prevCodeGearName."_stub"}) {