Erstellen eines Programmierspracheninterpreters [geschlossen]

19

Aufgabe:

Sie müssen einen Interpreter erstellen, der Ausschnitte einer Programmiersprache analysieren kann. Die Sprache muss nicht komplex sein, sondern die folgenden syntaktischen Elemente enthalten:

  • Möglichkeit, Variablen zuzuweisen und zu lesen (kann so einfach sein wie a- zvorgefertigte Variablen zu sein)
  • If-Anweisungen (elseif und else sind nicht erforderlich)
  • Schleifen (bis zu einer beliebigen Zahl zählen, Benutzerzugriff auf Zähler nicht erforderlich)
  • Einfache Mathematik mit Variablen (Addition, Subtraktion, Multiplikation, Division, größer / kleiner als, gleich)
  • Anweisungen drucken

Regeln:

  • Sie dürfen die Syntax einer anderen populären Sprache nicht kopieren.
  • Sie müssen Ihren eigenen Dolmetscher schreiben, nicht Änderungen an einem anderen Dolmetscher.
  • Sie können Ihren Dolmetscher in jeder Sprache schreiben.
  • Schreiben Sie ein Beispielprogramm für 99 Flaschen Bier in Ihrer Sprache (siehe hier ).
  • Dies ist ein , daher gewinnt die am meisten bewertete Antwort.
Der Doktor
quelle
3
Was sind die Anforderungen des Parsers? Muss eine Art Syntaxbaum ausgegeben werden?
Kendall Frey
1
Ist es möglich, von einem Stapel genug zu pushen und zu platzieren, um die variablen Anforderungen zu erfüllen?
Tecywiz121
1
@Dennis - Es muss in der Lage sein, eine bestimmte Anzahl von Schleifen
auszuführen
2
Ich glaube, das macht es zu einem Dolmetscher, oder?
Kendall Frey
3
Irgendwie möchte Guido CPython einreichen sehen.
user2357112 unterstützt Monica

Antworten:

17

DogeScript

Das 99 Flaschen Bier Programm:

many amaze 99 time

such scare bottles-of-beer
such scream on-the-wall
many despair 13 time

such fail take-one-down-pass-it-around

wow

so amaze
so scare
so scream
so despair!

so amaze
so scare
so despair!

much amaze

so fail
so despair!

so amaze
so scare
so scream

so despair!
so despair!

very amaze

wow

Der PHP-Interpreter:

<?php
$input=fopen('php://stdin', 'r');

//pre-process input
$input=preg_replace("/ +/", " ", $input); //replace any multiple spaces by a single space

//split into instructions by newlines
$instructions=explode("\n", $input);

$loopstartpoint= -1;
$variables=array();
$activevariable="";
for($instrpointer=0; $instrpointer<count($instructions); $instrpointer++)
{
    $tokens=explode(" ", $instructions[$instrpointer]);
    switch($tokens[0])
    {
        case "wow":
            if($loopstartpoint<0)
            {
                $loopstartpoint=$instrpointer+1;
            }
            else
            {
                if($variables[ $activevariable ])
                {
                    $instrpointer=$loopstartpoint;
                }
                else
                {
                    $loopstartpoint= -1;
                }
            }
            break;
        case "so":
            if(substr($tokens[1], -1)=="!")
            {
                echo chr($variables[ substr($tokens[1], 0, -1) ]);
            }
            else
            {
                echo $variables[ $tokens[1] ];
                echo " ";
            }
            break;
        case "very":
            $activevariable=$tokens[1];
            break;
        case "much":
            if(!isset($variables[ $tokens[1] ]))
                $variables[ $tokens[1] ]=0;
            if(count($tokens)==2)
            {
                $variables[ $tokens[1] ]--;
            }
            else
            {
                for($loop=0;$loop<$tokens[2];$loop++)
                {
                    $variables[ $tokens[1] ]--;
                }
            }
            $activevariable=$tokens[1];
            break;
        case "many":
            if(!isset($variables[ $tokens[1] ]))
                $variables[ $tokens[1] ]=0;
            if(count($tokens)==2)
            {
                $variables[ $tokens[1] ]++;
            }
            else
            {
                for($loop=0;$loop<$tokens[2];$loop++)
                {
                    $variables[ $tokens[1] ]++;
                }
            }
            $activevariable=$tokens[1];
            break;
        case "such":
            $variables[ $tokens[1] ]=$tokens[2];
            $activevariable=$tokens[1];
            break;
    }
}
?>

Die derzeitige Syntax:

wow - start and end loops, end of loop checks if active variable is 0 and loops if not
so without ! - print variable's value
so with ! - print variable's ASCII character
much - decrement this variable
many - increment this variable
such - set variable
very - make variable active
x time - does previous statement x times

Variables are initially 0.

Probieren Sie es hier aus .
Verbesserungsvorschläge sind willkommen.

Gareth
quelle
2
prgramming lvl = 100
Antonio Ragagnin
1
Weißt du, dass es das schon gibt ?
AL
Nein, das hatte ich noch nie gesehen. Schade, ich dachte, ich wäre originell. :-(
Gareth
10

BrainBack: Eine Stack-basierte kompilierte Sprache, die auf BrainFuck läuft

NB: Die Spezifikation wurde von "Erstellen eines Parsers" in "Erstellen eines Interpreters" geändert, nachdem ich diese Antwort gepostet habe. Diese Antwort ist ein Compiler, der auch den Quellcode analysiert.

Der Name ist ein Wortspiel auf Back , das das Gegenteil einer bekannten stapelbasierten Sprache ist, und Brain zeigt an, dass es eine esoterische Natur ist. Es sieht ein bisschen wie BrainFuck aus (ist es aber nicht), aber sein Compiler läuft auf BrainFuck und sein kompilierter Objektcode endet als BrainFuck-Binärdateien.

Die Sprache: * == zerstört seine Argumente

  • "constant" druckt konstant
  • # druckt den obersten Stapel als Zahl
  • > dupliziert die Oberseite des Stapels
  • <num> Drücke die konstante Zahl <num>als Wert nach oben
  • < Entfernen Sie die Oberseite des Stapels
  • - vom zweitobersten das oberste abziehen *
  • + addiere das oberste zum zweitobersten *
  • ! nicht umschaltbar positiv / null *
  • [ ... ] tut eine Weile oben auf dem Stapel nicht Null, sehr ähnlich zu BrainFuck

99 Flaschen Bier mit den richtigen Texten in BrainBack:

100
[
 1 -
 > ! [ < 0 0 "No more" ] < [ # 0 ] <
 " bottle"
 > 1 - [ < 0 "s" ] < 
 " of beer on the wall, "
 > ! [ < 0 0 "no more" ] < [ # 0 ] <
 " bottle"
 > 1 - [ < 0 "s" ] < 
 " of beer.
"
 > ! [ < 0 0 "Go to the store and buy some more, " ] < 
     [ "Take one down and pass it around, " 0 ] <

 > ! [ < 1 0 0 "99" ] < [ > 1 - > !  [ < < 1 0 0 "no more" ] < [ # 1 - 0 ] ] <
 " bottle"
 [ < 0 "s" ] <
 " of beer on the wall.

"
]

Der BrainBack-Compiler, geschrieben in Extended BrainFuck

;;; Macros

;; utility function that substracts 
;; ^2 from ^0 without reduceing ^2 
;; below zero. ^1 needs to be zero
{substract 
  (<<[->]>[<]>-)
}


;; Main macro is the main  program and
;; has the overal structure of the program.
;; every macro here is define in order below.
{main
  :i
  :wrk
  :tmp
  :else
  :sub 
  $i+(
  ; switch ( $wrk ) cases '"#><-+![]9;' using $tmp,$else
  $tmp+++++(-$wrk------)+$wrk---; !
  ($wrk-; "
    ($wrk-; #
      ($wrk--------; +
        ($wrk--; -
          ($wrk--- $tmp- $else 9+ &substract $tmp+ $wrk; 0-9
            ($wrk--; ;
              ($wrk-; <
                ($wrk--; >
                  ($tmp++++(-$wrk------)+$wrk+; [
                    ($wrk--; ]
                      (#(-) $tmp(-)  no matches)
                        $tmp (- #match 'cl'  &close        )
                    ) $tmp (- #match 'op'    &open         )
                  ) $tmp (- #match 'gt'      &dup          )
                ) $tmp (- #match 'lt'        &slash        )
              ) $tmp (  #match 'c'           &comment      )
            ) $tmp (- #match 0 to 9          &read_number  )
          ) $tmp (- #match 'minus'           &sub          )
        ) $tmp (- #match 'plus'              &add          )
      ) $tmp (- #match '#'                   &print_number )
    ) $tmp (- #match '"'                     &print_string )
  ) $tmp (- #match 'not'                     &not          )

  $i(-)$tmp#,+(-(-$wrk+$i+)))
  10+.
}

;; implements close bracket
{close 
    |" close"(-)
    $i.
}

;; implements open bracket
{open 
    |" open"(-)
    $i.
}

;; implements dup/>
{dup
    |"dup [->>+<<]>>[-<+<+>>]<
"
     (-)
}

;; implements slash/<
{slash
     |"slash [-]<
"
     (-)
}

;; implements comment
{comment
  [,10-]
}

;; implements read_number/<number>
;; makes code that if run makes 
;; the constant
{read_number
  ;TODO: compiler_read_constant_number
   $wrk|"number"(-)
#  $wrk 6+ (- $i 8-)
  ~"+>"<.(-)
  $i+(-(-$wrk.)
     #$else, $tmp 6+ (- $else 8-)
     $else(-$tmp+$i+)
     $sub 9+ &substract
     $else+
     $tmp((-) $i(-) $else-)
     $else(-|"[->++++++++++<]>[-<+>]<"(-)$i+)
     )
   $wrk(-)
   |"
"(-)
}

;; implements sub/-
{sub
     |"sub [-<->]<
"
     (-)
}

;; implements add/+
{add
     |"#add [-<+>]<
"
     (-)
}

;; implements print_number/#
{print_number
  |"print [->+<]>[-<+>>+<]>
    [>++++++++++<
    [->-[>+>>]>[+[-<+>]>+>>]<<<<<]
    +>[-]>[-<<+>>]>[-<<+>>]<<]
    +<[>-<[<]]>[>]
    <[>++++++[-<++++++++>]<-.[-]<]<
"(-)

}

;; implements print_string/"..."
;; this outputs EBF code making the
;; object code EBF
{print_string
  |"print >|"(-) 
  $i(-$wrk+$else+)
  $wrk($tmp(-$wrk+)$wrk.,$else(-$tmp+$wrk-$i+)$i(-$else+))
  $tmp(-)$else.(-)|"[-]<
"(-)
}

;; implements not/!
;; creates code that negates top of stack
{not
  |"not >+<[[-]>-]>[<+>->]<<
"(-)
}

&main

So kompilieren Sie BrainBack:

bf ebf.bf < BrainBack.ebf > BrainBack.bf

So kompilieren Sie ein BrainBack-Programm:

bf BrainBack.bf < 99.bb > 99.ebf # compile from bb to ebf
bf ebf.bf < 99.ebf > 99.bf       # compile from ebf to bf 

Führen Sie die Binärdatei aus:

bf 99.bf                        

Hier verwende ich bf, das in den meisten Debian-Distributionen verfügbar ist. beefund andere können auch verwendet werden. Sowohl der EBF-Compiler als auch BrainBack und sein Objektcode werden zu recht kompatiblen BrainFuck-Binärdateien.

Es sollte wahrscheinlich erweitert werden, um eine Zelle als ASCII zu drucken ., in der Lage zu sein, ein Byte einzulesen ,und verschiedene swapOperationen zu haben, um nützlicher zu sein. Dies ist unbedingt erforderlich, um einen BrainBack-Compiler oder -Interpreter in BrainBack zu erstellen.

Sylwester
quelle
6
Wow! Du bist gerade bei 1337 Wiederholungspunkten ... willst die Zahl fast nicht verbessern und verderben! :)
Luser Droog
6

Ich verbringe die meiste Zeit mit PHP-Skripten und es stellte sich die Frage, warum ich gezwungen bin, $für meine Variablennamen zu verwenden. ist meine lokale Währung, also lasst es uns benutzen! Da € in vielen Ländern verwendet wird, habe ich einige Wörter aus EU-Sprachen als Stichwörter verwendet.

€beers gleich 99
€bottles gleich bottles of beer
€bottles_on_the_wall gleich bottles of beer on the wall

mientras €beers topogleich 3
    afficher €beers €bottles_on_the_wall
    afficher , €beers €bottles
    afficher . NETHERLANDS
    odejmowanie €beers

    afficher Take one down and pass it around, €beers
    afficher €bottles_on_the_wall
    afficher . NETHERLANDS NETHERLANDS
sartneim

afficher 2 bottles of beer on the wall, 2 bottles of beer. NETHERLANDS
afficher Take one down and pass it around, 1 bottle of beer on the wall.
afficher NETHERLANDS NETHERLANDS

afficher 1 bottle of beer on the wall, 1 bottle of beer. NETHERLANDS
afficher Take one down and pass it around, no more bottles of beer on the wall.
afficher NETHERLANDS NETHERLANDS

afficher No more bottles of beer on the wall, no more bottles of beer. NETHERLANDS
afficher Go to the store and buy some more, 99 bottles of beer on the wall.
afficher NETHERLANDS NETHERLANDS

Schlüsselwörter:

  • gleichist gleich in deutsch
  • mientrasist während in Spanisch
  • topoist größer Portugiesisch in (Update: es sollte sein maior stattdessen dank daHugLenny für den Tipp)
  • odejmowanieist in polnischer Sprache subtrahieren
  • afficherist in Französisch gedruckt
  • Zeilenumbrüche werden nlmanchmal aufgerufen , und die TLD von NETHERLANDSist nl, also habe ich eine Konstante definiert NETHERLANDS, um Zeilenumbrüche anzuzeigen

Ich habe ein bisschen geschummelt, da es kein ifSchlüsselwort gibt. Ich habe mich dafür entschieden, die letzten beiden Zeilen direkt auszudrucken.

Dolmetscher in Python

Der Interpreter führt lediglich das Skript aus, um 99 Flaschen Bier anzuzeigen.

# -*- coding: utf-8 -*-
# @see http://stackoverflow.com/questions/12655836/writing-an-xml-file-that-contains-a-euro-symbol-in-python-using-xml-etree/12655861#12655861

# =             gleich (german)
# while         mientras (spanish)
# >             topo (portuguese) (it should be "maior" instead)
# subtract      odejmowanie (polish
# print         afficher (french)
# newline       NETHERLANDS

import sys, codecs

class euro:
    symbols = {}
    sign = u'€'

    def executeLine(self, line):
        s = line.split(' ')

        if s[0] == 'afficher':
            buffer = []

            for a in s[1:]:
                if (a == ''):
                    continue
                elif (a[0] == self.sign):
                    buffer.append(str(self.getSymbol(a)))
                elif (a == 'NETHERLANDS'):
                    buffer.append("\n")
                else :
                    buffer.append(a)

            sys.stdout.write(' '.join(buffer))
            # @see http://stackoverflow.com/questions/4499073/printing-without-newline-print-a-prints-a-space-how-to-remove/4499172#4499172
        elif s[0] == 'odejmowanie':
            self.setSymbol(s[1], (int(self.getSymbol(s[1])) - 1))
        elif (len(s) >= 3) and (s[1] == 'gleich'):
            self.setSymbol(s[0], (' ').join(s[2:]))

    def executeBlock(self, lines, statement):
        while (self.getStatement(statement)):
            for line in lines:
                self.executeLine(line)

    def getStatement(self, statement):
        if (statement[1] == 'topogleich'):
            return self.getSymbol(statement[0]) >= int(statement[2])

    def setSymbol(self, name, value):
        name = self.withoutEuro(name)
        self.symbols[name] = value

    def getSymbol(self, name):
        #~ print symbols, withoutEuro(name)
        name = self.withoutEuro(name)
        if name in self.symbols:
            value = self.symbols[name]

            return value
        else :
            print "\n-----\n",'Error: "', name, '"is not in', self.symbols, '-----'

            #~ sys.exit()

    def withoutEuro(self, string):
        return(string.replace(self.sign, ''))

    def parseFile(self, f):
        linesStack = []

        for line in codecs.open(f, 'r', 'utf-8'):
            line = line.replace('\n', '').replace('\t', '')
            s = line.split(' ')

            if (len(s) == 1) & (s[0] == '') :
                continue

            if (s[0] == 'mientras'):
                statement = s[1:]

                linesStack.append(line)
            elif (s[0] == 'sartneim'):
                linesStack.append(line)

                self.executeBlock(linesStack, statement)

                linesStack = []
                statement = ''
            elif (len(linesStack) > 0):
                linesStack.append(line)
            else:
                self.executeLine(line)

euro = euro()
euro.parseFile(sys.argv[1])

Speichern Sie beide Dateien und führen Sie dann die Python-Datei mit dem .euSkript als Argument aus:

python euro.py euro.eu
AL
quelle
4
+1! Erinnert mich an "Wenn PHP britisch wäre": addedbytes.com/blog/if-php-were-british
Pieter Witvoet
Diese Sprache wurde auf Esolang dokumentiert .
AL,
1
topois top in Portuguese
acrolith
@daHugLenny Es tut mir leid für den Fehler. Ist maior die korrekte Übersetzung von größer ?
AL
1
@AL ja. ( Kommentare müssen aus mindestens 15 Zeichen bestehen )
Acrolith
5

1Lang

1Lang ist eine funktionale Präfixsprache wie LISP oder Scheme, jedoch ohne Klammern, was das Lesen etwas erschwert, wenn alle unnötigen Leerzeichen entfernt werden. Klammern können entfernt werden, da alle Funktionen und Operatoren eine bekannte Anzahl von Parametern verwenden.

Klammern sind erforderlich, um Funktionskörper und bedingte Konsequenzen sowie alternative Codeblöcke, die aus einer Liste von Anweisungen bestehen können, abzugrenzen.

In LISP könnte Factorial folgendermaßen definiert werden:

(defun fact (x) (if (< x 2) 1 (* x (fact (- x 1))) ) )

in 1Lang wäre dies

@Fx{ ? < x 2 {1} {* x F -x1} }

die reduziert werden kann

@Fx{?<x2{1}{*xF-x1}}

1Lang unterstützt derzeit keine Nebenwirkungen.

1Lang ist in Bash geschrieben, sodass es derzeit einige Bash-Einschränkungen wie den Integer-Bereich aufweist.

a-z are variables. Variable are either integers, strings, or lists.

NB: Listen sind nicht vollständig implementiert.

A-Z are functions

Ganzzahlen sind Bash-Ganzzahlen (bis zu -2 ^ 32 bis 2 ^ 31-1, denke ich). Negative Zahlen können nicht direkt verwendet werden. Um ein Negativ einzugeben, subtrahieren Sie es von Null. z.B. -5 würde als -0 5 eingegeben. Diese Einschränkung liegt daran, dass 1Lang in Arbeit ist und für diese Anwendung keine negativen Zahlen benötigt wurden. Ich überlege, ~ als unären negativen Operator zu verwenden, der die Eingabe von -5 als ~ 5 erlauben würde.

Leerraum ist erforderlich, um ganze Zahlen abzugrenzen. z.B. +2 3

: means assign                                    eg. :c34 to assign 34 to c
+-*/% are binary integer operators                eg. +12 34
&|^ are binary bit-wise operators
! is unary boolean not
~ is unary one's complement
? is a if-then-else function-like operator.       eg. ?=x3{*xx}{0} is x=3 return x*x else 0
+ is also a binary string concatenation operator  eg. +99" bottles"
* is also a string repetition operator            eg. *5" hello" or *" hello"5
@ defines a function                              eg. @Fx{?<x1{1}{*xF-x1}}

Funktionsparameternamen können Aufrufervariablen überlasten. Alle innerhalb einer Funktion zugewiesenen Variablen sind lokal.

Drucken ist nicht erforderlich (obwohl dies nützlich sein könnte), da wie bei LISP jede Anweisung einen Wert zurückgibt und der zuletzt zurückgegebene Wert gedruckt wird.

eg. +2 3 prints 5

Ein unerwartetes Verhalten der Präfixnotation ohne Klammern besteht darin, dass die Verkettung von Zeichenfolgen tatsächlich einfach zu schreiben ist. Angenommen, Sie möchten verketten "a" " quick" " brown" " fox", könnte man schreiben:

+++"a"" quick"" brown"" fox"

Eine besser lesbare und weniger fehleranfällige Methode ist jedoch die folgende:

+"a"+" quick"+" brown"" fox" (Note missing + between last terms)

oder

+"a"+" quick"+" brown"+" fox"""

99 Flaschen Bier Code:

:b" of beer"
:w" on the wall"
:t"Take one down and pass it around, "
:s"Go to the store and buy some more, "
:c", "
:n".\n"
@Bx{?=x0{+"No more bottles"b}{+x+" bottle"+?=x1{""}{"s"}b}}
@Fx{?=x0{+B0+w+c+B0+n+s+B99+wn}{+Bx+w+c+Bx+n+t+B-x1+w+n+"\n"F-x1}}
F99

Funktion B liefert je nach x "No more bottles" oder "1 bottle" oder "bottles".

Funktion F gibt normale Verse oder letzte Verse zurück. Ein normaler Vers wird mit dem folgenden Vers verkettet, indem F rekursiv mit -x1 aufgerufen wird. Wenn x 0 ist, gibt F den letzten Vers zurück.

Dies erzeugt (für F5 bedeutet ab 5 Flaschen Bier ...):

> F5
5 bottles of beer on the wall, 5 bottles of beer.
Take one down and pass it around, 4 bottles of beer on the wall.

4 bottles of beer on the wall, 4 bottles of beer.
Take one down and pass it around, 3 bottles of beer on the wall.

3 bottles of beer on the wall, 3 bottles of beer.
Take one down and pass it around, 2 bottles of beer on the wall.

2 bottles of beer on the wall, 2 bottles of beer.
Take one down and pass it around, 1 bottle of beer on the wall.

1 bottle of beer on the wall, 1 bottle of beer.
Take one down and pass it around, No more bottles of beer on the wall.

No more bottles of beer on the wall, No more bottles of beer.
Go to the store and buy some more, 99 bottles of beer on the wall.
<End>

1Lang-Interpreter (in Bash geschrieben) in weniger als 500 Zeilen.

#!/bin/bash

LC_ALL=C  # else [a-z] and [A-Z] misbehave

# functions return result on stdout
# functions have an environment

# Requirements:
# * minimise size
#   -> eliminate delimiters
#   -> single letter variables and functions
#   -> no precidence
#   -> no overloading
# * 

# string "text with \characters as per printf"
# numbers 123
# functions F3
# Built-ins +-*/%^ &|~ ! etc.
# assignment :v12 :v"string"

log(){  local m="${l:p}" m="${m//[$NL]/\n}" v="${FUNCNAME[1]}"; echo "$v: l=[${l//[$NL]/\n}] ch=[${ch/[$NL]/\n}] next=[$m]" >&2; }
logr(){ local m="${l:p}" m="${m//[$NL]/\n}" v="${FUNCNAME[1]}"; echo "$v: l=[${l//[$NL]/\n}] ch=[${ch/[$NL]/\n}] next=[$m] ret=[${ret//[$NL]/\n}]" >&2; }
logv(){ local        v="${FUNCNAME[1]}"; echo "$v: ret=[${ret//[$NL]/\n}]" >&2; }
logm(){ local m="$1" v="${FUNCNAME[1]}"; echo "$v: ${m//[$NL]/\n} in [${read//[$NL]/\n}]." >&2; }

msg(){ echo -En "$1" >&2; }
msn(){ echo -E  "$1" >&2; }

# ==========
# Line layer
# ==========

declare l
readline(){ read -rp"1lang> " l; }

#==================
# Environment Layer
#==================

declare -A v t  # variables and variable type
declare ret typ  # all bash function return these values

# assign = : var expression
assign(){
  local var
  readch
  var && var=$ret || { logm "ERROR: variable name expected"      ; return 1; }
  exp             || { logm "ERROR: value or expression expected"; return 1; }
  v["$var"]="$ret"
  t["$var"]="$typ"
}

# get variable value
get(){
  local var
  var && var=$ret || { logm "ERROR: variable name expected"; return 1; }
  ret=${v["$var"]}
  typ=${t["$var"]}
}

declare -A func fpar 
declare -iA fnum                 # functions
# define = @ F param* { body } 
define(){
  local fn par body
  readch
  fn && fn=$ret || { logm "ERROR: function name expected"; return 1; }
  fpar[$fn]=                     # zero parameters
  fnum[$fn]=                     # zero parameter counter
  while var;do                   # read parameters
    fpar[$fn]+=$ret
    fnum[$fn]+=1                 # cound parameters
  done
  # get body but remove block delimiters
  skip "{" "}" && body="${ret:1: -1}" || { logm "ERROR: function body expected"; return 1; }
  readch                         # skip }
  func[$fn]="$body"              # store function body
  ret="@$fn${fpar[$fn]}{$body}"
  typ='f'
}

apply(){
  local fn=$ch n c s; local -i N q
  readch
  N=${fnum[$fn]}   # number of parameters
  n=${fpar[$fn]}   # parameters
  s=${func[$fn]}   # function body
  c=
  for((q=0; q<N; q++)){
    exp || { logm "ERROR: value expected"; return 1; }  
    c+="v[${n:q:1}]=\"$ret\"; "  # add value to script
    c+="t[${n:q:1}]=\"$typ\"; "  # add type to script
  }
  # parse function in a subshell and echo result and type back 
  # subshell means all variable changes in function are local
  c+="parse <<<'$s'; echo -E \"\$typ\$ret\""  # combine type and value
  ret=
  typ=
  ret="$( eval "$c" )" || { logm "ERROR: function application failed"; return 1; }
  typ="${ret::1}"  # extract type
  ret="${ret:1}"   # get actual return value
}

# bash oddities:

# [[ 1 -eq 1 ]] -> 0 or success
# [[ 1 -eq 2 ]] -> 1 or failed

# x=1\<2 -> a=1 (true)
# x=1\<1 -> a=0 (false)

# ((1==1)) -> 0 or success
# ((1==2)) -> 1 or failed

# declare -i a; a=1==1 -> a=1 (true)
# declare -i a; a=1==2 -> a=0  (false)

binary(){
  local -i iret; local op=$ch a b at bt
  readch
  exp && { a="$ret"; at=$typ; } || { logm "ERROR: initial expression expected"; return 1; }
  exp && { b="$ret"; bt=$typ; } || { logm "ERROR: second expression expected"  ; return 1; }
  ret=
  typ=
  case "$at$bt" in
    nn)  # num op num
      case "$op" in
        [\*]) iret=a*b;;
        [\^]) iret=a**b;;
        [\+]) iret=a+b;;
        [\-]) iret=a-b;;
        [\/]) [[ b -ne 0 ]] && { iret=a/b; } || { logm "ERROR: division by 0"       ; return 1; };;
        [\%]) [[ b -ne 0 ]] && { iret=a%b; } || { logm "ERROR: modulo division by 0"; return 1; };;
        [\&]) iret=a\&b;;
        [\|]) iret=a\|b;;
        [\#]) iret=a\^b;;
        [\=]) iret=a==b;;
        [\<]) iret=a\<b;;
        [\>]) iret=a\>b;;
      esac
      ret=$iret
      typ='n';;  # result is always a decimal number
    ss)  # string op string
      case "$op" in
#        [\*]) arith=a*b;;  # combine?
#        [\#]) arith=${}a**b; type='s';;
        [\+]) ret="$a$b"; typ='s';;  # concatenate
        [\-]) ret="${a//$b}"; typ='s';;  # remove substrings
        [\=]) [[ $a = $b ]]; ret=$?; typ='n';;
        [\<]) [[ $a < $b ]]; ret=$?; typ='n';;
        [\>]) [[ $a > $b ]]; ret=$?; typ='n';;
      esac;;
    ns)  # num op string  =3"hello"  ="hello"3  ="3"3  =3"4"
      case "$op" in
        [\+]) ret="$a$b"; typ='s';;  # concatenate
        [\*]) ret=$(eval echo \"\${b[0]\"{1..$a}\"}\"); typ='s';;  # repeat b a times
        [\=]) ((${#b}==a)); ret=$?; typ='n';;  # length b is a
#        [\<]) [[ $a < $b ]]; arith=$?; typ='n';;
#        [\>]) [[ $a > $b ]]; arith=$?; typ='n';;
      esac;;
    sn)  # string op num  *"hello"3  ="3"3  =3"4"
      case "$op" in
        [\+]) ret="$a$b"; typ='s';;  # concatenate
        [\*]) ret=$(eval echo \"\${a[0]\"{1..$b}\"}\"); typ='s';;  # repeat a b times
        [\=]) ((${#a}==b)); ret=$?; typ='n';;  # length a is b
#        [\<]) [[ $a < $b ]]; arith=$?; typ='n';;
#        [\>]) [[ $a > $b ]]; arith=$?; typ='n';;
      esac;;
    *) logm "ERROR: undefined operation [$op] for [$a] [$at] and [$b] [$bt]"; return 1;
  esac
  return 0
}

# FIXME: string ops?
unary(){
  local -i iret; local op="$ch"
  readch
  exp || { logm "ERROR: expression expected"; return 1; }
  case "$op" in
    [\!]) iret=\!ret;;
    [\~]) iret=\~ret;;
  esac
  ret=$iret
  typ='n'  # result is always a decimal number
}

#==============
# Control Layer
#==============

# iff = ? boolean { consequence block } { alternative block }
# ?<1 2{+4 5}{+1 2}
iff(){
  local -i c; local iff ift
  readch
  exp && c=$ret || { logm "ERROR: value or expression expected"; return 1; }
  [[ c -eq 1 ]] && {  # true so do consequence
    ws
    block && { iff="$ret"; ift="$typ"; } || { logm "ERROR: consequence block error"; return 1; }
    ws
    skip "{" "}" || { logm "ERROR: alternate block expected"; return 1; }
    ret="$iff"
    typ="$ift"
  } || {
    ws
    skip "{" "}" || { logm "ERROR: consequence block expected"; return 1; }
    ws
    block || { logm "ERROR: alternate block error"; return 1; }
  }
}

#==============
# Symbols Layer
#==============

# fn = [A-Z]
fn(){
# FIXME: make evalu?
  [[ $ch = [A-Z] ]] || return 1
  ret=$ch
  typ='c'
  readch
}

# var = [a-z]
var(){
# FIXME: make evalu?
  [[ $ch = [a-z] ]] || return 1
  ret=$ch
  typ='c'
  readch
}

# list = ( token* )
# FIXME: not finished and no operators support lists
list(){
  local list=$ch prev
  readch
  while [[ $ch != ')' ]];do
    exp || { logm "ERROR: expression expected"; return 1; }
    case $typ in
      [n]) list+=" $ret";;
      [s]) list+="$ret";;
      [l]) list+="$ret";;
    esac
    ws
  done
  ret="$list$ch"
  readch
  typ='l'
  return 0
}

#============
# Token Layer
#============

# char = ' echoch
#echoch = \ {special echo escape character} | {char}
char(){
  readch
  case "$ch" in
    [\\]) escch || { logm "ERROR: escape character expected"; return 1; };;
       ?) ret="$ch"; readch
  esac
  typ='c'
}

# escaped characters are a pain
# use read with -r to read in verbatim - no escaping
# use echo -E to write out verbatim (except \\ may be processed)

declare escchS
declare ECHO='abefnrtv'
# double \\ for a \
escch(){
  local ESC="$ch"
  readch    # skip \
  case "$ch" in
    [$ECHO])                   printf -v ret "%b" "$ESC$ch"; readch;;
       [\\]) ret="\\"; readch;;
       [\"]) ret="\""; readch;;
      [0-7])         onum && { printf -v ret "%b" "$ESC$ret"   ; } || { logm "ERROR: octal number expected"; return 1; };;
       [xU]) readch; hnum && { printf -v ret "%b" "${ESC}x$ret"; } || { logm "ERROR: hex number expected"  ; return 1; };;
          ?) ret="$ch"
             [[ $escchS ]] || {
               tidyReadCh
               logm "WARNING: only octal, hex, unicode, and [$ECHO\\\"] characters need to be escaped with '$ESC'"
               logm "WARNING: [$ch] in [$l] does not need to be escaped"
               escchS="OFF"
             }
             readch
  esac
  typ='c'
}

#  num =  digit  digit*
# onum = odigit odigit*
# onum = hdigit hdigit*

num(){  local num; num=$ch; readch; while  digit;do num+=$ret; done; ret=$num; typ='n'; }
onum(){ local num; num=$ch; readch; while odigit;do num+=$ret; done; ret=$num; typ='n'; }
hnum(){ local num; num=$ch; readch; while hdigit;do num+=$ret; done; ret=$num; typ='n'; }

#  digit = [0-9]
# odigit = [0-7]
# odigit = [0-9a-fA-F]
digit(){  [[ $ch == [0-9]       ]] || { ret=-1; return 1; }; ret=$ch; typ='s'; readch; }
odigit(){ [[ $ch == [0-7]       ]] || { ret=-1; return 1; }; ret=$ch; typ='s'; readch; }
hdigit(){ [[ $ch == [0-9a-fA-F] ]] || { ret=-1; return 1; }; ret=$ch; typ='s'; readch; }

# string = " char* "
# char = escch | {any character}
string(){
  skip "\"" "\"" || { logm "ERROR: quoted string expected"; return 1; }
  ret="${ret:1: -1}"
  typ='s'
  return 0
}

# ==========
# Char layer
# ==========

declare ch read
declare -i p L COUNT
readch(){
  if [[ p -eq L ]]; then  # need more code
    readline || { ch=; p=L=0; l="EOF"; return 1; }
    l+=$NL;
    p=0
    L=${#l}
  fi
# FIXME: remove once eady - prevents bash consuming all memory  
  COUNT+=1
  ((COUNT>100000)) && { logm "FAILSAFE: too many charcters read"; return 1; }
  ch="${l:p:1}"
  read+="$ch"
  p+=1  # queue next character
}

# skip = SS content* ES
# content = ch | escch | skip(SS ES)
# string = " ch* "
skip(){
  local s="$1" e="$2" b="$ch"
  typ='z'                    # code fragment
  [[ $ch != $s ]] && return  # nothing to skip
  readch
  while [[ -n $ch ]];do
    case "$ch" in
        $e)                 b+="$e"  ; readch; ret="$b"; return 0;;
        $s) skip "$s" "$e"; b+="$ret";;
      [\\]) escch         ; b+="$ret";;
      [\"]) skip "\"" "\""; b+="$ret";;
         ?)                 b+="$ch" ; readch
    esac
  done
  ret="$b"
  logm "ERROR: unexpected EOF"
  exit 1
}

# FIXME: still required?
shopt -s extglob
shopt -u nocasematch

declare NL; printf -v NL "%b" "\n"                 # echo $NL | hexdump -C
declare WS; printf -v WS "%b" " \n\t\r"            # define whitespace

# FIXME: should it set ret and typ? 
ws(){ while [[ $ch == [$WS] ]];do readch; done; }  # skip any WS

#=====
# eval
#=====

# exp = [0-9] num
#       | " string "
#       | : assignment
#       | @ function definition
#       | [-+*/%^] binary operation
#       | [&|#<>=] boolean operation
#       | [!~] unary operation
#       | [A-Z] function application
#       | [a-z] variable
#       | ? if expression
#       | { expression* } block expression
#       | ( expression* ) list of expressions

# spare prefix characters [ '$[]_\;, ]
# [v  head of list
# ]v tail of list

exp(){
  ws
  case "$ch" in
              [0-9]) num    || { logm "ERROR: number expected"               ; return 1; };;
#               [\']) char   || { logm "ERROR: char expected"                 ; return 1; };;
               [\"]) string || { logm "ERROR: string expected"               ; return 1; };;
               [\:]) assign || { logm "ERROR: assignment expected"           ; return 1; };;
               [\@]) define || { logm "ERROR: function definition expected"  ; return 1; };;
           [-+*/%^]) binary || { logm "ERROR: binary expression expected"    ; return 1; };;
       [\&\|#\<\>=]) binary || { logm "ERROR: binary expression expected"    ; return 1; };;
              [\!~]) unary  || { logm "ERROR: unary expression expected"     ; return 1; };;
              [A-Z]) apply  || { logm "ERROR: function failed"               ; return 1; };;
              [a-z]) get    || { logm "ERROR: variable name expected"        ; return 1; };;
               [\?]) iff    || { logm "ERROR: boolean expression expected"   ; return 1; };;
               [\{]) block  || { logm "ERROR: code block expected"           ; return 1; };;
               [\(]) list   || { logm "ERROR: list expected"                 ; return 1; };;
                 '') ret=;       logm "ERROR: unexpected EOF"                ; return 1;;
                  *) ret="$ch"                                               ; return 1;;
  esac
  return 0
}

# block = { code }
block(){
  readch                         # skip {
  while [[ $ch != "}" ]];do
    exp || { 
      tidyReadCh
      logm "WARNING: ignoring previous error or unknown symbol [$ch]"
      [[ errors+=1 -gt 5 ]] && { logm "ERROR: exiting due to too many warnings"; exit 1; }
    }
    ws
  done
  readch    # skip }
  return 0
}

#=====
# repl
#=====

# pass an expression on stdin- not used withing same ebvironment - called by apply
parse(){
  p=L  # force readline
  ch=
  read=
  readch  # clears ch
  while [[ $ch && $ch != '.' ]];do
    exp || { logm "ERROR: expression expected"; return 1; }
    read=$ch
    ws
  done
# last expression is returned as result
}

tidyReadCh(){
  tidyRead
  ch="${ch//[$NL]/\n}"
}
tidyRead(){
  read="${read//[$NL]}"
}

# repl = eval* EOF
# eval = evalu | readch
repl(){
  readch
  while [[ $ch && $ch != '.' ]];do
    exp && {
      tidyRead
      msn "> $read"  # echo line except for WS
#      echo -E "$ret [$typ]"
      echo -E "$ret"
      read=$ch
    } || {
      tidyReadCh
      msn "> $read"
      logm "WARNING: ignoring previous error or unknown symbol [$ch]"
      read=
      readch
      [[ errors+=1 -gt 5 ]] && { logm "ERROR: exiting due to too many warnings"; exit 1; }
    }
    ws
  done
  msn "<End>"
}

#=====
# test
#=====
# FIXME: negative numbers

msn "1Lang"

repl <<<'
:b" of beer"
:w" on the wall"
:t"Take one down and pass it around, "
:s"Go to the store and buy some more, "
:c", "
:n".\n"
@Bx{?=x0{+"No more bottles"b}{+x+" bottle"+?=x1{""}{"s"}b}}
@Fx{?=x0{+B0+w+c+B0+n+s+B99+wn}{+Bx+w+c+Bx+n+t+B-x1+w+n+"\n"F-x1}}
F99
'
Philcolbourn
quelle
Ich hätte es noch mehr geliebt, wenn es @Mfxy{fxy}M+3 4funktioniert hätte, aber dann müssen Sie die Funktion und den variablen Namespace verbinden. Es dauerte eine Weile, bis 99 Biere berechnet waren: p
Sylwester
@ Sylwester, vielen Dank für Ihr Interesse. Ich bin froh, dass du es ausprobiert hast und dass es auch funktioniert hat. Ja, bash ist langsam und die Verwendung von bash zur Interpretation einer anderen Sprache (insbesondere mit Subshells) ist nur interessant, aber nicht nützlich. M + 3 4 wäre nicht korrekt, da +3 4 beim Anwenden zuerst ausgewertet würde. M \ xy {+ xy} 3 4 könnte eine Syntax sein, die funktionieren würde.
Philcolbourn
Hmmm. Anscheinend hat meine Beschreibung Auszeichnungssprachenregeln ausgelöst und es fehlen Bits.
Philcolbourn
Ja, so dass, wenn es consIhnen möglich istmap M\x{*x2}C1C2C3C4/ => (2 4 6 8)
Sylwester
4

Hälfte (Dolmetscher / Übersetzer in Windows Batch)

Ich weiß nicht, warum ich in Windows Batch so viele Rätsel beantworte, aus irgendeinem kranken Grund denke ich, dass es mir Spaß macht übersetzt in Windows Batch von einem Skript, das auch in Windows Batch geschrieben ist. Es ist nicht besonders erstaunlich, aber es funktioniert.

99 Flaschen Bier

# Initialize variables
bottles ~ 99
# You can't directly compare a literal value
zero ~ 0

# This makes a point 'loop' that can be jumped to or used as a subroutine
mark loop
    write $ bottles
# You only need quotes when you have leading or trailing spaces
    print ~ " bottles of beer on the wall,"
    write $ bottles
    print ~ " bottles of beer."
    print ~ Take one down and pass it around,
    bottles @ bottles-1
    if
    bottles equ zero
        jump none
    endif
    write $ bottles
    print ~ " bottles of beer on the wall."
    print ~
jump loop

mark none
    print ~ no more bottles of beer on the wall.
    print ~
    print ~ No more bottles of beer on the wall,
    print ~ No more bottles of beer.
    print ~ Go to the store and buy some more,
    print ~ 99 bottles of beer on the wall.

Syntax

In jeder Zeile werden nur drei durch Leerzeichen getrennte Token erkannt.

# ist ein Kommentar.

In den meisten Fällen, in denen ein Wert benötigt wird, bedeutet a $im zweiten Token, dass der dritte als Variablenname behandelt werden soll, während a ~einen Literalwert bezeichnet. Allgemeine Anweisungen haben die Form <instruction> [$~] <name>. Das Setzen einer Variablen hat die gleiche Form, wird jedoch immer dann implementiert, wenn sie nicht erkannt wird.

Definierte Befehle:

  • printund writebeide schreiben Ausgabe, aber writefügt keine neue Zeile hinzu. Benötigt $ oder ~.
  • mark Erstellt einen Punkt, zu dem gesprungen oder der als Unterroutine aufgerufen werden kann.
  • jump Entspricht goto in batch (oder einer anderen Sprache).
  • procruft ein Unterprogramm auf. Äquivalent von call :label.
  • returnkehrt von einem Unterprogramm zurück. Beendet das Programm, wenn es sich nicht in einem befindet.
  • ifbedingte Anweisung. Übernimmt den Vergleich aus der nächsten Zeile im Formular <var1> <operator> <var2>. Die Operatoren sind die gleichen wie ifin Batch, dh. EQU, NEQ, LSS, LEQ, GTR, GEQ. Führt Anweisungen danach nur aus, wenn der Vergleich wahr ist.
  • endif beendet eine if-Anweisung.
  • catverkettet zwei Variablen. cat a bspeichert den Wert von ab in a.

Wenn keiner dieser Befehle gefunden wird, wird der Ausdruck als Variablenzuweisung behandelt, wobei das erste Token als Variablenname verwendet wird. $und ~verhalten sich genauso wie in print, aber es gibt auch einen @Bezeichner. Hiermit wird das letzte Token als mathematischer Ausdruck behandelt, der an übergeben wird set /a. Es umfasst die meisten Operatoren. Wenn keiner der drei Bezeichner gefunden wird, liegt ein Syntaxfehler vor und der Interpreter wird beendet.

Dolmetscher (Windows Batch)

Der Interpreter übersetzt den Code tatsächlich in einen Windows-Stapel, legt ihn in eine temporäre Datei und führt ihn aus. Während Syntaxfehler in der halben Sprache erkannt werden, kann das resultierende Stapelskript Probleme verursachen, insbesondere bei Sonderzeichen wie Klammern, vertikalen Balken usw.

@echo off

REM Half Interpreter / Translator

if exist ~~.bat del ~~.bat
if not exist "%1" call :error "File not found: '%1'"
set error=
setlocal enabledelayedexpansion
call :parse "%1" 1>~~.bat
if exist ~~.bat if not "error"=="" ~~.bat 2>nul
goto :eof

:parse
set ifstate=0
echo @echo off
echo setlocal
echo setlocal enabledelayedexpansion
for /f "eol=# tokens=1,2* delims= " %%a in (%~1) do  (
    if "!ifstate!"=="1" (
        if /i not "%%b"=="equ" if /i not "%%b"=="neq" if /i not "%%b"=="lss" if /i not "%%b"=="leq" if /i not "%%b"=="gtr" if /i not "%%b"=="geq" call :error "Unknown comparator: '%%b'"
        echo if "^!%%a^!" %%b "^!%%c^!" ^(
        set ifstate=0
    ) else (
        if "%%a"=="print" (
            if "%%b"=="$" (
                echo echo.^^!%%c^^!
            ) else if "%%b"=="~" (
                echo echo.%%~c
            ) else call :error "Unknown identifier for print: '%%b'"
        ) else if "%%a"=="write" (
            if "%%b"=="$" (
                echo echo^|set/p="^!%%c^!"
            ) else if "%%b"=="~" (
                echo echo^|set/p="%%~c"
            ) else call :error "Unknown identifier for write: '%%b'"
        ) else if "%%a"=="mark" (
            if not "%%c"=="" call :error "Unexpected token: %%c"
            echo :%%b
        ) else if "%%a"=="jump" (
            if not "%%c"=="" call :error "Unexpected token: %%c"
            echo goto :%%b
        ) else if "%%a"=="proc" (
            if not "%%c"=="" call :error "Unexpected token: %%c"
            echo call :%%b
        ) else if "%%a"=="return" (
            if not "%%c"=="" call :error "Unexpected tokens: %%b %%c"
            if not "%%b"=="" call :error "Unexpected token: %%b"
            echo goto :eof
        ) else if "%%a"=="if" (
            if not "%%c"=="" call :error "Unexpected tokens: %%b %%c"
            if not "%%b"=="" call :error "Unexpected token: %%b"
            set ifstate=1
        ) else if "%%a"=="endif" (
            if not "%%c"=="" call :error "Unexpected tokens: %%b %%c"
            if not "%%b"=="" call :error "Unexpected token: %%b"
            echo ^)
        ) else if "%%a"=="cat" (
            echo set "%%b=^!%%b^!^!%%c^!"
        ) else (
            if "%%b"=="$" (
                echo set "%%a=!%%c!"
            ) else if "%%b"=="~" (
                echo set "%%a=%%~c"
            ) else if "%%b"=="@" (
                echo set/a"%%a=%%c"
            ) else call :error "Unknown tokens '%%a %%b %%c'"
        )
    )
)
echo endlocal
goto :eof

:error
echo.Parse Error: %~1 1>&2
set error=1
goto :eof
mackthehobbit
quelle
4

Flex Bison

Weisen Sie eine Variable zu, andernfalls einen Bedingungsblock und eine andere Additions- / Subtraktionsoperation.

Laxical Datei lex.l

%{
 #include <stdio.h>
 #include <stdlib.h>
%}

 var [A-Za-z][A-Za-z0-9]*
 digit [0-9]+
 comment \*\*[A-Za-z0-9\*\/\+\-\(\)\"\' \t;:=]*\n

 %%
 print {return(PRINT);}
 save {return(SAVE);}
 {digit} {yylval=atoi(yytext);return(DIGIT);}
 {var} {yylval=strdup(yytext);return(VAR);}
 \* {return(M_SIGN);}
 \/ {return(D_SIGN);}
 \+ {return(A_SIGN);}
 \- {return(S_SIGN);}
 \( {return(L_BRACE);}
 \) {return(R_BRACE);}
 = {return(E_SIGN);}
 ; {return(S_COLON);}
 : {return(COMMA);}
 \n {return (NW_LINE);}
 [ \t] /*skip*/;
 {comment} /*skip*/;
 %%

Parser-Datei com.y

  %{
    #include <ctype.h>
    #include <stdio.h>
    FILE *save_p;
    int new_line=1,stack_top=0,trigger=1;
    void value_store(int);
    int check_srore(char name_var[],int);
    void error(int);

    struct store
    {
     int var_value;
     char var_name[10];
     }info[10];        

    %}

      %token PRINT SAVE S_COLON L_BRACE R_BRACE DIGIT VAR COMMA NW_LINE
      %left A_SIGN S_SIGN
      %left D_SIGN M_SIGN
      %right E_SIGN



      %%
      commands : 
         | commands command
          ;
      command : expers
        | print
        | save
        | NW_LINE{new_line++;}
          ;

           save : SAVE expr etest {fprintf(save_p,"%d\n",$2);}
            ;

           expers  : store_val equal expr etest{value_store($3);}
        ;

           print    : PRINT expr etest {printf("%d\n",$2);} 
              ;

           etest    : S_COLON
        | DIGIT {error(0);}|PRINT{error(0);}|SAVE{error(0);}
         | VAR{error(0);}|COMMA{error(0);}
         ;

           store_val : VAR {check_store($1,0);}
          ;

           expr    : expr A_SIGN expr      { $$ = $1 + $3; } 
                | expr S_SIGN expr      { $$ = $1 - $3; }
                | expr M_SIGN expr      { $$ = $1 * $3; }
                    | expr D_SIGN expr      { $$ = $1 / $3; }
                | L_BRACE expr R_BRACE  { $$ = $2; }
                | DIGIT
                | retriv_var
                ;

             equal   : E_SIGN
             ;

             retriv_var : VAR { $$=check_store($1,1); }
           ;            

        %%

        #include "lex.yy.c"

        void error(int temp)
         {
                char *err[]={
                     "Statement Missing\n",
                 "Compund Statement Missing\n",
                     "Variable need a value\n",
                     "Invalid Argument\n"  
          };
             printf("In line no.%d:\t%s",new_line,err[temp]);   
         exit(1);
        } 

      void value_store(int store_val)
      {
       stack_top--;
      info[stack_top++].var_value = store_val;
      }

   int check_store(char name_var[],int status)
   {
     int temp = 0;
   do{
    if(strcmp(info[temp].var_name,name_var)==0)
    {
   trigger=0;
       if(status)
   {  
          trigger=1;
      return (info[temp].var_value);
   }          
     }
    temp++;     
   } while(temp<stack_top);

    if(trigger)
    {    
if(status)
{
  trigger=1;
      error(2);
}
    else
strcpy(info[stack_top++].var_name,name_var);
   }
      else trigger=1;

  }

  int yyerror(const char *str)
  {
    fprintf(stderr,"error: %s\n",str);
  }


  main(int argc, char *argv[])
  {       

if(argc != 3)
{
     error(3);
}
   yyin = fopen(argv[1],"r");
   save_p = fopen(argv[2],"w");
   yyparse();
   fclose(yyin);
   fclose(yyout);
  }

Kompilieren

  1. Listenpunkt
  2. flex lex.l
  3. bison com.y
  4. gcc -o compiler com.tab.c -lfl

Lauf

Compiler in.txt oder.txt

Eingabedatei

a = 3 + (4 · 7) -9; print a; c = a + 45; print c;

** Dies ist Kommentar speichern c;

** speichere c in der Datei print c * (a + 32);

Ausgabedatei 67

Mamun
quelle
2

Dolmetscher

Anweisungen zum Ausführen dieses Codes finden Sie in meiner anderen Antwort: /codegolf//a/19935/13186

99 Flaschen Bier

Das Programm

 bottles of beer on the wall, @ bottles of beer.
Take one down and pass it around, @ bottles of beer on the wall.

@ bottle of beer on the wall.

1 bottle of beer on the wall, 1 bottle of beer.
Take one down and pass it around, no more bottles of beer on the wall.
@@@@@@@@@@@@@@

#9.{
    !#48.+

    !<#57.<#0.^<!<#57.<#1.^<!<#56.<#64.^<
    !<#56.<#0.^<!<#56.<#1.^<!<#55.<#64.^<
    !<#55.<#0.^<!<#55.<#1.^<!<#54.<#64.^<
    !<#54.<#0.^<!<#54.<#1.^<!<#53.<#64.^<
    !<#53.<#0.^<!<#53.<#1.^<!<#52.<#64.^<
    !<#52.<#0.^<!<#52.<#1.^<!<#51.<#64.^<
    !<#51.<#0.^<!<#51.<#1.^<!<#50.<#64.^<
    !<#50.<#0.^<!<#50.<#1.^<!<#49.<#64.^<
    !<#49.<#0.^<!<#49.<#1.^<!<#48.<#64.^<
    !<#48.<#0.^<!<#48.<#1.^<!#1.-<#57.<#64.^<
    _
?}

#57.<#0.^<#57.<#1.^<!<#56.<#64.^<
#56.<#0.^<#56.<#1.^<!<#55.<#64.^<
#55.<#0.^<#55.<#1.^<!<#54.<#64.^<
#54.<#0.^<#54.<#1.^<!<#53.<#64.^<
#53.<#0.^<#53.<#1.^<!<#52.<#64.^<
#52.<#0.^<#52.<#1.^<!<#51.<#64.^<
#51.<#0.^<#51.<#1.^<!<#50.<#64.^<
#50.<#0.^<#50.<#1.^<!<#49.<
#94.^<

$
tecywiz121
quelle
2

99ISC

99ISC verwendet einen ganzzahligen Speicher beliebiger Größe. Der Speicher wird durch eine nicht negative Ganzzahl indiziert. Alle Werte im Speicher werden mit ihrer Adresse initialisiert. Z.B. Zur Laufzeit enthält die Adresse 0 den Wert 0 und die Adresse 9 den Wert 9.

99ISC hat zwei Anweisungen. Der erste druckt die Routine 99 Flaschen Bier an der Wand aus. Die Syntax besteht aus einer einzelnen Zeile (siehe unten). Die Ausführung wird mit der nächsten Zeile im Programm fortgesetzt.

.

Der zweite Befehl ist ein Befehl "subtrahieren und verzweigen, wenn nicht gleich Null". Die Syntax besteht aus einer einzelnen Zeile (siehe unten).

x y z

xist die Adresse der zu bearbeitenden Zahl, yist die Adresse der zu subtrahierenden Zahl und zist die nächste auszuführende Zeile, wenn das Ergebnis der Subtraktion nicht Null ist. Andernfalls wird die Ausführung mit der nächsten Zeile fortgesetzt.

Das Vorhandensein des Befehls "Subtrahieren und Verzweigen, wenn nicht Null" macht 99ISC zu einem OISC (One Instruction Set Computer) und damit zu einem vollständigen Turing.

Hier ist ein Programm, das die ersten 10 Werte im Speicher löscht und dann die Routine "99 Flaschen Bier an der Wand" druckt.

1 1 0
2 2 0
3 3 0
4 4 0
5 5 0
6 6 0
7 7 0
8 8 0
9 9 0
.

Und hier ist ein 99ISC-Interpreter in Python.

def interpret(filename):
    mem = range(0, 10)
    print mem

    with open(filename) as f:
            lines = f.readlines()

    ptr = 0
    while ptr < len(lines):
            line = lines[ptr]

            if line.strip() == ".":
                    for i in range(99,0,-1):
                            text = str(i) + " bottles of beer on the wall, " + str(i) + " bottles of beer.\nTake one down and pass it around, " + str(i-1) + " bottles of beer on the wall.\n\n"
                            print text.replace("0", "No more")
            else:
                    toks = map(int, line.split())
                    mem[toks[0]] = (mem[toks[0]] - mem[toks[1]]) & 0xFF
                    if mem[toks[0]] != 0:
                            ptr = toks[2]
                    else:
                            ptr += 1
intx13
quelle
1
Ich denke, dies verstößt gegen die "Best Practices" -Regeln für Golffragen. Mit einer generischen print-Anweisung anstelle von "." es würde immer noch funktionieren, aber ich werde verdammt sein, wenn ich das 99BOB-Programm schreibe!
intx13
Die letzten 2 Verse brauchen etwas mehr Arbeit.
Philcolbourn
2

Ich gebe dir:

Small Instruction Set Interpreter (SISI)

Die Syntax basiert auf BASIC und Assembly. Es hat vier Aussagen: set, print, jump(unbedingter goto) und jumpif(bedingten goto). Vor jeder Aussage muss eine Zeilennummer stehen. Unterstützte Datentypen sind Ganzzahlen und Zeichenfolgen.

Der Interpreter selbst befindet sich in Python 3 auf Github (sisi.py). Das 99 Bottles of Beer-Programm gibt es auch, aber ich werde es hier reproduzieren:

10 set x 99
20 set bottles " bottles "

100 set line x + bottles
110 set line line + "of beer on the wall, "
120 set line line + x
130 set line line + bottles
135 set line line + "of beer."
140 print line

200 set x x - 1
210 set none x = 0
220 jumpif none 400
230 set multiple x > 1
240 jumpif multiple 300
250 set bottles " bottle "

300 set line "Take one down and pass it around, " + x
310 set line line + bottles
320 set line line + "of beer on the wall."
330 print line
340 print ""
350 jump 100

400 print "Take one down and pass it around, no more bottles of beer on the wall."
410 print ""
420 print "No more bottles of beer on the wall, no more bottles of beer."
430 print "Go to the store and buy some more, 99 bottles of beer on the wall."
DLosc
quelle
1

Pogo

https://github.com/nrubin29/Pogo

method main:void
    declare(integer,i,99)
    while i > 0
        print(i "bottles of beer on the wall")
        math(i - 1) i
    end
end main
nrubin29
quelle
Ich habe Probleme zu sehen, dass dies die 99 Flaschen Texte druckt.
Sylwester
Zuerst deklariere ich eine Ganzzahl mit dem Namen iund setze sie auf 99. Während i größer als 0 ist, gebe ich eine Zahl aus i bottles of beer on the wallund subtrahiere sie von i. Wenn das Problem ist, dass mir einige Texte fehlen, kann ich noch mehr hinzufügen.
Nrubin29
3
Ein Link zu Texten wurde (oder wird) bereitgestellt. Die letzten Verse sind etwas komplizierter.
Philcolbourn