Konstruere et simpelt programmeringssprog

Du ville spare lidt linier ved at bruge Char.IsDigit og Char.IsLetter !

Nogen speciel grund til at du ikke bruger en scanner & parser generator ?

Jeg kender ikke så meget til generatorer. Egentlig vil jeg meget gerne se selve koden for sproget, og det ved jeg ikke, og man får ved brug af en generator?
Men ellers er det vel logisk opbygget mht. kald og procedurer m.m. (som jeg har forsøgt at skrive i koden), jeg mangler blot overblikket og den rigtige tilgang.

Jeg vil selvfølgelig gerne, at koden kan afvikles op mod en tekstfil, så det bliver så "kompileringsagtigt" som muligt. Hertil her jeg hørt om en "fil-dialog"-boks i Visual Studio, men den ved jeg heller ikke, hvordan fungerer i praksis.

Normalt vil en generator generere source code som du kan studere inden den compiles.

Men ellers er jeg desværre ikke skrap til compiler teknologi.

Men ved du, hvor man kan finde en gratis generator?

Du kan vaelge og vrage !

http://www.antlr.org/
http://www.codeproject.com/csharp/minossecc.asp
http://www.codeproject.com/csharp/spart.asp
http://home.earthlink.net/~slkpg/
http://grammatica.percederberg.net/
etc.etc.

Nu har jeg arbejdet en del videre med projektet. Jeg ha lavet lidt om påkoden, så den er opbygget efter mine kendte principper (ikke teori, men hvad jeg ved, der fungerer).
Til det formål har jeg lavet en undermappe i projektet. Her har jeg lavet en almindelig ".cs"-fil, som indehlder alle classer og metoder. Så vil jeg gerne teste koden. Men når jeg trykker på "run"-knappen, så kommer der blot en tom form frem.Hvorfor sker dette?

I den sammenhæng har jeg så prøvet at køre programet fra prompten på denne måde: java fil(argument)
men så skriver den bl.a., at der ikke findes nogen Main. Er det fordi, Main står inde i classen? Jeg har også prøvet at skrive Main'en udenfr klassen, men det hjælper ikke.

public static void main(string[] args)

Jeg ved ikke hvorfor der ikke kommer mere frem. Uden kode er det umuligt at sige.

Jeg kan godt forstå at du ikke kan køre et C# program med java kommandoen.

Ahh, ja selvfølgelig. Min handling var vist et godt udtryk for, at jeg mangler lidt overblik over projektet. Jeg har nemlig fundet ud af, at der vist primært bliver lavet programmeringssprog i java - derfor prøvede jeg nok ubevidst med java-compileren. I java findes der en masse klasser, som kan afhjælpe konstruktionen.
Findes der nogle eksempler (gerne avancerede) i java, som representerer et programmeringssprog? (altså hvor man blot skal rette nogle linier i koden, så man får det ønskede output med egne begrænsninger/ønkser)

Også i Java vil man typisk bruge en generator.

http://www.antlr.org/
https://javacc.dev.java.net/
http://www.cs.princeton.edu/~appel/modern/java/CUP/
http://grammatica.percederberg.net/
http://sablecc.org/
http://jparsec.codehaus.org/
http://www.ssw.uni-linz.ac.at/Projects/Coco/Coco.html/
http://byaccj.sourceforge.net/
http://www.cs.rit.edu/~ats/projects/lp/doc/jay/package-summary.html

Jeg er ret sikker på at de fleste af dem kommer med nogle eksempler som du kan bygge
videre på.

Nu har jeg downloaded nogle af de generatorer. Umiddelbart ser Coco fin ud. Dog tror jeg, at den giver nogle lidt for avancerede muligheder. Jeg ville egentlig godt prøve ANTLR, men hver dén, eller umiddelbart nogle af de andre, kan jeg betjene korrekt. Ved du bl.a. hordan jeg laver f.eks. grammar'en i ANTLR?

(jeg har ikke set så meget på "hvordan" i de andre)

Jeg har lavet en masse med "den første version". Nu er der kun nogle få kompileringsfejl. Er det noget, som arne_v eller andre eventuelt vil kompilere og finde fejlene ved? (du/i har garanteret bedre og større indsigt i programmeringshalløjet end mig)

Token.java:
public class Token
{
    public byte kind;
    public String spelling;
    private static String[] spellings=
    {"identifier", "integer-literal", "operator", "begin", "const", "do", "else", "end", "if", "in", "let", "then", "var", "while", ";", ":", ":=", "(", ")", "eot"};
    public static byte IDENTIFIER=0, INTEGERLITERAL=1, OPERATOR=2, BEGIN=3,
    CONST=4, DO=5, ELSE=6, END=7, IF=8, IN=9, LET=10, THEN=11, VAR=12, WHILE=13,
    SEMICOLON=14, COLON=15, BECOMES=16, IS=17, LEFTPARAN=18, RIGHTPARAN=19, EOT=20,
    CLASS=21, DECLARATION=22, IMPLEMENTATION=23, STATEMENT=24, FUNC=25;
   
    public Token(byte kind, String spelling)
    {
        this.kind=kind;
        this.spelling=spelling;
        //if kind is IDENTIFIER and SPELLING matches one
        //of the keywords, change the tokens kind accordingly:
        if(kind==IDENTIFIER)
        {
            for (int k = BEGIN; k<=WHILE; k++)
            {
                if (spelling.equals((String)spellings[k]))
                {
                    this.kind = (byte)k;
                    break;
                }
            }
        } 
    }   
}
 
Parser.java:
public class Parser
    {
        private DataScanner scan;
        private Token currentTerminal;

        public Parser(DataScanner scan)
        {
            this.scan = scan;
            currentTerminal = scan.scan();
        }

        public void parseLine()
        {
            if(parseProgram())
            accept( Token.DOT );
        }

        public boolean  parseProgram()
        {
            if(currentTerminal.kind == Token.CLASS)
                  return parseClass();   
            else
                System.out.println("Does not contain class");
            if(currentTerminal.kind != Token.EOT )
                System.out.println("Tokens found after end of program");
            return false;
        }

        private boolean parseClass()
        {
            accept( Token.CLASS );
            if(currentTerminal.kind == Token.DECLARATION )
                parseDeclarations();
            if(currentTerminal.kind == Token.IMPLEMENTATION )
                parseImplementation();
            if(currentTerminal.kind == Token.STATEMENT)
                parseStatements();
            return false;
        }

        private boolean  parseDeclarations()
        {
            accept(Token.DECLARATION);
            while (currentTerminal.kind == Token.IDENTIFIER)
                parseOneDeclaration();
            return false;
        }

        private boolean  parseOneDeclaration()
        {
            switch( currentTerminal.kind ) {
                case Token.VAR:
                    accept( Token.VAR );
                    accept( Token.IDENTIFIER );
                    accept( Token.SEMICOLON );
                    break;       
                default:
                    System.out.println("declarations expected");
                    break;
            }
            return false;
        }

        private boolean  parseImplementation()
        {
            accept( Token.IMPLEMENTATION );
            switch( currentTerminal.kind ) {
                case Token.FUNC:
                    accept( Token.FUNC );
                    accept( Token.LEFTPARAN );
                      accept( Token.IDENTIFIER );       
                    accept( Token.RIGHTPARAN );
                    parseStatements();
                    accept( Token.SEMICOLON );
                    break;           
                default:
                    System.out.println("declarations expected");
                    break;
            }
            return false;
        }

        private boolean  parseStatements()
        {
            accept(Token.STATEMENT);
            while (currentTerminal.kind == Token.IDENTIFIER ||
                  currentTerminal.kind == Token.OPERATOR ||
                  currentTerminal.kind == Token.INTEGERLITERAL ||
                  currentTerminal.kind == Token.IF ||
                  currentTerminal.kind == Token.WHILE)
              return  parseOneStatement();
          return false;
        }

        private boolean  parseOneStatement()
        {
            switch( currentTerminal.kind ) {
                case Token.IDENTIFIER:
                case Token.INTEGERLITERAL:
                case Token.OPERATOR:   
                case Token.IF:
                    accept( Token.IF );
                    parseExpression();
                    if( currentTerminal.kind == Token.ELSE ) {
                        accept( Token.ELSE );
                        parseStatements();
                    }
                    accept( Token.SEMICOLON );
                    break;       
                case Token.WHILE:
                    accept( Token.WHILE );
                    parseExpression();
                    accept( Token.DO );
                    parseStatements();
                      accept( Token.SEMICOLON );
                    break;       
                default:
                    System.out.println("Error in statement");
                    break;
            }
            return false;
        }

        private boolean  parseExpression()
        {
            parsePrimary();
            while (currentTerminal.kind == Token.OPERATOR)
            {
                accept(Token.OPERATOR);
                parsePrimary();
            }
            return false;
        }

        private boolean  parsePrimary()
        {
            switch( currentTerminal.kind ) {           
                case Token.INTEGERLITERAL:
                    accept( Token.INTEGERLITERAL );
                    break;           
                case Token.OPERATOR:
                    accept( Token.OPERATOR );
                    parsePrimary();
                    break;               
                default:
                    System.out.println("Error in primary");
                    break;
            }
            return false;
        }

        private void accept(byte expectedKind)
        {
            if (currentTerminal.kind == expectedKind)
            {
                currentTerminal = scan.scan();
                //currentToken = scanner.scan();
            }
            else
                System.out.println("ERROR IN ACCEPT()");
        }
    }

DataScanner.java:
import java.io.*;
    import java.util.Scanner;
    import java.lang.*;
    import java.io.File;
    import java.io.FileNotFoundException;

    public class DataScanner
    {
        private static char currentChar; //"FIRST SOURCECHARACTER";
        private static byte currentKind;
        private static StringBuffer currentSpelling=new StringBuffer();
        private static StringBuffer endingBuffer=new StringBuffer();
        private static String filename;
        private static int numberBeginingBrachets=0;
        private static int numberEndingBrachets=0;
        private static int numberBoolean=0, numberInt=0;
        private static boolean declaration=false, implementation=false;
        private static String word;
       
        private void take(char expectedChar)
        {
            if(currentChar==expectedChar)
            {
                currentSpelling.append(currentChar);
                currentChar='a';//"NEXT SOURCE CHARACTER";
            }else
                System.out.println("Error charaters!");
        }

        private void takeIt()
        {
            currentSpelling.append(currentChar);
            currentChar='a';//"NEXT SOURCECHARACTER";
        }

        private boolean isDigit(int c)
        {
            switch(c)
            {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:
                    return true;   
            }
            return false;
        }

        private boolean isLetter(char c)
        {
            switch(c){
                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f':
                case 'g':
                case 'h':
                case 'i':
                case 'j':
                case 'k':
                case 'l':
                case 'm':
                case 'n':
                case 'o':
                case 'p':
                case 'q':
                case 'r':
                case 's':
                case 't':
                case 'u':
                case 'v':
                case 'x':
                case 'y':
                case 'z':
                    return true;
                }
            return false;
        }

        private byte scanToken()
        {
            switch(currentChar)
            {
                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'x': case 'y': case 'z':
                    takeIt();
                return Token.IDENTIFIER;
                case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
                    takeIt();
                while(isDigit(currentChar))
                    takeIt();
                return Token.INTEGERLITERAL;
                case '+': case '-': case '*': case '/': case '%': case '=': takeIt();
                return Token.OPERATOR;
                case ';': takeIt();
                return Token.SEMICOLON;
                case ':': takeIt();
                if(currentChar=='='){
                    takeIt();
                    return Token.BECOMES;
                }else     
                    return Token.COLON;
                case '(': takeIt();
                    return Token.LEFTPARAN;
                case ')': takeIt();
                    return Token.RIGHTPARAN;                   
                default:{
                    System.out.println("lecical error");
                    return 1;
                }
            }
        }

        private void scanSeperator()
        {
            switch(currentChar)
            {
                case ' ':
                case '\n':
                    takeIt();
            }
        }

        public Token scan()
        {
            currentSpelling=new StringBuffer();
            currentKind=scanToken();
            return new Token(currentKind, currentSpelling.toString());
        }
        //***********FOUND ONLINE******ARE ONLY CODING FROM HERE AND DOWNWARDS******
        private static void readFile(String fileName)
        {
              try
              {
                Scanner scanner =
                  new Scanner(new File(fileName));
                scanner.useDelimiter
                  (System.getProperty("line.separator"));
                while (scanner.hasNext())
                {
                  parseLine(scanner.next());
                }
                Token.EOT;//for at slutte af fra scanner før
                System.out.println("\nScanning completed\n");
                scanner.close();
              } catch (FileNotFoundException e)
              {
                e.printStackTrace();
              }
        }

            private static void parseLine(String line)//static
            //check for beginning of line and process accordingly
            {//is called pr line
                try{
                Scanner lineScanner = new Scanner(line);
                while(lineScanner.hasNext())
                {
                    word=lineScanner.next();
                    if(word=="class")//check if word is "class"
                    {
                        endingBuffer.append(word.toString());
                        if(lineScanner.hasNext()){
                            word=lineScanner.next();
                            endingBuffer.append(word.toString());//append name of class
                        }
                        if(lineScanner.hasNext()){
                            System.out.println("Too many words after name of class");
                            System.exit(1);
                        }
                        else{
                            return;   
                        }
                        System.out.println("Missing name of class");
                        System.exit(1);
                    }
                    if(word=="{"){
                        //finalBuffer.append(word.toString());
                        numberBeginingBrachets++;
                        return;//return to linechecker
                    }
                    if(word=="}"){
                        //finalBuffer.append(word.toString());
                        numberEndingBrachets++;
                        return;//return to linechecker
                    }
                    if(word=="declaration:")
                    {
                        endingBuffer.append(word.toString());
                        declaration=true;
                        if(lineScanner.hasNext()){
                            System.out.println("Not allowed to type after DECLARATION");
                            System.exit(1);
                        }
                    }
                    if(declaration=true){//the last runthrough stated a declaration begun
                        if(word==Token.Int||word==Token.Bool){
                            if(word==Token.Int)
                                numberInt++;
                            if(word==Token.Bool)
                                numberBoolean++;
                            endingBuffer.append(word.toString());//found an identifier/type
                            word=lineScanner.next();//search for name, =, value, ;
                            endingBuffer.append(word.toString());//found a VARname
                            word=lineScanner.next();
                            //check if word contains '='(word.contains('='))
                            char[] charArray=word.toCharArray();
                            boolean hasEqual=false;
                            for(int count=0; count<charArray.length(); count++)
                            {
                                if(charArray[count]=='=')
                                    hasEqual=true;
                            }
                            if(hasEqual)
                            {           
                                if(lineScanner.hasNext()){
                                    word=lineScanner.next();
                                    if(numberBoolean>0)
                                    {
                                        endingBuffer.append(word);//if 'true' or 'false'
                                        numberBoolean--;
                                    }
                                    if(numberInt>0)
                                    {
                                        endingBuffer.append(word);//if number
                                        numberInt--;
                                    }
                                }
                                else
                                {
                                    System.out.println("Variable MUST be initialized to a value!");
                                    System.exit(1);
                                }
                            }
                            else{
                                System.out.println("Variable MUST be initialized with a '='!");
                                System.exit(1);
                            }
                        }
                        declaration=false;//going out of declaration
                    }
                    if(word=="implementation:")
                    {
                        implementation=true;
                        endingBuffer.append(word.toString());
                        if(lineScanner.hasNext()){
                            System.out.println("Not allowed to type after Implementation");
                            System.exit(1);
                        }
                    }
                    if(implementation=true)
                    {
                        word=lineScanner.next();
                        //check if variables are initialized!!!!
                        //check if word contains '='(word.contains('='))
                        char[] charArray=word.toCharArray();
                        boolean hasEqual=false;
                        for(int count=0; count<charArray.length(); count++)
                        {
                            if(charArray[count]=='=')
                                hasEqual=true;
                        }
                        if(hasEqual==true)//if a variable is handled
                        {           
                            if(lineScanner.hasNext()){
                                word=lineScanner.next();
                                if(exists())//check if variable exists!
                                {
                                    endingBuffer.append(word);
                                    if(lineScanner.hasNext()){
                                        //do the operation according to Token.Operator
                                    }else
                                        System.out.println("Error in handling the variables in implementation!");
                                }
                                if(word.equals("out"))
                                {
                                    endingBuffer.append(word);
                                    //and print out the value
                                }
                            }
                            else
                            {
                                System.out.println("Variable MUST be initialized to a value!");
                                System.exit(1);
                            }
                        }
                        else{
                            System.out.println("Variable MUST be initialized with a '='!");
                            System.exit(1);
                        }
                        implementation=false;
                    }
                    //check if the number of '{' and '}' are even!
                    System.exit(1);
                }
               
                }catch(Exception e)
                {
                    System.out.println("ERROR in try-method\n"+e.toString());
                }
            }

            public static void main(String[] args) {
              if (args.length != 1) {
                System.err.println("usage: java TextScanner2"
                  + "file location");
                System.exit(0);
              }
              readFile(args[0]);
            }
    }

ffs...

du kan jo ikke poste 200 linier kode... især ikke når det er en Parser... det tager jo 5 dage at sætte sig ind i hvad den gø og ikke gør

S&#229; fik jeg kringlet den med egen opbygning af koden. Det var nu ikke s&#229; omfattende, som f&#248;rst antaget.