Nous proposons un nouveau langage, le langage bouclier (shield lang).
ex.shie
#Ceci est un commentaire.
(*Ceci est également un commentaire.*)
#Livré avec un compilateur de~ using *L'espace de noms peut être omis avec
from system using * #exit(La fin du programme),TapKey(Entrée clé),type(Moule),Rtype(制限Moule)Tel
using os #id(Sortie d'adresse),exit(Fin) ptr(Fonctionnement du pointeur)Tel
using rapt #Fonction confort standard
from console using * #print,read,error,linef(Fonction de fin)Tel
using err # comment,déboguer etc.
from collection using * #Array<>,List<>,Dict<>,range()etc
#L'opération de fichier utilise le fichier
#Le fichier externe est importé Cette fois, OpenCV est importé.
import cv
rect = rapt.rect #namespace rapt classe rect est défini sur rect
using texisnone as rapt.texture.isnone #def rapt.textureisnone(bool)()Reçoit un alias.
var n1 = 5
var s1 = "string1"
any d = 5 #Type dynamique
d = "Ah"
#La substitution est"=",La comparaison est"=="
var str s2 = "string2"
opt var str s3 = None #Le type de référence est Aucun
opt var float n2 = Null #Le type de valeur est Null
var lst = new [1,"ABC",3.141592] #list est un type de référence et un type dérivé obj Une fois que le type est décidé, il ne change pas.
lst[1] = 3 #Erreur de compilation
lst += 4 #Ajoutez 3 à la fin de la liste
print(lst[3]) #output 4
nlst = lst + 8.3 #lst puis 8.Créer nlst avec 3 ajoutés
# var lsta = new List<int>[3]{1,2,3}<-Liste qui ne peut contenir que des types spécifiques
# var lsta = new List<new List<int>>[3,3]{{1,2,3}{4,5,6}{7,8,9}}
var arr = Array<str>[3]{"1","ABC","3.141592"} #Le tableau est de type valeur
var tupple = new (1,"ABC",3.14159265358979)
#var tupple := new {1,"ABC",3.14159265358979}Mais peut être déclaré
var dic = new Dict<Tupple<str,int>>[2]{("Ah",1),("Ueo",2)}
#S'il est const, il est possible de déclarer une constante. Lier quand const(:=)utilisation
const Anum := 5
var Aiu[Anum] = Array<int>{1,2,3,4,5}
tupple[2] =3.14 #Erreur de compilation
var str Moji = '1' + '3'
print(Moji) #output "13"
var errs1 = '1' + 3 #Erreur de compilation:La moisissure n'est pas sûre(str + int)
var MRC_OK = int('1') + int('3')
print(str(MRC_OK)) #output '4'
#Type principal booléen,str,int,var,byte,float,obj,ref~,dérivé d'énumération,type dérivé struct,type dérivé de classe,Type générique
if(type(n1) is int or opt int):#true
print(f"{n1}")
s1 = switch(s1) case "2" case "3" as "s1 est"+s1+"est" break case "string1" case "string2" default as "s1 est2ではありません" break
print(f"{s1}") #output "s1 n'est pas 2"
enum VakKey:#Juste une partie
LEFT = 0x25
RIGHT
UP
DOWN
a = 0x41
b
c
d
var vk[] = new VakKey()<-Créez une boîte qui connaît tous les états
using val as vk,using VakKey: #Si vous voulez savoir si l'intérieur de la parenthèse du commutateur est vrai au lieu de la valeur de retour avec val comme~Utilisez la syntaxe. À ce stade, utilisez continuer.
switch(system.TapKey(int(val))):
case .RIGHT as #Ce qui suit est exécuté:
print("Right")
continue
case .LEFT as
print("Left")
continue
case .UP as
print("Up")
continue
case .DOWN as
print("Down")
continue
#Le constructeur de la structure est le nom de la balise var structure=Nom de la structure(Argument du constructeur)
struct tanf: #La structure est un type de valeur(self,Objet vide:Null)
pub unsafe def _init(var int m,var str w,var x) without self: #Aucune valeur de retour requise pour le constructeur
.m = m #À l'intérieur sans.~Peut être écrit.
.w = w
.x = global s1 #Utilisez unsafe lors de l'utilisation de variables globales, de variables extraclasses et de pointeurs.
return self
pub def show()():#()Peut être omis lorsque le type de retour est nul return None
read (f"{self.m}")
for(i in range(self.m)):
print(str(i)+"Temps")
print(f"{self.w}Mais{self.x}est")
pass
pub set(val) pub get var int m #Réglage de la plage
pub var str w
pub set(val) pub get del var x
dat class Mycdat(obj)(opt var str mydat1,opt var int mydat2)#(Héritage/aspect)(Les données)
dat struct Mysdat(opt var str mydat1,opt var int mydat2)
#le constructeur de classe est le nom de l'objet var=nouveau nom de classe(Argument du constructeur)
class Myclass(obj):#(Héritage/aspect)La classe est un objet de type référence(this,Objet vide:None)S'il s'agit d'une base, vous pouvez vous connecter à la méthode parent
pub def _init(int m,ref rect rc,var h,var y,var t[931]):
this.m = m
this.rc = rc
this.h = h
this.y = y
this.t = [if(t[i] is Null) 5 else t[i];for i in range(931)]
pub def show()(int m = 3):
this.m = m
var n = 0
for(not n is this.m and rc is not None):#
print(rc.left,rc.right,rc.top,rc.bottom)
var rect_is_live = if(m < 3) true elif(6 < m and m < 10) false else true
this.rc = if(not rect_is_live) None else pass
pub def show()(var h):
var n = 0
for(not n is this.m and rc is not None):#
print(rc.left,rc.right,rc.top,rc.bottom)
var rect_is_live = if(m < 3) true elif(6 < m and m < 10) false else true
this.rc = if(not rect_is_live) None else pass
pub operator==(bool)(Myclass T): #Surcharge de l'opérateur+,-,==,is,and,or,not,xor,*,/,++,--,**,//,%,^,<<,>>,<=,>=,<,>,|,&,!(Les 7 derniers sont des opérateurs de bits)cependant,,as,=, :=,., ?:, ->, new,le type ne peut pas être surchargé
#+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=,!=Est possible en surchargeant l'opérateur binaire
return (if(not this.m is not T.m) false elif(this.rc is not T.rc) false elif(this.h is not T.h) false elif(this.y is not T.y) false elif(this.t is not T.t) false else true)
set(val) get int m
del opt ref rect rc
var h
var y
ref var t
#Génériques conditionnels(Des génériques simples peuvent être créés avec var)
def Tshow<T>()(T t) when T is Rtype(opt ref in(int or str or float)) : #Vous pouvez utiliser type au lieu de Rtype, mais nous ne le recommandons pas car il est redondant.
opt int s = if(T)
default when:
err.comment("vakerror0001:Aucun générique fabriqué avec ce type")
def sum(var)(var t1,var t2):
return t1 + t2 #J'obtiens une erreur de compilation lorsque je lis que les types de t1 et t2 sont incorrects au moment de la compilation.
#Espace de nom(基本はEspace de nomに書く今回は特別に外)namespaceとimport名を分けることにより日本語文字列のEspace de nomをできるだけ排除しやすいようにする。
namespace ex:
main(opt int)():
return Null
#Ex dans l'espace de noms.main()Accessible avec.(Après avoir lu vers le bas, la fonction principale démarre(S'il est à l'extérieur, il sera intégré à la fonction principale au moment de la compilation et entrera dans main)。)
#aspect(共通aspect)
diversity MyLogging(asp):
def log(int i):
print(f"{i}est")
Il existe un langage Boo comme langage similaire, mais je pense qu'il n'était pas populaire car il n'est pas plus similaire au langage C qu'à Python, alors je l'ai fait en Python qui est facile à compiler avec un typage statique qui peut être écrit comme C, C ++, C # même un peu. Vu. Par conséquent, j'ai également fait référence à C # et Kotlin. Voici la version avec des pointeurs (vous pouvez également écrire des macros ici). .shie c'est bien, mais j'ai choisi .shiex car la grammaire est un peu différente.
ex.shiex
using system;
using os;
using rapt;
using console;
using err;
using collection;
@pragma out_console #out console,only_window,out_window(La valeur par défaut est out_console)
@pragma out_native #out_native out_compile(.jcp) use_jit(compilation de jit/Défaut)Peut être combiné
@pragma style Signal_Colon#Il est possible d'écrire dans le style du langage C.
#Pointeur principal
#thisptr->c'est un type de référence. thisptr est un pointeur.(Inclus avec le système d'exploitation d'espace de noms)
#ptr,o_ptr->*Si tel est le cas, il peut être confondu avec une multiplication et la lisibilité diminuera.(Inclus avec le système d'exploitation d'espace de noms)
#os.id(name)
#macro
@def MyMacro{
@operator when(tex as when rapt.Texture)#Type d'argument conditionnel#L'opérateur de macro peut utiliser la plupart des(Une macro puissante qui vous permet de modifier vous-même la structure)。
}@as if(tex is not None) true else false;
@def PI = 3.14159265358979 #constant(Chaîne)Remplacer
@def TEXT = "ABC"
@def BEGIN @as {
@def END @as }
def unsafe main(opt int)(){
var A[4] = collection.Array<int>{1,2,3,4};
opt int os.ptr s_p = os.id(A);
print(os.o_ptr s_p);#output 1
s_p++;
int s = os.o_ptr s_p;
s_p = os.nullptr;
ref int AA = new {4,5,3,2};
rapt.Texture tx = None;
bool A = MyMacro{when(tx)}
print(A); #output false
if(true) BEGIN ref int BB = AA; END
print(AA[2]); #Erreur de compilation
print(BB[2]); #Erreur de compilation
print(A[1]); #2
print(s); #output 2
return Null;#Réussite
}
Si quelqu'un a la technologie pour le fabriquer, faites-le. Ce que je pensais de l'écriture est difficile à écrire sans IDE.
Ce point de réforme Activé pour déclarer des variables dans le constructeur avec struct (class). Activé pour modifier le nombre de variables dans la méthode de classe (type de référence). Les méthodes (defs à l'intérieur de la classe) et les procédures (defs en dehors de la classe) écrites en dehors de l'espace de noms appartiennent à l'espace de noms de votre nom de fichier. Ajout de mots-clés ifdef () / eldef () / undef (type var, existence de variables), etc. Le type d'option (Null, None) peut omettre le mot clé opt s'il est clair au moment de l'attribution. Si rien n'est écrit en var (la valeur numérique est mutable / le type est immuable), const (le type et la valeur numérique sont immuables), dynamique (aucune déclaration de type n'est requise / le type peut être modifié) (= est fondamentalement var) () ,: = est essentiellement const ,; = est essentiellement dynamique (var dans l'appel de fonction ou l'instruction if)) Livré avec un compilateur using,using ~ as ~,from~ using *,from~ using~ as ~ Fabriqué par un tiers (un programme que vous avez créé vous-même) importer, importer ~ comme ~, depuis ~ importer *, depuis ~ importer ~ comme ~, depuis ~ (nom du fichier) avec ~ (espace de noms) comme * (désactiver un espace de noms spécifique dans le fichier), depuis ~ avec ~ comme ~ (~ Renommer un espace de noms spécifique dans le fichier) De hogehoge avec hugahuga comme huga hogehoge.shie Rend l'espace de noms hugahuga huga (hugahuga.Huga-> huga.Huga, hugahuga de hogehoge ne peut pas être utilisé). Entrée / sortie standard organisée (classe console)
console.shie
print(str) = return None #La chaîne de caractères peut être sortie(Non)Rapide et sécurisé!
scan() = return (type)str #La chaîne de caractères peut être sortie(Non)Rapide et sécurisé!
white(type<genelic>) = return None #Chaîne,La valeur numérique peut être sortie(Non)Calendrier CLI, etc.!
read(type<genelic>) = return (type)str #Chaîne,La valeur numérique peut être saisie(Non)Quand les sauts de ligne gênent
whiteline(type<genelic>) = return None #Chaîne,La valeur numérique peut être sortie(¥ n Oui)Je l'utilise habituellement
readline(type<genelic>) = return (type)str #Chaîne,La valeur numérique peut être saisie(¥ n Oui)Je l'utilise habituellement
input(type<genelic> or f"",~) = return None #La chaîne de caractères F peut être utilisée(¥ n Oui)Lorsque vous voulez la commodité d'utiliser la chaîne de caractères f
output(type<genelic> or f"",~) = return (type)str #La chaîne de caractères F peut être utilisée(¥ n Oui)Lorsque vous voulez la commodité d'utiliser la chaîne de caractères f
linef() return '¥n'
(type)str->format()
exp.shie
from system using *
from console using *
from collection using *
#Procédure hors espace de noms
def sum(var)(var i,var j):
return i+j
#Classe hors espace de noms
class Main:
pub def main(var int)():
abc = new nan.ABC("Ah",10)
output(for(i in range(abc.get_n())) abc.get_is_Nothing())#output "false" * 10
abc.show(3.14159265358979)#output "3.14159265358979"*10
abc.show(3,4,true) #output true*3 false*4
return Null
namespace nan:
class ABC(obj):
pub def _init(str m,int n) without this:
pub set(val) pub get del var .is_Nothing = if(m is None) true elif(m.isEmpty()) true else false
pub set(val) pub get var .n = n
pub def show()(var K)without this:
pub set(val) get var .K = K
output(for(i in range(.n)) .Est K)
pub def operetor== (bool)(ABC abc)without this:
ifdef(.K):
return .isNothig == abc.get_isNothig() and .n == abc.get_n() and .K == abc.k()
undef:
return .isNothig == abc.get_isNothig() and .n == abc.get_n()
#Surcharge
pub def show()(int A,int B,bool C):
var bcd = exp.BCD(A,B,C)
bcd.show()
#Structure hors espace de noms
struct BCD:
pub def _init(int A,int B,bool C) without self:
pub set(val) pub get del var .A = A
.B = B
.C = C
pub def show()()without self:
print(for(a in range(.A))C,for(b in range(.B))not C)
Recommended Posts