Công cụ bảo vệ mã nguồn .NET mạnh nhất, không thể unpack, miễn phí cho các khách hàng đầu tiên đăng ký.
Trang 1 trên tổng số 2 12 Cuối cùngCuối cùng
Từ 1 tới 10 trên tổng số 13 kết quả

Đề tài: Mã nguồn C | Chương trình chuyển code Pascal sang C

  1. #1
    Ngày gia nhập
    12 2007
    Bài viết
    224

    Mặc định Mã nguồn C | Chương trình chuyển code Pascal sang C

    Giới thiệu

    Pascal 2 C Converter



    This program converts simple standard Pascal programs to C language.


    How does the program work from a general approach?

    v First Step: it will open the source file and will read till maximum of “MAX” characters or till the return character “\n” and will store it in a suitable buffer.

    v Second Step: it will look for matching supported keywords (Pascal commands) in the buffer.

    v Third Step: regarding to the specific keyword, program will process and convert it to a C language command; with applying various text processing functions.
    During this step program will keep track & handle most of possible error regarding to program limitations or source syntax errors. (Pyramid Block Diagram – Page: 6)

    v Fourth Step: At the end of this step program will store the converted text of read buffer into write buffer.

    v Fifth Step: program will write processed buffer to destination file.

    (Radial Block Diagram - page: 5)



    Main Text Processing Functions:

    1) SmartTrim
    a. This function will trim space “ “and tab “\t” in read buffer except in messages and comments.
    b. It will keep track of tabs for destination code human readability.

    2) InStrSPos
    a. This function will find the position of a char. Array in another char. Array from initial position of searching.

    3) ReplaceS
    a. This function will find a char. Array in destination char. Array and will replace it with source char. Array from given position.
    4) Mid
    a. This function will return the char. Array from specified start & end positions of given char. Array.

    5) InsertS
    a. This function will insert (overwrite) given char. Array to specified position of destination char. Array.
    b. This function can also be used for specific text deletion from a char. Array.

    6) AppendS
    a. This function will append a char. Array to specified position of destination char. Array.

    7) MoveS
    a. This function will move (swap) a char. Array from destination char. Array to specified position of that.


    General Conversion Method:

    I designed two methods for doing this task

    1) Direct Conversion:
    In this method read buffer “buffr” will be converted to C code directly with using text processing tools.

    2) Indirect Conversion:
    In this method write buffer “buffw” will be created regarding to specific C structure.

    3) Mixed Mode:
    In this method we use a combination of Direct Conversion & Indirect Conversion

    Each method is suitable for some statements.



    Visualization, Precision and Error Handling:

    This implantation will detect almost all using of unsupported commands or exceeding program limitations.

    While converting process it will print each line of Pascal code and converted C code in human readable form to the screen so it would very easy to follow and analyze program functioning.

    You will receive an error message if algorithm detects syntax error in your source code.
    Error Message will inform you the line caused the error.
    Specified error will be logged in the corresponding line of destination file in comment form.

    You will receive a warning message if you exceed program limitations.
    Warning Message will inform the line caused the warning.
    Specified warning will be logged in the corresponding line of destination file in comment form.

    Program will keep track of all occurred errors & warnings at the end of conversion process it will print total number of them.


    Supported Commands & Limitations:


    Variables (Arrays) Global/Local, Constants, Arrays
    · Only integer, real, char data types is supported for variables.
    · Arrays Indexed from 1 is supported.
    · One dimensional array of (integer, real, char) is supported.
    · Global variables should be defined before functions or procedures.
    · Local variables should be defined inside functions or procedures.
    · Variables SHOULD NOT defined after ending of a function or procedure.
    · Precedence of local & global variables is supported.

    if, if - else, while, for
    · Any combination of listed operators & operations can be applied without any restrictions
    · Use "BEGIN" & "END" keywords ONLY in a separate line for each command above.
    · Statements MUST BE written in a separate line.

    Procedure & functions
    · Procedure or function name can't contain Pascal keywords.
    · Only one level procedures & functions are supported.
    · (E.g. procedure in procedure isn't supported!)
    · Only definition of one variable is supported in parameter list.
    · Function type can only be defined as (integer, real, char).
    · Using of var inside the parameter list is not supported.
    · Arrays are not supported in parameter list or function type.

    read, readln
    · Can only read directly into variables and arrays.
    · Only one variable is supported for each command.

    write writeln
    · Messages are supported using this pattern:
    · Write(‘message’, variable);
    · Can print only the variables.
    · Only one variable is supported for each command.
    · Operands aren't supported.
    · variable:n is not supported.
    · Operands & operations aren't supported.
    · Function call inside commands isn't supported.

    Comments
    · Only in separate lines.
    · Comments should start & finish in the same line.
    · And using this pattern: {e.g. comments ...}

    Operators:
    · >, <, <=, >=, <> ,:=, =, AND, OR, NOT

    Operations:
    · +, -, *, /, DIV, MOD


    Necessary Conditions of Conversion:

    · Each command should be written in a separate line.
    · Comments are supported only in separate lines.
    · Maximum no. of global or local variables, functions, procedures, shouldn’t exceed "VAS" for
    each type.
    · Maximum Size for name of variables, functions, procedures shouldn't exceed "VSS" for each
    type.
    · Each program line can contain maximum of "MAX" characters.

    Function Listing & Description:


    · int InStrSPos(char *MainStr,char *SubStr,int SPos);
    Returns position of first occurence of "SubStr" in "MainStr" from position "SPos"; if FALSE it will
    return -1

    · int InStrPos(char *MainStr,char *SubStr);
    Returns position of first occurrence of "SubStr" in "MainStr" from position 0 ;if FALSE it will return -1

    · char *Left(char *str,int end);
    Returns char. array of "str" from position 0 to "end"

    · char *Mid(char *str,int start,int end);
    Returns char. array of "str" from "start" to "end"

    · char *SmartTrim(char *str);
    Returns trimed char. array of "str"

    · char *Trim(char *str);
    Returns trimmed char. array of "str"

    · char *ReplaceS(char *MainStr,char *FindS, char *RSub,int SPos, int EPos);
    Finds "FindS" in "MainStr" from position "SPos" to "EPos" and replace it with "RSub" and returns the modified char. Array

    · char *MoveS(char *MainStr,int MPos,int MLenght, int TPos);
    Moves "MLength" from position "MPos" from string "MainStr" to position "TPos" and returns the modified char. Array

    · char *TrimPos(char *MainStr,int SPos, int TLength);
    Trims "MainStr" from position "TPos" and length of "TLength" and returns the modified char. Array

    · char *InsertS(char *MainStr,char *AStr,int SPos,int TP);
    Overwrites "MainStr" by "AStr" from the position "SPos" and returns the modified char. Array

    · char *AppendS(char *MainStr,char *AppS,int AppPos);
    Appends "AppS" to "MainStr" from position "APos" and returns the modified char. Array

    · void TabWriter();
    Writes required "\t" (tab) to destination file


    · void DataFlush(int Rt);
    Flushes the data in specified “Rt” char. Arrays

    · void PF(char *TempStr);
    Converts the specific data type of "TempStr" (real;integer;char) to C language (float;int;char)

    · void Logical();
    Processes and converts supported operators to C language

    · void VarListMaker(char *VT, char *VI,int LV);
    Generates the Global/Local Variable List

    · void ArrayListMaker(char *VT, char *VI,int LV);
    Generates Global/Local Array List
    Công cụ bảo vệ mã nguồn .NET mạnh nhất hiện tại, miễn phí cho các khách hàng đầu tiên đăng ký.

  2. #2
    Ngày gia nhập
    12 2007
    Bài viết
    224

    Mã nguồn

    C Code:
    1. /*
    2.   This program converts standard pascal program to C language.
    3.  
    4.    #################################
    5.    #   Coded By: Hamed Kalantari;  #
    6.    #      PL: ANSI C;              #
    7.    #   Academic Year: 2004/05;     #
    8.    #   Lecturer: Mr. Zsolt Kohari; #
    9.    #################################
    10.  
    11.    * Neccessary Conditions:
    12.  
    13.   I: Each command should be writen in a separate line.
    14.   II: Comments are suppored only in seprate lines.
    15.  III: Maximum no. of global or local variables, functions, procedures. shouldn't exceed "VAS" for each type in each stage.
    16.   IV: Maximum Size for name of variables, functions, procedures shouldn't exceed "VSS" for each type.
    17.    V: Each line can include only of maximum "MAX" characters.
    18.  
    19.   ** Supported commands are:
    20.  
    21.    I: variables (Arrays) Global/Local, Constants
    22.      - Only integer, real, char datatypes is supported for variables.
    23.      - Arrays Indexed from 1 is supported.
    24.      - One dimensional array of (integer,real,char) is supported.
    25.      - Global variables should be defined before functions or procedures.
    26.      - Local variables should be defined inside functions or procedures.
    27.      - variable SHOULD NOT BE defined after ending of a function or procedure.
    28.      - Precedence of local & global variables is supported.
    29.  
    30.  
    31.   II: if, if - else, while, for
    32.      - Any combination of listed operands & operations (Appendix: I,II) can apply without any restrictions
    33.      - Use "BEGIN" & "END" keywords ONLY in a separate line for each command above.
    34.      - Statements MUST BE written in a separate line.
    35.  
    36.  III: procedures & functions
    37.       - Procedure or function name can't contain pascal keywords.
    38.       - Only one level procedures & functions are supported.
    39.         (e.g. procedure in procedure isn't supported!)
    40.       - Only definition of one variable is supported in parameter list.
    41.       - Function type can only be defined as (integer,real,char).
    42.       - Using of var inside the parameter list is not supported.
    43.       - Arrays are not supported in parameter list or function type.
    44.  
    45.   IV: read, readln
    46.       - Can read only into variables and arrays.
    47.       - Only one variable is supported for this command.
    48.  
    49.    V: write, writeln
    50.       - Messages are supported using this pattern:
    51.         write('message',variable);
    52.       - Can print only the variables.
    53.       - Only one variable is supported for each command.
    54.       - Variable:n is not supported.
    55.       - Operands aren't supported.
    56.       - Function call inside statement isn't supported.
    57.  
    58.   VI: comments
    59.       - Only in separate lines.
    60.       - Comments should start & finish in the same line.
    61.       - General pattern: {e.g. comments ...}
    62.  
    63.  *** Appendix
    64.    I: Operands: >, <, <=, >=, <>, :=, =, AND, OR, NOT
    65.   II: Operations: +, -, *, /, DIV, MOD
    66.  
    67. */
    68.  
    69.  
    70. #include <stdio.h>
    71. #include <string.h>
    72. #include <stdlib.h>
    73. #include <conio.h>
    74. #include <dos.h>
    75.  
    76.  
    77. int InStrSPos(char *MainStr,char *SubStr,int SPos); /* Returns position of first occurence of "SubStr" in "MainStr" from position "SPos"; if FALSE it will return -1 */
    78. int InStrPos(char *MainStr,char *SubStr);  /* Returns position of first occurence of "SubStr" in "MainStr" from position 0 ;if FALSE it will return -1  */
    79. char *Left(char *str,int end); /*Returns char. array of "str" from position 0 to "end" */
    80. char *Mid(char *str,int start,int end); /*Returns char. array of "str" from "start" to "end" */
    81. char *SmartTrim(char *str); /*Returns trimed char. array of "str" */
    82. char *Trim(char *str); /*Returns trimmed char. array of "str" */
    83. char *ReplaceS(char *MainStr,char *FindS, char *RSub,int SPos, int EPos); /* Finds "FindS" in "MainStr" from "SPos" to "EPos"and replace it with "RSub" and returns the modified char. array*/
    84. char *MoveS(char *MainStr,int MPos,int MLenght, int TPos); /* Moves "MLength" from position "MPos" from string "MainStr" to position "TPos" and returns the modified char. array*/
    85. char *TrimPos(char *MainStr,int SPos, int TLength); /* Trims "MainStr" from position "TPos" and length of "TLength" and returns the modified char. array*/
    86. char *InsertS(char *MainStr,char *AStr,int SPos,int TP); /* Overwrites "MainStr" by "AStr" from the position "SPos" and returns the modified char. array*/
    87. char *AppendS(char *MainStr,char *AppS,int AppPos); /* Appends "AppS" to "MainStr" from position "APos" and returns the modified char. array */
    88. void TabWriter(); /* Writes required "\t" (tab) to desination file */
    89. void DataFlush(int Rt); /* Flushes the data in char. arrays */
    90. void PF(char *TempStr); /* Converts the specific data type of "TempStr" (real;integer;char) to C language (float;int;char)*/
    91. void Logical(); /* Process and converts the operands to C language */
    92. void VarListMaker(char *VT, char *VI,int LV); /* Generates the Global/Local Variable List */
    93. void ArrayListMaker(char *VT, char *VI,int LV);/* Generates Global/Local Array List */
    94.  
    95. /* Constants */
    96.  
    97. #define MAX  1001 /* Buffer size */
    98. #define VSS 41    /* Variable Size */
    99. #define VAS 41    /* Variable Array Size */
    100.  
    101. #define MaxL 23
    102. #define LInt 1
    103.  
    104. /* Global Variables */
    105.  
    106. FILE *readf, *writef; /* "readf": Source file, "writef: Destination file */
    107. char ReadFileName[41]="",WriteFileName[41]="";  /* "ReadFileName":Source file; "WriteFileName": Destination file */
    108. char buffr[MAX]="",buffw[MAX]=""; /* "buffr": Read buffer, "buffw": Write buffer */
    109.  
    110. char LocVarList[VSS][VAS], LocVarType[VSS][VAS], LocVarSize[VSS][VAS];  /* Local Variables arrays (Name,Type,Size) */
    111. char GlobVarList[VSS][VAS], GlobVarType[VSS][VAS], GlobVarSize[VSS][VAS]; /* Global Variable arrays (Name,Type,Size) */
    112. char PName[VSS][VAS], FName[VSS][VAS], FType[VSS][VAS]; /* "PName": Procedure name; "FName": Function name; "FType": Function type */
    113.  
    114. char FRS[MAX] = ""; /* Function Return String */
    115. int FRV=0; /* Function Return Value */
    116.  
    117. int l=0,g=0, TabC=0; /* "l": Local Var. counter; "g": Global Var. counter; "TabC": "\t" (tab) counter */
    118. int PC=0,FC=0; /* "PC": Procedure counter; "FC": Function counter */
    119.  
    120. /* "CVE": Conversion Error Indicator */
    121. /* "CVW": Conversion Warning Indicator */
    122.  
    123. int CVE=0,CVW=0;
    124.  
    125. /* Main Block */
    126.  
    127. int main(){
    128.  
    129.  
    130.     /* "PreVar","Var": Variable name; "Message","ErrMsg": Messages; "TempStr": Temporary char. array */
    131.     char PreVar[VSS]="",Var[VSS]="",Message[MAX]="",ErrMsg[MAX]="",TempStr[MAX]="";
    132.  
    133.     char c=0,j=0;
    134.  
    135.     /* "Comment": indicator for comments ("{","}") ins pascal */
    136.     /* "LFB": Line Feed Back */
    137.     /* "TempVal": Temporary Value */
    138.     /* "LC": Line Counter for Standard Screen Display" */
    139.     /* "LineRead": counter of read lines of the source file */
    140.  
    141.     int Comment=0, LFB=0,TempVal=0,LC=0,LineRead=0;
    142.  
    143.     /* "CVEC": Conversion Error Counter */
    144.     /* "CVWC": Conversion Warning Counter */
    145.  
    146.     int CVEC=0,CVWC=0;
    147.     int IG=0; /* Ignore Indicator */
    148.  
    149.     /* "SubProgram": Function or Procedure existance indicator */
    150.     /* "Block": End of "SubProgram" indicator */
    151.  
    152.     int SubProgram=0,Block=0;
    153.  
    154.     clrscr(); /* Clears the screen */
    155.  
    156.     DataFlush(1);
    157.     DataFlush(2);
    158.     DataFlush(3);
    159.  
    160.     printf("Please Enter Pascal file name: ");
    161.     scanf("%s",ReadFileName);
    162.  
    163.     strcpy(WriteFileName,ReadFileName);
    164.     strcat(WriteFileName,".c");
    165.     strcat(ReadFileName,".pas");
    166.  
    167.     readf = fopen(ReadFileName,"r"); /* Opens source file in read only mode */
    168.     if(!readf) {
    169.         printf("ERROR 20: Can't open the source file!!!\n\n");
    170.         printf("ending program...");
    171.         exit(0);
    172.     }
    173.  
    174.     writef = fopen(WriteFileName,"w"); /* Opens destination file in writing mode */
    175.     if (!writef) {
    176.         printf("ERROR 30: Can't create the destination file!!!\n\n");
    177.         printf("ending program...");
    178.         exit(0);
    179.     }
    180.  
    181.     printf("\n");
    182.     printf("Converted file will be saved to: %s\n",WriteFileName);
    183.     printf("Conversion process started for %s >>>>\n\n",ReadFileName);
    184.     LC=6;
    185.  
    186.     fputs("#include <stdio.h>\n",writef);
    187.  
    188.     while(!feof(readf))
    189.     {
    190.         strcpy(buffw,""); /* Empty the write buffer */
    191.         strcpy(buffr,"");
    192.  
    193.         fgets(buffr,MAX,readf); /* Reads from source file with size of "MAX" and store it in "buffr" */
    194.  
    195.         if(InStrPos(buffr,"begin")>=0 && Block==1 && SubProgram==1 && IG==0)
    196.         {
    197.             strcpy(buffr,"#IGNORELINE#");
    198.             IG=1;
    199.         }
    200.  
    201.         LineRead++;
    202.  
    203.         CVE= 1;
    204.         CVW= 0;
    205.  
    206.         printf("%3d: %s",LineRead,buffr);
    207.         if (InStrPos(buffr,"\n")==-1) printf("\n");
    208.  
    209.         if (LC < MaxL) LC++; /* Screen Display Pause */
    210.         else
    211.         {
    212.             printf("Press Enter to Continue ...");
    213.             fflush(stdin);
    214.             c=' ';
    215.             while (c!='\r')
    216.                 c=getch();
    217.                 clrscr();
    218.             LC=LInt;
    219.         }
    220.  
    221.         strcpy(buffr, strupr(buffr)); /* Upper cases all the read buffer contents */
    222.         strcpy(buffr,SmartTrim(buffr)); /* Removes all the space characters from buffer */
    223.  
    224.         if(InStrPos(buffr,"{")>=0)  /*  Comments */
    225.         {
    226.             strcpy(buffr, Mid(buffr,InStrPos(buffr,"{")+1,InStrPos(buffr,"}")-1));
    227.             strcat(buffw,"/*");
    228.             strcat(buffw,buffr);
    229.             strcat(buffw,"*/\n");
    230.             Comment=1;
    231.             CVE=0;
    232.         } else Comment=0;
    233.  
    234.         if (Comment!=1)
    235.         {
    236.  
    237.             if(InStrPos(buffr,"PROGRAM") >=0) /* Program */
    238.                 CVE=0;
    239.  
    240.             if(InStrPos(buffr,"PROCEDURE") >=0) /* Procedure */
    241.             {
    242.                 SubProgram=1;
    243.  
    244.                 if (InStrPos(buffr,",") >= 0 || InStrPos(buffr,"VAR") >=0) CVW=1;
    245.                 if (InStrSPos(buffr,";",InStrPos(buffr,";")+1)>=0) CVW =1;
    246.  
    247.                 strcpy(buffw,"void ");
    248.  
    249.                 if (InStrPos(buffr,"(")>=0)
    250.                     strcpy(PName[PC],Mid(buffr,InStrPos(buffr,"PROCEDURE")+9,InStrPos(buffr,"(")-1));
    251.                 else
    252.                     strcpy(PName[PC],Mid(buffr,InStrPos(buffr,"PROCEDURE")+9,InStrPos(buffr,";")-1));
    253.  
    254.                 strcat(buffw,PName[PC]);
    255.                 PC++;
    256.  
    257.                 if (InStrPos(buffr,");") >=0)
    258.                 {
    259.                     strcat(buffw,"(");
    260.                     strcpy(LocVarList[l],Mid(buffr,InStrPos(buffr,"(")+1,InStrPos(buffr,":")-1));
    261.                     strcpy(TempStr,Mid(buffr, InStrPos(buffr,":")+1,InStrPos(buffr,")")-1));
    262.  
    263.                     PF(TempStr);
    264.                 }
    265.                 else
    266.                 {
    267.                     strcat(buffw,"()\n");
    268.                 }
    269.  
    270.                 CVE=0;
    271.  
    272.                 strcat(buffw,"{\n");
    273.                 Block++;
    274.             }
    275.  
    276.             if(InStrPos(buffr,"FUNCTION") >=0) /* Function */
    277.             {
    278.                 SubProgram=1;
    279.  
    280.                 if (InStrPos(buffr,",") >= 0 || InStrPos(buffr,"VAR") >=0) CVW=1;
    281.                 if (InStrPos(buffr,"):") > InStrPos(buffr,";")) CVW =1;
    282.  
    283.                 if (InStrPos(buffr,"(")>=0) /* Parameter List */
    284.                 {
    285.                     strcpy(TempStr,Mid(buffr,InStrPos(buffr,"):")+2,strlen(buffr)-3));
    286.  
    287.                     if (strcmp(TempStr,"REAL")==0)
    288.                     {
    289.                         strcpy(buffw,"float ");
    290.                         strcpy(FType[FC],"%f");
    291.                     }
    292.  
    293.                     if (strcmp(TempStr,"INTEGER")==0)
    294.                     {
    295.                         strcpy(buffw,"int ");
    296.                         strcpy(FType[FC],"%d");
    297.                     }
    298.  
    299.                     if (strcmp(TempStr,"CHAR")==0)
    300.                     {
    301.                         strcpy(buffw,"char ");
    302.                         strcpy(FType[FC],"%c");
    303.                     }
    304.  
    305.                     /* Function Name */
    306.                     strcpy(FName[FC],Mid(buffr,InStrPos(buffr,"FUNCTION")+8,InStrPos(buffr,"(")-1));
    307.                 }
    308.                 else
    309.                     strcpy(FName[FC],Mid(buffr,InStrPos(buffr,"FUNCTION")+8,InStrPos(buffr,":")-1));
    310.  
    311.                 strcat(buffw,FName[FC]);
    312.                 FC++;
    313.  
    314.                 if (InStrPos(buffr,"(")>=0)
    315.                 {
    316.                     strcat(buffw,"(");
    317.                     strcpy(LocVarList[l],Mid(buffr,InStrPos(buffr,"(")+1,InStrPos(buffr,":")-1));
    318.                     strcpy(TempStr,Mid(buffr, InStrPos(buffr,":")+1,InStrPos(buffr,")")-1));
    319.  
    320.                     PF(TempStr);
    321.                 }
    322.                 else
    323.                 {
    324.                     strcat(buffw,"()\n");
    325.                 }
    326.  
    327.                 CVE=0;
    328.                 strcat(buffw,"{\n");
    329.                 Block++;
    330.             }
    331.  
    332.             if (SubProgram==1 && FC>0) /* Function Return */
    333.             {
    334.                 strcpy(TempStr,Mid(buffr,0,InStrPos(buffr,":=")-1));
    335.                 if (InStrPos(TempStr,FName[FC-1])>=0 && strlen(FName[FC-1]) > 0)
    336.                 {
    337.                     strcpy(buffw,"return ");
    338.                     strcat(buffw,Mid(buffr,InStrPos(buffr,":=")+2,strlen(buffr)));
    339.                     strcpy(buffr,"");
    340.                     CVE=0;
    341.                 }
    342.             }
    343.  
    344.             if(InStrPos(buffr,"CONST")>=0) /* CONST */
    345.             {
    346.                 strcpy(buffw,"#define ");
    347.                 strcat(buffw,Mid(buffr,5,InStrPos(buffr,"=")-1));
    348.                 strcat(buffw," ");
    349.                 strcat(buffw,Mid(buffr,InStrPos(buffr,"=")+1,InStrPos(buffr,";")-1));
    350.                 strcat(buffw,"\n");
    351.                 CVE=0;
    352.             }
    353.  
    354.             if ((InStrPos(buffr,"BEGIN")>=0)) /* BEGIN */
    355.             {
    356.                 if ((SubProgram==0) && (Block==0)) /* Main Block */
    357.                 {
    358.                     strcpy(buffw,"void main()\n");
    359.                     strcat(buffw,"{\n");
    360.                 }
    361.                 else /* Others */
    362.                 {
    363.                     strcat(buffw,"{\n");
    364.                 }
    365.  
    366.                 Block++;
    367.                 CVE=0;
    368.             }
    369.  
    370.             if (InStrPos(buffr,"VAR") >=0)  /* VAR */
    371.             {
    372.                 strcpy(buffr,Mid(buffr,3,strlen(buffr)));
    373.                 CVE=0;
    374.             }
    375.  
    376.             if (InStrPos(buffr,"OFINTEGER") >= 0)   /* Array of Integer */
    377.             {
    378.                 if (SubProgram==1)  /* Local */
    379.                     ArrayListMaker("int ","%d",1);
    380.  
    381.                 if (SubProgram==0) /* Global */
    382.                     ArrayListMaker("int ","%d",0);
    383.  
    384.                 CVE=0;
    385.                 if (SubProgram==1) TabC++;
    386.             }
    387.  
    388.             if (InStrPos(buffr,"OFREAL") >= 0)  /* Array of Real */
    389.             {
    390.                 if (SubProgram==1)  /* Local */
    391.                     ArrayListMaker("float ","%f",1);
    392.  
    393.                 if (SubProgram==0) /* Global */
    394.                     ArrayListMaker("float ","%f",0);
    395.  
    396.                 CVE=0;
    397.                 if (SubProgram==1) TabC++;
    398.             }
    399.  
    400.             if (InStrPos(buffr,"OFCHAR") >= 0)   /* Array of Char */
    401.             {
    402.                 if (SubProgram==1)  /* Local */
    403.                     ArrayListMaker("char ","%s",1);
    404.  
    405.                 if  (SubProgram==0)  /* Global */
    406.                     ArrayListMaker("char ","%s",0);
    407.  
    408.                 CVE=0;
    409.                 if (SubProgram==1) TabC++;
    410.             }
    411.  
    412.             if (InStrPos(buffr,":INTEGER") >= 0 && InStrPos(buffr,"PROCEDURE")==-1 && InStrPos(buffr,"FUNCTION")==-1)     /* Integer VARIABLES */
    413.             {
    414.                 if (SubProgram==1) /* Local Variables */
    415.                     VarListMaker("int ","%d",1);
    416.  
    417.                 if (SubProgram==0) /* Global Variables */
    418.                     VarListMaker("int ","%d",0);
    419.  
    420.                 CVE=0;
    421.                 if (SubProgram==1) TabC++;
    422.             }
    423.  
    424.             if (InStrPos(buffr,":REAL") >=0  && InStrPos(buffr,"PROCEDURE")==-1 && InStrPos(buffr,"FUNCTION")==-1)  /* Real VARIABLES */
    425.             {
    426.                 if (SubProgram==1) /* Local Variables */
    427.                     VarListMaker("float ","%f",1);
    428.  
    429.                 if (SubProgram==0)  /* Global Variables */
    430.                     VarListMaker("float ","%f",0);
    431.  
    432.                 CVE=0;
    433.                 if (SubProgram==1) TabC++;
    434.             }
    435.  
    436.             if (InStrPos(buffr, ":CHAR") >=0  && InStrPos(buffr,"PROCEDURE")==-1 && InStrPos(buffr,"FUNCTION")==-1)  /* Char VARIABLES */
    437.             {
    438.                 if (SubProgram==1) /* Local Variables */
    439.                     VarListMaker("char ","%c",1);
    440.  
    441.                 if (SubProgram==0)  /* Global Variables */
    442.                     VarListMaker("char ","%c",0);
    443.  
    444.                 CVE=0;
    445.                 if (SubProgram==1) TabC++;
    446.             }
    447.  
    448.             if (InStrPos(buffr,"ELSE") >= 0) /* ELSE */
    449.             {
    450.                 strcpy(buffw,"else \n");
    451.                 CVE=0;
    452.             }
    453.  
    454.             if (InStrPos(buffr,"WHILE") >= 0) /* WHILE */
    455.             {
    456.                 strcat(buffw, "while (");
    457.  
    458.                 Logical();
    459.  
    460.                 strcpy(buffr,InsertS(buffr,"  ",InStrPos(buffr,"DO"),1));
    461.                 strcpy(buffr,InsertS(buffr,"     ",InStrPos(buffr,"WHILE"),1));
    462.                 strcat(buffw,Mid(buffr,0,InStrPos(buffr,"\n")-1));
    463.                 strcat(buffw,")\n");
    464.                 CVE=0;
    465.             }
    466.  
    467.             if (InStrPos(buffr,"IF") >=0) /* IF */
    468.             {
    469.                 strcat(buffw, "if (");
    470.  
    471.                 Logical();
    472.  
    473.                 strcpy(buffr,InsertS(buffr,"    ",InStrPos(buffr,"THEN"),1));
    474.                 strcpy(buffr,InsertS(buffr,"  ",InStrPos(buffr,"IF"),1));
    475.                 strcat(buffw,Mid(buffr,0,InStrPos(buffr,"\n")-1));
    476.                 strcat(buffw,")\n");
    477.                 CVE=0;
    478.             }
    479.  
    480.             if (InStrPos(buffr,":=")>= 0) /* := */
    481.             {
    482.                 strcpy(buffr,ReplaceS(buffr,":=","=",0,strlen(buffr)));
    483.  
    484.                 if(InStrPos(buffr,"MOD") >=0) /* MOD inside */
    485.                    strcpy(buffr,ReplaceS(buffr,"MOD","%",0,strlen(buffr)));
    486.  
    487.                 if(InStrPos(buffr,"DIV") >=0) /* DIV inside */
    488.                    strcpy(buffr,ReplaceS(buffr,"DIV","/",0,strlen(buffr)));
    489.  
    490.                 strcat(buffw,buffr);
    491.                 CVE=0;
    492.             }
    493.  
    494.             if (InStrPos(buffr,"READ(") >=0 || InStrPos(buffr,"READLN(") >=0) /* READ */
    495.             {
    496.                 if (InStrSPos(buffr,",",0) >=0) CVW=1;
    497.                 strcpy(buffr,Mid(buffr,InStrPos(buffr,"(")+1,strlen(buffr)));
    498.                 strcpy(Var, Mid(buffr, 0,InStrPos(buffr,")")-1));
    499.  
    500.                 if (InStrPos(Var,"[")>=0)
    501.                     strcpy(Var,Mid(Var,0,InStrPos(Var,"[")-1));
    502.  
    503.                 strcat(buffw,"scanf(");
    504.                 strcat(buffw,"\"");
    505.  
    506.                 for(j=0; j<=l; j++)   /* Local Variable */
    507.                     if (strcmp(Var,LocVarList[j]) ==0)
    508.                     {
    509.                         strcat(buffw,LocVarType[j]);
    510.                         strcat(buffw,"\"");
    511.                         strcat(buffw,", ");
    512.                         strcat(buffw,"&");
    513.                         strcat(buffw,Var);
    514.                         if (strlen(LocVarSize[j]) > 0)
    515.                         {
    516.                             strcat(buffw,"[");
    517.                             strcat(buffw,Mid(buffr,InStrPos(buffr,"[")+1,InStrPos(buffr,"]")-1));
    518.                             strcat(buffw,"]");
    519.                         }
    520.                         strcat(buffw ,");\n");
    521.                         strcpy(PreVar,LocVarList[j]);
    522.                     }
    523.  
    524.  
    525.                 for(j=0; j<=g; j++)    /* Global Variable */
    526.                     if (strcmp(Var,GlobVarList[j]) ==0 && strcmp(PreVar,GlobVarList[j]) != 0)
    527.                     {
    528.                         strcat(buffw,GlobVarType[j]);
    529.                         strcat(buffw,"\"");
    530.                         strcat(buffw,", ");
    531.                         strcat(buffw,"&");
    532.                         strcat(buffw,Var);
    533.                         if (strlen(GlobVarSize[j]) > 0)
    534.                         {
    535.                             strcat(buffw,"[");
    536.                             strcat(buffw,Mid(buffr,InStrPos(buffr,"[")+1,InStrPos(buffr,"]")-1));
    537.                             strcat(buffw,"]");
    538.                         }
    539.                         strcat(buffw ,");\n");
    540.                     }
    541.  
    542.                 CVE=0;
    543.             }
    544.  
    545.             if(InStrPos(buffr,"WRITE(") >=0 || InStrPos(buffr,"WRITELN(") >= 0) /* WRITE */
    546.             {
    547.                 strcpy(Message,"");
    548.                 if (InStrPos(buffr,"WRITELN(") >=0)
    549.                 {
    550.                     LFB =1;
    551.                     TempVal= 10;
    552.                 }
    553.                 else
    554.                 {
    555.                     LFB = 0;
    556.                     TempVal= 8;
    557.                 }
    558.  
    559.                 if (InStrPos(buffr,"'") >=0)
    560.                 {
    561.                     if(InStrPos(buffr,"',") >=0)
    562.                     {
    563.                         strcpy(Message,Mid(buffr,InStrPos(buffr,"'")+1,InStrPos(buffr,"',")-1));
    564.                         strcpy(buffr,Mid(buffr,strlen(Message)+TempVal,strlen(buffr)));
    565.                     }
    566.                     else
    567.                     {
    568.                         strcpy(Message,Mid(buffr,InStrPos(buffr,"'")+1,InStrSPos(buffr,"'",InStrPos(buffr,"'")+1)-1));
    569.                         if (LFB==1) strcat(Message, "\\n");
    570.                     }
    571.  
    572.                     CVE=0;
    573.                 }
    574.                 strcat(buffw,"printf(");
    575.                 strcat(buffw,"\"");
    576.                 strcat(buffw,Message);
    577.  
    578.                 if (strlen(Message) > 0)
    579.                 {
    580.                     if(InStrPos(buffr,",") >=0)
    581.                     {
    582.                         if (InStrSPos(buffr,",",InStrPos(buffr,",")+1) >=0) CVW=1;
    583.                         strcpy(Var, Mid(buffr, InStrPos(buffr,",")+1,InStrPos(buffr,")")-1));
    584.  
    585.                         if (InStrPos(Var,"[")>=0)
    586.                         strcpy(Var,Mid(Var,0,InStrPos(Var,"[")-1));
    587.  
    588.                         for(j=0; j<=l; j++) /* Local Variable */
    589.                             if (strcmp(Var,LocVarList[j]) ==0)
    590.                             {
    591.                                 strcat(buffw,LocVarType[j]);
    592.                                 if (LFB==1) strcat(buffw,"\\n");
    593.                                 strcat(buffw,"\"");
    594.                                 strcat(buffw,", ");
    595.                                 strcat(buffw,Var);
    596.                                 if (strlen(LocVarSize[j]) > 0)
    597.                                 {
    598.                                     strcat(buffw,"[");
    599.                                     strcat(buffw,Mid(buffr,InStrPos(buffr,"[")+1,InStrPos(buffr,"]")-1));
    600.                                     strcat(buffw,"]");
    601.                                 }
    602.                                 strcpy(PreVar,LocVarSize[j]);
    603.                             }
    604.  
    605.                         for(j=0; j<=g; j++) /* Global Variable */
    606.                             if (strcmp(Var,GlobVarList[j]) ==0 && strcmp(PreVar,GlobVarList[j])!= 0)
    607.                             {
    608.                                 strcat(buffw,GlobVarType[j]);
    609.                                 if (LFB==1) strcat(buffw,"\\n");
    610.                                 strcat(buffw,"\"");
    611.                                 strcat(buffw,", ");
    612.                                 strcat(buffw,Var);
    613.                                 if (strlen(GlobVarSize[j]) > 0)
    614.                                 {
    615.                                     strcat(buffw,"[");
    616.                                     strcat(buffw,Mid(buffr,InStrPos(buffr,"[")+1,InStrPos(buffr,"]")-1));
    617.                                     strcat(buffw,"]");
    618.                                 }
    619.                             }
    620.  
    621.                     } else strcat(buffw,"\"");
    622.                 } else
    623.                 {
    624.                     if (InStrPos(buffr,",") >=0) CVW=1;
    625.  
    626.                     strcpy(Var, Mid(buffr, InStrPos(buffr,"(")+1,InStrPos(buffr,")")-1));
    627.  
    628.                     if (InStrPos(Var,"[")>=0)
    629.                     strcpy(Var,Mid(Var,0,InStrPos(Var,"[")-1));
    630.  
    631.                     for(j=0; j<=l; j++)  /* Local Variable */
    632.                         if (strcmp(Var,LocVarList[j]) ==0)
    633.                         {
    634.                             strcat(buffw,LocVarType[j]);
    635.                             if (LFB==1) strcat(buffw,"\\n");
    636.                             strcat(buffw,"\"");
    637.                             strcat(buffw,", ");
    638.                             strcat(buffw,Var);
    639.                             if (strlen(LocVarSize[j]) > 0)
    640.                             {
    641.                                 strcat(buffw,"[");
    642.                                 strcat(buffw,Mid(buffr,InStrPos(buffr,"[")+1,InStrPos(buffr,"]")-1));
    643.                                 strcat(buffw,"]");
    644.                             }
    645.                             strcpy(PreVar,LocVarList[j]);
    646.                         }
    647.  
    648.                     for(j=0; j<=g; j++)   /* Global Variable */
    649.                         if (strcmp(Var,GlobVarList[j]) ==0 && strcmp(PreVar,GlobVarList[j])!=0)
    650.                         {
    651.                             strcat(buffw,GlobVarType[j]);
    652.                             if (LFB==1) strcat(buffw,"\\n");
    653.                             strcat(buffw,"\"");
    654.                             strcat(buffw,", ");
    655.                             strcat(buffw,Var);
    656.                             if (strlen(GlobVarSize[j]) > 0)
    657.                             {
    658.                                 strcat(buffw,"[");
    659.                                 strcat(buffw,Mid(buffr,InStrPos(buffr,"[")+1,InStrPos(buffr,"]")-1));
    660.                                 strcat(buffw,"]");
    661.                             }
    662.                         }
    663.  
    664.                 }
    665.                 strcat(buffw ,");\n");
    666.                 CVE=0;
    667.             }
    668.  
    669.             if(InStrPos(buffr ,"FOR") >=0) /* FOR */
    670.             {
    671.                 strcpy(buffr,ReplaceS(buffr,":=","=",0,strlen(buffr)));
    672.                 strcpy(buffw, "for(");
    673.                 if (InStrPos(buffr,"DOWNTO") >= 0)
    674.                 {
    675.                     strcpy(buffr,Mid(buffr,3,InStrPos(buffr,"\n")-1));
    676.                     strcpy(Var,Mid(buffr,0,InStrPos(buffr,"=")-1));
    677.                     strcpy(buffr, AppendS(buffr,";",InStrPos(buffr,"DOWNTO")));
    678.                     strcpy(buffr, InsertS(buffr,"      ",InStrPos(buffr,"DOWNTO"),1));
    679.                     strcpy(buffr, AppendS(buffr,Var,InStrPos(buffr,";") +1));
    680.                     strcpy(buffr, AppendS(buffr,">=", InStrSPos(buffr,Var,InStrPos(buffr,Var)+1)+ strlen(Var)));
    681.                     strcpy(buffr, ReplaceS(buffr,"DO",";",0,strlen(buffr)));
    682.                     strcat(buffr,Var);
    683.                     strcat(buffr,"--");
    684.                     strcat(buffr,")\n");
    685.                     strcat(buffw,buffr);
    686.                 } else
    687.                 {
    688.                     strcpy(buffr,Mid(buffr,3,InStrPos(buffr,"\n")-1));
    689.                     strcpy(Var,Mid(buffr,0,InStrPos(buffr,"=")-1));
    690.                     strcpy(buffr, AppendS(buffr,";",InStrPos(buffr,"TO")));
    691.                     strcpy(buffr, InsertS(buffr,"  ",InStrPos(buffr,"TO"),1));
    692.                     strcpy(buffr, AppendS(buffr,Var,InStrPos(buffr,";") +1));
    693.                     strcpy(buffr, AppendS(buffr,"<=", InStrSPos(buffr,Var,InStrPos(buffr,Var)+1)+ strlen(Var)));
    694.                     strcpy(buffr, ReplaceS(buffr,"DO",";",0,strlen(buffr)));
    695.                     strcat(buffr,Var);
    696.                     strcat(buffr,"++");
    697.                     strcat(buffr,")\n");
    698.                     strcat(buffw,buffr);
    699.                 }
    700.                 CVE=0;
    701.             }
    702.  
    703.             if (SubProgram==0 && Block>0) /* Procedure & Function call */
    704.             {
    705.  
    706.                 if(InStrPos(buffr,"(")>=0)
    707.                     strcpy(TempStr,Mid(buffr,0,InStrPos(buffr,"(")-1));
    708.                 else
    709.                     strcpy(TempStr,Mid(buffr,0,InStrPos(buffr,";")-1));
    710.  
    711.                 for (j=0;j<=PC; j++) /* Procedure Call */
    712.                     if (strcmp(TempStr,PName[j])==0 && strlen(PName[j]) > 0)
    713.                     {
    714.                         CVE=0;
    715.                         strcpy(buffw,buffr);
    716.                         if(InStrPos(buffr,"(")==-1)
    717.                             strcpy(buffw,AppendS(buffw,"()",InStrPos(buffw,TempStr)+strlen(TempStr)));
    718.  
    719.                     }
    720.  
    721.                 for(j=0;j<=FC; j++) /* Function Call */
    722.                     if (strcmp(TempStr,FName[j])==0 && strlen(FName[j]) > 0)
    723.                     {
    724.                         CVE=0;
    725.                         strcpy(buffw,buffr);
    726.                         if(InStrPos(buffr,"(")==-1)
    727.                             strcpy(buffw,AppendS(buffw,"()",InStrPos(buffw,TempStr)+strlen(TempStr)));
    728.                     }
    729.             }
    730.  
    731.             if (InStrPos(buffr, "END")>=0) /* END */
    732.             {
    733.                 strcat(buffw,"}\n");
    734.                 Block--;
    735.  
    736.                 if (Block==0) /* Terminates Local Variables */
    737.                 {
    738.                     l=0;
    739.                     SubProgram=0;
    740.                     DataFlush(2);
    741.                     IG=0;
    742.                 }
    743.  
    744.                 CVE=0;
    745.             }
    746.  
    747.             if(strcmp(buffr,"\n")==0) /* Return "\n" */
    748.             {
    749.                 strcpy(buffw,"\n");
    750.                 CVE=0;
    751.             }
    752.  
    753.             if (InStrPos(buffr,"#IGNORELINE#")>=0) /* Ignore */
    754.             {
    755.                 strcpy(buffw,"");
    756.                 CVE=0;
    757.             }
    758.  
    759.             if (InStrPos(buffr,"[") >=0 && InStrPos(buffr,"]") >=0 && Block!=0) /* Equivalent to Array Indexed from 1 in C  */
    760.             {
    761.                 strcpy(buffw,ReplaceS(buffw,"]","-1]",0,strlen(buffw)));
    762.                 CVE=0;
    763.             }
    764.  
    765.         }
    766.  
    767.         TabWriter(); /* calls TabWriter */
    768.  
    769.         if (CVE==0&&CVW==0) /* checks for ocurrence of errors */
    770.         {
    771.             for(j=0;j<TabC;j++)
    772.             printf("\t");
    773.  
    774.             if (strlen(buffw)>0)
    775.                 fputs(buffw,writef); /* Writes "buffw"(write buffer) to "writef"(destination file)*/
    776.  
    777.             printf("%s",strupr(buffw));
    778.         }
    779.         else
    780.         {
    781.             if (CVE==1)  /* Prints error messeages to screen */
    782.             {
    783.                 printf("#### ERROR 10: FATAL CONVERSION ERROR!!! #### | Line: %d \n" ,LineRead);
    784.  
    785.                 strcpy(ErrMsg,"/* #### ERROR 10: FATAL CONVERSION ERROR!!! #### */\n");
    786.                 fputs(ErrMsg,writef);
    787.  
    788.                 CVEC++;
    789.  
    790.                 sound(700);
    791.                 delay(1000);
    792.                 nosound();
    793.             }
    794.  
    795.             if (CVW==1) /* Prints warning messages to screen */
    796.             {
    797.                 printf("#### WARNING 11: EXCEEDING PROGRAM LIMITIONS!!! #### | Line: %d\n",LineRead);
    798.  
    799.                 strcpy(ErrMsg,"/* #### WARNING 11: EXCEEDING PROGRAM LIMITIONS!!! #### */\n");
    800.                 fputs(ErrMsg,writef);
    801.  
    802.                 CVWC++;
    803.             }
    804.         }
    805.  
    806.         if (LC < MaxL) LC++;  /* Screen Display Pause */
    807.         else
    808.         {
    809.             printf("Press Enter to Continue ...");
    810.             fflush(stdin);
    811.             c=' ';
    812.             while (c!='\r')
    813.                 c=getch();
    814.                 clrscr();
    815.             LC=LInt;
    816.         }
    817.     }
    818.  
    819.     printf("\n");
    820.     printf("Press Enter to View Results ...\n");
    821.     fflush(stdin);
    822.     c=' ';
    823.     while (c!='\r')
    824.         c=getch();
    825.  
    826.     printf("\n");
    827.     printf("#### Conversion Results ####\n\n");
    828.  
    829.     if (CVEC >= 1 || CVWC >=1) /* Display the results of the conversion */
    830.     {
    831.  
    832.         printf("Errors: %d\n", CVEC);
    833.         printf("Warnings: %d\n\n",CVWC);
    834.         printf("WARNING: THE PROGRAM MAY NOT COMPILE!!!");
    835.         fputs("/* THE PROGRAM MAY NOT COMPILE!!! */",writef);
    836.  
    837.         sound(800);
    838.         delay(1500);
    839.         nosound();
    840.     }
    841.     else
    842.     {
    843.         printf("\nProgram converted successfully.");
    844.         fputs("\n",writef);
    845.         fputs("/* Program converted successfully.*/",writef);
    846.     }
    847.  
    848.     fclose(readf);   /* Closes "readf" */
    849.     fclose(writef);  /* Closes "writef" */
    850.  
    851.     return 0;
    852. }
    853.  
    854. /******************************** FUNCTIONS *********************************/
    855.  
    856. int InStrSPos(char *MainStr,char *SubStr,int SPos)
    857. {
    858.     int i,j,wcount=0;
    859.  
    860.     for (i=SPos; i < strlen(MainStr);i++)
    861.     {
    862.         if(MainStr[i]==SubStr[0])
    863.         {
    864.             for(j=i; j < strlen(SubStr)+i;j++)
    865.             {
    866.                 if (SubStr[j-i]==MainStr[j])
    867.                     wcount++;
    868.                 else
    869.                     wcount=0;
    870.             }
    871.         }
    872.         FRV=i;
    873.         if (wcount==strlen(SubStr))
    874.             return FRV;
    875.     }
    876.     return -1;
    877. }
    878.  
    879. int InStrPos(char *MainStr,char *SubStr)
    880. {
    881.     int i,j,wcount=0;
    882.  
    883.     for (i=0; i < strlen(MainStr);i++)
    884.     {
    885.         if(MainStr[i]==SubStr[0])
    886.         {
    887.             for(j=i; j < strlen(SubStr)+i;j++)
    888.             {
    889.                 if (SubStr[j-i]==MainStr[j])
    890.                     wcount++;
    891.                 else
    892.                     wcount=0;
    893.             }
    894.         }
    895.         FRV=i;
    896.         if (wcount==strlen(SubStr))
    897.             return FRV;
    898.     }
    899.     return -1;
    900. }
    901.  
    902. char *Left(char *str,int end)
    903. {
    904.     char tempstr[MAX]="";
    905.     int start;
    906.  
    907.     for (start=0;(start < strlen(str)) && (start <= end); start++)
    908.         tempstr[start]= str[start];
    909.  
    910.     strcpy(FRS,tempstr);
    911.     return FRS;
    912.  
    913. }
    914. char *Mid(char *str,int start,int end) /* Pre-process prepator */
    915. {
    916.     int cc=0;
    917.     char tempstr[MAX]="";
    918.  
    919.     for (;(start < strlen(str)) && (start <= end); start++)
    920.         tempstr[cc++]= str[start];
    921.  
    922.     strcpy(FRS,tempstr);
    923.     return FRS;
    924.  
    925. }
    926.  
    927. char *SmartTrim(char *str)
    928. {
    929.     char tempstr[MAX]="";
    930.     int start,cc=0;
    931.     int Mess=0;
    932.     TabC=0;
    933.  
    934.     for(start =0; start < strlen(str); start++)
    935.     {
    936.         if (strcmp(Mid(str,start,start),"'")==0 || strcmp(Mid(str,start,start),"{")==0 || strcmp(Mid(str,start,start),"}")==0)
    937.             if (Mess==0) Mess=1;
    938.                 else
    939.                     Mess=0;
    940.         if (((str[start] != ' ') && (str[start] != '\t') && (Mess!=1)))
    941.             tempstr[cc++]= str[start];
    942.         if (Mess==1) if (str[start]!= '\t') tempstr[cc++]=str[start];
    943.  
    944.         if(str[start]=='\t') TabC++;
    945.     }
    946.  
    947.     strcpy(FRS,tempstr);
    948.     return FRS;
    949.  
    950. }
    951.  
    952.  
    953. char *Trim(char *str)
    954. {
    955.     char tempstr[MAX]="";
    956.     int start,cc=0;
    957.  
    958.     for(start =0; start < strlen(str); start++)
    959.         if (str[start] != ' ')
    960.             tempstr[cc++]= str[start];
    961.  
    962.     strcpy(FRS,tempstr);
    963.     return FRS;
    964. }
    965.  
    966.  
    967. char *ReplaceS(char *MainStr,char *FindS, char *RSub,int SPos, int EPos) /* Conversion ENGINE */
    968. {
    969.      int i=SPos,j;
    970.      char LeftStr[MAX]="", RightStr[MAX]="",OutPut[MAX]="",TempLeft[MAX]="",TempRight[MAX]="";
    971.  
    972.     strcpy(OutPut,MainStr);
    973.  
    974.     while(InStrSPos(OutPut,FindS,i)!=-1 && i <= EPos)
    975.     {
    976.         if (i != 0)
    977.             strcpy(LeftStr,Mid(OutPut,i,InStrSPos(OutPut,FindS,i)-1));
    978.         else
    979.             strcpy(LeftStr,Mid(OutPut,strlen(LeftStr),InStrPos(OutPut,FindS)-1));
    980.  
    981.         strcpy(RightStr,Mid(OutPut,InStrSPos(OutPut,FindS,i)+strlen(FindS),strlen(OutPut)));
    982.  
    983.         if (i != 0)
    984.         {
    985.             strcpy(TempLeft,Mid(OutPut,0,i-1));
    986.             strcpy(TempRight,Mid(OutPut,i,strlen(OutPut)));
    987.             strcpy(OutPut,TempLeft);
    988.             strcat(OutPut,LeftStr);
    989.             strcat(OutPut,RSub);
    990.             strcat(OutPut,RightStr);
    991.         }
    992.         else
    993.         {
    994.             strcpy(OutPut,LeftStr);
    995.             strcat(OutPut,RSub);
    996.             strcat(OutPut,RightStr);
    997.         }
    998.  
    999.         i= i+ strlen(LeftStr)+strlen(RSub);
    1000.     }
    1001.  
    1002.     strcpy(FRS,OutPut);
    1003.     return FRS;
    1004. }
    1005.  
    1006. char *MoveS(char *MainStr,int MPos,int MLenght, int TPos)
    1007. {
    1008.     int i,j=0,k=0;
    1009.     char Move1[MAX]="",Move2[MAX]="";
    1010.     char tempstr[MAX]="";
    1011.  
    1012.     strcpy(Move1,Mid(MainStr,MPos,MPos + MLenght-1));
    1013.     strcpy(Move2,Mid(MainStr,TPos,TPos + MLenght-1));
    1014.  
    1015.     for (i=0; i < strlen(MainStr) ;i++)
    1016.     {
    1017.         if ((i >= MPos) && (i < (MPos + MLenght)))
    1018.             tempstr[i]=Move2[j++];
    1019.         else
    1020.             tempstr[i]=MainStr[i];
    1021.  
    1022.         if ((i >=TPos) && ( i <(TPos + MLenght)))
    1023.             tempstr[i]=Move1[k++];
    1024.     }
    1025.  
    1026.     strcpy(FRS,tempstr);
    1027.     return FRS;
    1028. }
    1029.  
    1030. char *TrimPos(char *MainStr,int SPos, int TLength)
    1031. {
    1032.     int j=0,i=0;
    1033.     char tempstr[MAX]="";
    1034.  
    1035.     for(i =0; i < strlen(MainStr); i++)
    1036.     {
    1037.         if ((i>= SPos) && (i <= (SPos+TLength)))
    1038.         {
    1039.             if (MainStr[i] != ' ')
    1040.                 tempstr[j++]= MainStr[i];
    1041.         }
    1042.         else tempstr[j++]=MainStr[i];
    1043.     }
    1044.  
    1045.     strcpy(FRS,tempstr);
    1046.     return FRS;
    1047. }
    1048.  
    1049. char *InsertS(char *MainStr,char *AStr,int SPos,int TP)
    1050. {
    1051.     int i,j=0;
    1052.     char tempstr[MAX]="";
    1053.  
    1054.     for (i=0; i < strlen(MainStr) ;i++)
    1055.     {
    1056.         if ((i >= SPos) &&(i < (SPos + strlen(AStr))))
    1057.             tempstr[i]=AStr[j++];
    1058.         else
    1059.             tempstr[i]=MainStr[i];
    1060.     }
    1061.  
    1062.     if (TP==1) strcpy(tempstr,TrimPos(tempstr,SPos, strlen(AStr)));
    1063.  
    1064.     strcpy(FRS,tempstr);
    1065.     return FRS;
    1066. }
    1067.  
    1068. char *AppendS(char *MainStr,char *AppS,int AppPos)
    1069. {
    1070.     char tempstr[MAX]="";
    1071.  
    1072.     if (AppPos > 0)
    1073.     {
    1074.         strcpy(tempstr,Mid(MainStr,0,AppPos-1));
    1075.         strcat(tempstr,AppS);
    1076.     }
    1077.     else
    1078.         strcpy(tempstr,AppS);
    1079.  
    1080.     strcat(tempstr,Mid(MainStr,AppPos,strlen(MainStr)));
    1081.  
    1082.     strcpy(FRS,tempstr);
    1083.     return FRS;
    1084. }
    1085.  
    1086. void TabWriter()
    1087. {
    1088.     int i=0;
    1089.     for(i=0;i<TabC;i++)
    1090.     {
    1091.         fputs("\t",writef);
    1092.     }
    1093. }
    1094.  
    1095. void DataFlush(int Rt)
    1096. {
    1097.     int j=0;
    1098.     switch (Rt)
    1099.     {
    1100.         case 1:
    1101.         {
    1102.             for(j=0;j<VAS; j++)
    1103.             {
    1104.                 strcpy(GlobVarList[j],"");
    1105.                 strcpy(GlobVarType[j],"");
    1106.                 strcpy(GlobVarSize[j],"");
    1107.             }
    1108.             break;
    1109.         }
    1110.         case 2:
    1111.         {
    1112.             for(j=0;j<VAS; j++)
    1113.             {
    1114.                 strcpy(LocVarList[j],"");
    1115.                 strcpy(LocVarType[j],"");
    1116.                 strcpy(LocVarSize[j],"");
    1117.             }
    1118.             break;
    1119.         }
    1120.         case 3:
    1121.         {
    1122.             for(j=0;j<VAS; j++)
    1123.             {
    1124.                 strcpy(PName[j],"");
    1125.                 strcpy(FName[j],"");
    1126.                 strcpy(FType[j],"");
    1127.             }
    1128.             break;
    1129.         }
    1130.     }
    1131. }
    1132.  
    1133. void PF(char *TempStr)
    1134. {
    1135.     if (strcmp(TempStr,"REAL")==0)
    1136.     {
    1137.         strcat(buffw,"float ");
    1138.         strcat(buffw,LocVarList[l]);
    1139.         strcpy(LocVarType[l],"%f");
    1140.         strcat(buffw,")\n");
    1141.     }
    1142.     if (strcmp(TempStr,"INTEGER")==0)
    1143.     {
    1144.         strcat(buffw,"int ");
    1145.         strcat(buffw,LocVarList[l]);
    1146.         strcpy(LocVarType[l],"%d");
    1147.         strcat(buffw,")\n");
    1148.     }
    1149.  
    1150.     if (strcmp(TempStr,"CHAR")==0)
    1151.     {
    1152.         strcat(buffw,"char ");
    1153.         strcat(buffw,LocVarList[l]);
    1154.         strcpy(LocVarType[l],"%c");
    1155.         strcat(buffw,")\n");
    1156.     }
    1157.     l++;
    1158. }
    1159.  
    1160. void Logical()
    1161. {
    1162.     if(InStrPos(buffr ,"DIV") >=0)
    1163.         strcpy(buffr,ReplaceS(buffr,"DIV","/",0,strlen(buffr)));
    1164.     if(InStrPos(buffr ,"MOD") >=0)
    1165.         strcpy(buffr,ReplaceS(buffr,"MOD","%",0,strlen(buffr)));
    1166.     if (InStrPos(buffr,"=") >=0)
    1167.         strcpy(buffr, ReplaceS(buffr,"=","==",InStrPos(buffr,"="),strlen(buffr)));
    1168.     if(InStrPos(buffr ,"NOT") >=0)
    1169.         strcpy(buffr,ReplaceS(buffr,"NOT","!",0,strlen(buffr)));
    1170.     if (InStrPos(buffr,"<>") >=0)
    1171.         strcpy(buffr, ReplaceS(buffr,"<>","!=",0,strlen(buffr)));
    1172.     if (InStrPos(buffr,"OR") >=0)
    1173.         strcpy(buffr, ReplaceS(buffr,"OR","||",0,strlen(buffr)));
    1174.     if (InStrPos(buffr,"AND") >=0)
    1175.         strcpy(buffr, ReplaceS(buffr,"AND","&&",0,strlen(buffr)));
    1176.     if (InStrPos(buffr,">=") >=0)
    1177.         strcpy(buffr, ReplaceS(buffr,">==",">=",0,strlen(buffr)));
    1178.     if (InStrPos(buffr,"<=") >=0)
    1179.         strcpy(buffr, ReplaceS(buffr,"<==","<=",0,strlen(buffr)));
    1180. }
    1181.  
    1182. void VarListMaker(char *VT, char *VI,int LV)
    1183. {
    1184.     if (LV==1) /* Local Variables */
    1185.     {
    1186.         if (InStrPos(buffr,",") >= 0) CVW=1;
    1187.         strcpy(LocVarList[l],Mid(buffr,0,InStrPos(buffr,":")-1));
    1188.         strcat(buffw,VT);
    1189.         strcat(buffw,LocVarList[l]);
    1190.         strcat(buffw,";\n");
    1191.         strcpy(LocVarType[l],VI);
    1192.         l++;
    1193.     } else  /* Global Variable */
    1194.     {
    1195.         if (InStrPos(buffr,",") >= 0) CVW=1;
    1196.         strcpy(GlobVarList[g],Mid(buffr,0,InStrPos(buffr,":")-1));
    1197.         strcat(buffw,VT);
    1198.         strcat(buffw,GlobVarList[g]);
    1199.         strcat(buffw,";\n");
    1200.         strcpy(GlobVarType[g],VI);
    1201.         g++;
    1202.     }
    1203.  
    1204. }
    1205.  
    1206. void ArrayListMaker(char *VT, char *VI,int LV)
    1207. {
    1208.     if (LV==1) /* Local Variables */
    1209.     {
    1210.         if (InStrPos(buffr,",") >= 0) CVW=1;
    1211.         strcpy(LocVarList[l],Mid(buffr,0,InStrPos(buffr,":")-1));
    1212.         strcpy(LocVarSize[l],Mid(buffr,InStrPos(buffr,"..")+2,InStrPos(buffr,"]")-1));
    1213.         strcat(buffw,VT);
    1214.         strcat(buffw,LocVarList[l]);
    1215.         strcat(buffw,"[");
    1216.         strcat(buffw,LocVarSize[l]);
    1217.         strcat(buffw,"]");
    1218.         strcat(buffw,";\n");
    1219.         strcpy(LocVarType[l],VI);
    1220.         l++;
    1221.  
    1222.     } else  /* Global Variable */
    1223.     {
    1224.         if (InStrPos(buffr,",") >= 0) CVW=1;
    1225.  
    1226.         strcpy(GlobVarList[g],Mid(buffr,0,InStrPos(buffr,":")-1));
    1227.         strcpy(GlobVarSize[g],Mid(buffr,InStrPos(buffr,"..")+2,InStrPos(buffr,"]")-1));
    1228.         strcat(buffw,VT);
    1229.         strcat(buffw,GlobVarList[g]);
    1230.         strcat(buffw,"[");
    1231.         strcat(buffw,GlobVarSize[g]);
    1232.         strcat(buffw,"]");
    1233.         strcat(buffw,";\n");
    1234.         strcpy(GlobVarType[g],VI);
    1235.         g++;
    1236.     }
    1237.  
    1238. }
    1239.  
    1240. 

  3. #3
    Ngày gia nhập
    12 2007
    Bài viết
    224

    Thử nghiệm

    Một chương trình PASCAL đơn giản

    PASCAL Code:
    1.  
    2. {Global Variables}
    3. const MAX=10;
    4.  
    5. var a: array[1..MAX] of integer;
    6. b: integer;
    7. i:integer;
    8. j:integer;
    9. temp: integer;
    10.  
    11. function Prime(v: integer): integer;
    12. var t:Integer;
    13. begin
    14.     t:= v div 2;
    15.     while v mod t >0 do
    16.     begin
    17.         t:=t-1;
    18.     end;
    19.     if t =1 then
    20.     begin
    21.         Prime:=1;
    22.     end
    23.     else
    24.             begin
    25.         Prime:=0;
    26.     end;
    27. end;
    28.  
    29. function nd(v: integer):integer;
    30. var i :integer;
    31. cnt:integer;
    32. begin
    33.     cnt:=0;
    34.     i:=2;
    35.     while i<v do
    36.     begin
    37.         if (v mod i)=0 then
    38.             cnt:=cnt+1;
    39.         i:=i+1;
    40.     end;
    41.     nd:=cnt;
    42. end;
    43.  
    44. procedure print;
    45. begin
    46.     for i:=1 to MAX do
    47.     begin
    48.         write('Element No ',i);
    49.         writeln(' :',a[i]);
    50.         temp:= nd(a[i]);
    51.         if temp > 1 then
    52.             if prime(temp)=1 then
    53.                 writeln(' OK: ', a[i] );
    54.     end;
    55. end;
    56.  
    57.  
    58. begin
    59.     for i:=1 to MAX do
    60.     begin
    61.         writeln('Enter Element No ',i);
    62.         read(a[i]);
    63.     end;
    64.  
    65.     for i:=1 to MAX-1 do
    66.         for j:=MAX -1 downto i do
    67.         begin
    68.             if a[j] > a[j+1] then
    69.             begin
    70.                 temp:=a[j];
    71.                 a[j]:=a[j+1];
    72.                 a[j+1]:=temp;
    73.             end;
    74.         end;
    75.     print;
    76.    
    77. end.

    Sau khi chuyển thành chương trình C

    C Code:
    1. #include <stdio.h>
    2. /*GLOBAL VARIABLES*/
    3. #define MAX 10
    4.  
    5. int A[MAX];
    6. int B;
    7. int I;
    8. int J;
    9. int TEMP;
    10.  
    11. int PRIME(int V)
    12. {
    13.     int T;
    14.     T=V/2;
    15.     while (V%T>0)
    16.     {
    17.         T=T-1;
    18.     }
    19.     if (T==1)
    20.     {
    21.         return 1;
    22.     }
    23.     else
    24.     {
    25.         return 0;
    26.     }
    27. }
    28.  
    29. int ND(int V)
    30. {
    31.     int I;
    32.     int CNT;
    33.     CNT=0;
    34.     I=2;
    35.     while (I<V)
    36.     {
    37.         if ((V%I)==0)
    38.             CNT=CNT+1;
    39.         I=I+1;
    40.     }
    41.     return CNT;
    42. }
    43.  
    44. void PRINT()
    45. {
    46.     for(I=1;I<=MAX;I++)
    47.     {
    48.         printf("ELEMENT NO %d", I);
    49.         printf(" :%d\n", A[I-1]);
    50.         TEMP=ND(A[I-1]);
    51.         if (TEMP>1)
    52.             if (PRIME(TEMP)==1)
    53.                 printf(" OK: %d\n", A[I-1]);
    54.     }
    55. }
    56.  
    57.  
    58. void main()
    59. {
    60.     for(I=1;I<=MAX;I++)
    61.     {
    62.         printf("ENTER ELEMENT NO %d\n", I);
    63.         scanf("%d", &A[I-1]);
    64.     }
    65.  
    66.     for(I=1;I<=MAX-1;I++)
    67.         for(J=MAX-1;J>=I;J--)
    68.         {
    69.             if (A[J-1]>A[J+1-1])
    70.             {
    71.                 TEMP=A[J-1];
    72.                 A[J-1]=A[J+1-1];
    73.                 A[J+1-1]=TEMP;
    74.             }
    75.         }
    76.     PRINT();
    77.    
    78. }
    79.  
    80. /* Program converted successfully.*/

  4. #4
    Ngày gia nhập
    04 2008
    Bài viết
    24

    Code hay đấy. Mỗi tội cover vẫn sai nhiều lắm, chỉ cover được những bài đơn giản thôi
    admin luôn là admin

  5. #5
    Ngày gia nhập
    12 2007
    Bài viết
    224

    Em nghĩ đây là một code đáng để tham khảo đấy chứ nhỉ ? Vì thật sự em có gặp nhiều bạn muốn chuyển những code viết bằng Pascal sang C để học cấu trúc dữ liệu và giải thuật.

  6. #6
    Ngày gia nhập
    04 2008
    Bài viết
    24

    Mặc định Mã nguồn C | Chương trình chuyển code Pascal sang C

    Đúng vạy, chỉ mang tính chất tham khảo. Mình thấy code này ban đầu mình cũng mừng thầm vì mình có rất nhiều code viết bằng pascal cần chuyển sang C vì viết lại bằng C rất mất thời gian nhưng lại hóa ra mừng hụt, hix. Thôi đành chuyển bằng thủ công tay vậy.
    admin luôn là admin

  7. #7
    Ngày gia nhập
    12 2007
    Bài viết
    224

    Hihi , nếu muốn tất cả các code Pascal có thể chuyển một cách chuẩn sang C thì theo mình hình như chưa có phần mềm nào làm nổi đâu . Chỉ tương đối và đơn giản thôi.

  8. #8
    Ngày gia nhập
    03 2008
    Bài viết
    7

    Anh ơi sao em Copy code về rồi Paste vào Borland C++ 5.02 sau đó Alt+F9 nó báo rất nhiều lỗi là sao ạ.
    Các anh giúp em với !

  9. #9
    Ngày gia nhập
    12 2007
    Bài viết
    224

    Mình chạy có lỗi gì đâu bạn ( mình dùng BC++ 3.1 ) . Nếu có lỗi vui lòng bạn post lỗi lên giùm mình . Còn đây là file .C của code trên .

    http://www.mediafire.com/?xtmamtdi5qy

  10. #10
    Ngày gia nhập
    10 2007
    Bài viết
    1

    mình chạy bình thường bạn à, nhưng nó không xuất ra file C đã covert là sao nhỉ? trong đó có đoạn nào chỉ đường dẫn nơi sẽ xuất file C ra ko? còn nhập file pas thì cứ theo như kiểu C:\vidu.pas phải không? ( ví dụ mình đặt file pas vidu tại ổ C )
    Công cụ bảo vệ mã nguồn .NET mạnh nhất hiện tại, miễn phí cho các khách hàng đầu tiên đăng ký.

Các đề tài tương tự

  1. Nhờ chuyển code từ C sang Pascal
    Gửi bởi Loveanygirls trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 7
    Bài viết cuối: 27-05-2012, 01:21 PM
  2. Chuyển code pascal sang C++
    Gửi bởi minhthuyit85 trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 2
    Bài viết cuối: 10-04-2011, 11:49 PM
  3. Chuyển code Nested Dolls từ C sang code pascal
    Gửi bởi longago trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 1
    Bài viết cuối: 04-01-2011, 08:54 AM
  4. Chuyển sang code C từ Pascal
    Gửi bởi levanhuan trong diễn đàn Tài liệu, ebooks và công cụ
    Trả lời: 0
    Bài viết cuối: 05-04-2009, 02:37 PM
  5. Chuyển code Pascal sang C??
    Gửi bởi Tuấn Mạnh trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 1
    Bài viết cuối: 26-06-2007, 03:41 PM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn