Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

by Quentin Hocquet

https://svn.lrde.epita.fr/svn/oln/trunk Index: ChangeLog from Quentin Hocquet <quentin.hocquet(a)lrde.epita.fr> Remove scool compiler. Scool compiler has been moved into its own repository. * tools: Remove. * tools/test.yml: Remove. * tools/tests: Remove. * tools/tests/syntax error: Remove. * tools/tests/syntax error/wrong.scl: Remove. * tools/tests/parse-ref: Remove. * tools/tests/parse-ref/vardec.ref: Remove. * tools/tests/parse-ref/fundec.ref: Remove. * tools/tests/parse-ref/funcall_no-args.ref: Remove. * tools/tests/parse-ref/empty-class_dec.ref: Remove. * tools/tests/parse-ref/varinit.ref: Remove. * tools/tests/parse-ref/emtpy-class_dec.ref: Remove. * tools/tests/parse-ref/no-args_funtype.ref: Remove. * tools/tests/parse-ref/class_dec.ref: Remove. * tools/tests/parse-ref/manydec.ref: Remove. * tools/tests/parse-ref/wiki1.ref: Remove. * tools/tests/parse-ref/bi-exp.ref: Remove. * tools/tests/parse-ref/funcall.ref: Remove. * tools/tests/parse-ref/wiki2.ref: Remove. * tools/tests/parse-ref/function.ref: Remove. * tools/tests/parse-ref/consinit.ref: Remove. * tools/tests/parse-ref/wiki3.ref: Remove. * tools/tests/parse-ref/funtype.ref: Remove. * tools/tests/parse-ref/empty.ref: Remove. * tools/tests/parse-ref/type_static-call.ref: Remove. * tools/tests/parse-ref/guard.ref: Remove. * tools/tests/good: Remove. * tools/tests/good/type_static-call.scl: Remove. * tools/tests/good/guard.scl: Remove. * tools/tests/good/vardec.scl: Remove. * tools/tests/good/fundec.scl: Remove. * tools/tests/good/funcall_no-args.scl: Remove. * tools/tests/good/varinit.scl: Remove. * tools/tests/good/empty-class_dec.scl: Remove. * tools/tests/good/manydec.scl: Remove. * tools/tests/good/no-args_funtype.scl: Remove. * tools/tests/good/class_dec.scl: Remove. * tools/tests/good/wiki1.scl: Remove. * tools/tests/good/funcall.scl: Remove. * tools/tests/good/bi-exp.scl: Remove. * tools/tests/good/function.scl: Remove. * tools/tests/good/wiki2.scl: Remove. * tools/tests/good/consinit.scl: Remove. * tools/tests/good/wiki3.scl: Remove. * tools/tests/good/funtype.scl: Remove. * tools/tests/good/empty.scl: Remove. * tools/transformer: Remove. * tools/transformer/scoolc.str: Remove. * tools/transformer/Makefile: Remove. * tools/scoolc: Remove. * tools/gen.yml: Remove. * tools/parser: Remove. * tools/parser/grammar: Remove. * tools/parser/grammar/Class.sdf: Remove. * tools/parser/grammar/Decl.sdf: Remove. * tools/parser/grammar/Exp.sdf: Remove. * tools/parser/grammar/Scool.sdf: Remove. * tools/parser/grammar/ExpOrType.sdf: Remove. * tools/parser/grammar/Type.sdf: Remove. * tools/parser/grammar/Lexical.sdf: Remove. * tools/parser/grammar/Guard.sdf: Remove. * tools/parser/grammar/Stm.sdf: Remove. * tools/parser/parse-scool: Remove. * tools/parser/Makefile: Remove. * tools/Makefile: Remove. Makefile | 14 ---------- gen.yml | 9 ------ parser/Makefile | 20 -------------- parser/grammar/Class.sdf | 18 ------------- parser/grammar/Decl.sdf | 48 ----------------------------------- parser/grammar/Exp.sdf | 43 ------------------------------- parser/grammar/ExpOrType.sdf | 12 -------- parser/grammar/Guard.sdf | 10 ------- parser/grammar/Lexical.sdf | 28 -------------------- parser/grammar/Scool.sdf | 11 -------- parser/grammar/Stm.sdf | 17 ------------ parser/grammar/Type.sdf | 18 ------------- parser/parse-scool | 8 ----- scoolc | 4 -- test.yml | 18 ------------- tests/good/bi-exp.scl | 1 tests/good/class_dec.scl | 15 ---------- tests/good/consinit.scl | 1 tests/good/empty-class_dec.scl | 1 tests/good/funcall.scl | 4 -- tests/good/funcall_no-args.scl | 4 -- tests/good/function.scl | 4 -- tests/good/fundec.scl | 2 - tests/good/funtype.scl | 1 tests/good/guard.scl | 1 tests/good/manydec.scl | 4 -- tests/good/no-args_funtype.scl | 1 tests/good/type_static-call.scl | 1 tests/good/vardec.scl | 1 tests/good/varinit.scl | 1 tests/good/wiki1.scl | 9 ------ tests/good/wiki2.scl | 5 --- tests/good/wiki3.scl | 9 ------ tests/parse-ref/bi-exp.ref | 1 tests/parse-ref/class_dec.ref | 1 tests/parse-ref/consinit.ref | 1 tests/parse-ref/empty-class_dec.ref | 1 tests/parse-ref/empty.ref | 1 tests/parse-ref/funcall.ref | 1 tests/parse-ref/funcall_no-args.ref | 1 tests/parse-ref/function.ref | 1 tests/parse-ref/fundec.ref | 1 tests/parse-ref/funtype.ref | 1 tests/parse-ref/guard.ref | 1 tests/parse-ref/manydec.ref | 1 tests/parse-ref/no-args_funtype.ref | 1 tests/parse-ref/type_static-call.ref | 1 tests/parse-ref/vardec.ref | 1 tests/parse-ref/varinit.ref | 1 tests/parse-ref/wiki1.ref | 1 tests/parse-ref/wiki2.ref | 1 tests/parse-ref/wiki3.ref | 1 tests/syntax | 1 transformer/Makefile | 6 ---- transformer/scoolc.str | 6 ---- 55 files changed, 375 deletions(-) Index: tools/test.yml --- tools/test.yml (revision 505) +++ tools/test.yml (working copy) @@ -1,18 +0,0 @@ ---- -Test of the Scool parser: !S::Suite - contents: - - Valid input tests: !S::Iterate - over: !pathlist <<pwd>>/tests/good/(*).scl - iter: [it_file, it_name] - test: - Test <<it_name>>: !S::Cmd - command: parser/parse-scool "<<it_file>>" - exit: 0 - output: !path "tests/parse-ref/<<it_name>>.ref" - - Wrong input tests: !S::Iterate - over: !pathlist "<<pwd>>/tests/syntax error/(*).scl" - iter: [it_file, it_name] - test: - Test <<it_name>>: !S::Cmd - command: parser/parse-scool "<<it_file>>" - exit: 1 Index: tools/tests/syntax error/wrong.scl --- tools/tests/syntax error/wrong.scl (revision 505) +++ tools/tests/syntax error/wrong.scl (working copy) @@ -1 +0,0 @@ -var i::int; Index: tools/tests/parse-ref/vardec.ref --- tools/tests/parse-ref/vardec.ref (revision 505) +++ tools/tests/parse-ref/vardec.ref (working copy) @@ -1 +0,0 @@ -Program([VarDec("i",Var("int"))]) Index: tools/tests/parse-ref/fundec.ref --- tools/tests/parse-ref/fundec.ref (revision 505) +++ tools/tests/parse-ref/fundec.ref (working copy) @@ -1 +0,0 @@ -Program([FunDec("f",[("a",Var("int")),("b",Var("int"))],Var("bool"),[])]) Index: tools/tests/parse-ref/funcall_no-args.ref --- tools/tests/parse-ref/funcall_no-args.ref (revision 505) +++ tools/tests/parse-ref/funcall_no-args.ref (working copy) @@ -1 +0,0 @@ -Program([FunDec("doit",[],Var("int"),[Return(FunCall("chiche",[]))])]) Index: tools/tests/parse-ref/empty-class_dec.ref --- tools/tests/parse-ref/empty-class_dec.ref (revision 505) +++ tools/tests/parse-ref/empty-class_dec.ref (working copy) @@ -1 +0,0 @@ -Program([ConsDec("foo",Class,Class([]))]) Index: tools/tests/parse-ref/varinit.ref --- tools/tests/parse-ref/varinit.ref (revision 505) +++ tools/tests/parse-ref/varinit.ref (working copy) @@ -1 +0,0 @@ -Program([VarDec("i",Var("int"),Int("42"))]) Index: tools/tests/parse-ref/emtpy-class_dec.ref Index: tools/tests/parse-ref/no-args_funtype.ref --- tools/tests/parse-ref/no-args_funtype.ref (revision 505) +++ tools/tests/parse-ref/no-args_funtype.ref (working copy) @@ -1 +0,0 @@ -Program([VarDec("f",FunType([],Var("void")))]) Index: tools/tests/parse-ref/class_dec.ref --- tools/tests/parse-ref/class_dec.ref (revision 505) +++ tools/tests/parse-ref/class_dec.ref (working copy) @@ -1 +0,0 @@ -Program([ConsDec("point",Class,Class([Accessblock(Public,[FunDec("x",[],Var("int"),[Return(Var("x"))])]),Accessblock(Private,[VarDec("x",Var("int")),VarDec("y",Var("int"))])]))]) Index: tools/tests/parse-ref/manydec.ref --- tools/tests/parse-ref/manydec.ref (revision 505) +++ tools/tests/parse-ref/manydec.ref (working copy) @@ -1 +0,0 @@ -Program([ConsDec("answer",Var("int"),Int("42")),VarDec("i",Var("int")),VarDec("j",Var("int"),Var("i"))]) Index: tools/tests/parse-ref/wiki1.ref --- tools/tests/parse-ref/wiki1.ref (revision 505) +++ tools/tests/parse-ref/wiki1.ref (working copy) @@ -1 +0,0 @@ -Program([FunDec("f",[],Var("void"),[ConsDec("i",Var("int16"),Int("3")),ExpStm(Affect(Var("i"),Int("4"))),VarDec("j",Var("int16"),Int("3")),ExpStm(Affect(Var("j"),Int("4")))])]) Index: tools/tests/parse-ref/bi-exp.ref --- tools/tests/parse-ref/bi-exp.ref (revision 505) +++ tools/tests/parse-ref/bi-exp.ref (working copy) @@ -1 +0,0 @@ -Program([ConsDec("i",Var("int"),BiFunCall("pow",[Int("4")],[Int("3")]))]) Index: tools/tests/parse-ref/funcall.ref --- tools/tests/parse-ref/funcall.ref (revision 505) +++ tools/tests/parse-ref/funcall.ref (working copy) @@ -1 +0,0 @@ -Program([FunDec("doit",[],Var("int"),[Return(FunCall("chiche",[String("\"pelle\""),String("\"branle\"")]))])]) Index: tools/tests/parse-ref/wiki2.ref --- tools/tests/parse-ref/wiki2.ref (revision 505) +++ tools/tests/parse-ref/wiki2.ref (working copy) @@ -1 +0,0 @@ -Program([FunDec("f",[],Var("void"),[VarDec("a",StaticFunCall("array",[Int("2"),Var("int16")])),VarDec("i",Var("int16"),MethodCall("a","at",[Int("0")]))])]) Index: tools/tests/parse-ref/function.ref --- tools/tests/parse-ref/function.ref (revision 505) +++ tools/tests/parse-ref/function.ref (working copy) @@ -1 +0,0 @@ -Program([FunDec("answer",[],Var("int"),[Return(Int("42"))])]) Index: tools/tests/parse-ref/consinit.ref --- tools/tests/parse-ref/consinit.ref (revision 505) +++ tools/tests/parse-ref/consinit.ref (working copy) @@ -1 +0,0 @@ -Program([ConsDec("i",Var("int"),Int("3"))]) Index: tools/tests/parse-ref/wiki3.ref --- tools/tests/parse-ref/wiki3.ref (revision 505) +++ tools/tests/parse-ref/wiki3.ref (working copy) @@ -1 +0,0 @@ -Program([FunDec("f",[],Var("void"),[VarDec("i",Var("int")),VarDec("j",Var("int")),ExpStm(Affect(Var("i"),Int("0"))),ExpStm(Affect(Var("j"),Var("i"))),ExpStm(Affect(Var("i"),Sum(Var("j"),Var("i"))))])]) Index: tools/tests/parse-ref/funtype.ref --- tools/tests/parse-ref/funtype.ref (revision 505) +++ tools/tests/parse-ref/funtype.ref (working copy) @@ -1 +0,0 @@ -Program([VarDec("f",FunType([Var("int"),Var("bool")],Var("float")))]) Index: tools/tests/parse-ref/empty.ref --- tools/tests/parse-ref/empty.ref (revision 505) +++ tools/tests/parse-ref/empty.ref (working copy) @@ -1 +0,0 @@ -Program([]) Index: tools/tests/parse-ref/type_static-call.ref --- tools/tests/parse-ref/type_static-call.ref (revision 505) +++ tools/tests/parse-ref/type_static-call.ref (working copy) @@ -1 +0,0 @@ -Program([VarDec("l",StaticFunCall("list",[Var("int")]))]) Index: tools/tests/parse-ref/guard.ref --- tools/tests/parse-ref/guard.ref (revision 505) +++ tools/tests/parse-ref/guard.ref (working copy) @@ -1 +0,0 @@ -Program([BiFunDec("f",[("i",Var("int"),Guard(Sup(Var("i"),Int("0"))))],[],Var("int"),[])]) Index: tools/tests/good/type_static-call.scl --- tools/tests/good/type_static-call.scl (revision 505) +++ tools/tests/good/type_static-call.scl (working copy) @@ -1 +0,0 @@ -var l : list[int]; Index: tools/tests/good/guard.scl --- tools/tests/good/guard.scl (revision 505) +++ tools/tests/good/guard.scl (working copy) @@ -1 +0,0 @@ -f : [i : int where i > 0]() -> int = {} \ No newline at end of file Index: tools/tests/good/vardec.scl --- tools/tests/good/vardec.scl (revision 505) +++ tools/tests/good/vardec.scl (working copy) @@ -1 +0,0 @@ -var i : int; Index: tools/tests/good/fundec.scl --- tools/tests/good/fundec.scl (revision 505) +++ tools/tests/good/fundec.scl (working copy) @@ -1,2 +0,0 @@ -f : (a: int, b : int) -> bool = -{} Index: tools/tests/good/funcall_no-args.scl --- tools/tests/good/funcall_no-args.scl (revision 505) +++ tools/tests/good/funcall_no-args.scl (working copy) @@ -1,4 +0,0 @@ -doit : () -> int = -{ - -> foo(); -} \ No newline at end of file Index: tools/tests/good/varinit.scl --- tools/tests/good/varinit.scl (revision 505) +++ tools/tests/good/varinit.scl (working copy) @@ -1 +0,0 @@ -var i : int := 42; Index: tools/tests/good/empty-class_dec.scl --- tools/tests/good/empty-class_dec.scl (revision 505) +++ tools/tests/good/empty-class_dec.scl (working copy) @@ -1 +0,0 @@ -foo : class = {}; \ No newline at end of file Index: tools/tests/good/manydec.scl --- tools/tests/good/manydec.scl (revision 505) +++ tools/tests/good/manydec.scl (working copy) @@ -1,4 +0,0 @@ -answer : int = 42; - -var i : int; -var j : int := i; Index: tools/tests/good/no-args_funtype.scl --- tools/tests/good/no-args_funtype.scl (revision 505) +++ tools/tests/good/no-args_funtype.scl (working copy) @@ -1 +0,0 @@ -var f : () -> void; \ No newline at end of file Index: tools/tests/good/class_dec.scl --- tools/tests/good/class_dec.scl (revision 505) +++ tools/tests/good/class_dec.scl (working copy) @@ -1,15 +0,0 @@ -point : class = -{ - public - { - x : () -> int = - { - -> x; - } - } - private - { - var x :int; - var y :int; - } -}; \ No newline at end of file Index: tools/tests/good/wiki1.scl --- tools/tests/good/wiki1.scl (revision 505) +++ tools/tests/good/wiki1.scl (working copy) @@ -1,9 +0,0 @@ - -f : () -> void = -{ - i : int16 = 3; - i := 4; - - var j : int16 := 3; - j := 4; -} \ No newline at end of file Index: tools/tests/good/funcall.scl --- tools/tests/good/funcall.scl (revision 505) +++ tools/tests/good/funcall.scl (working copy) @@ -1,4 +0,0 @@ -doit : () -> int = -{ - -> foo("bar", "baz"); -} \ No newline at end of file Index: tools/tests/good/bi-exp.scl --- tools/tests/good/bi-exp.scl (revision 505) +++ tools/tests/good/bi-exp.scl (working copy) @@ -1 +0,0 @@ -i : int = pow[4](3); \ No newline at end of file Index: tools/tests/good/function.scl --- tools/tests/good/function.scl (revision 505) +++ tools/tests/good/function.scl (working copy) @@ -1,4 +0,0 @@ -answer : () -> int = -{ - -> 42; -} \ No newline at end of file Index: tools/tests/good/wiki2.scl --- tools/tests/good/wiki2.scl (revision 505) +++ tools/tests/good/wiki2.scl (working copy) @@ -1,5 +0,0 @@ -f : () -> void = -{ - var a : array[2,int16]; - var i : int16 := a.at(0); -} Index: tools/tests/good/consinit.scl --- tools/tests/good/consinit.scl (revision 505) +++ tools/tests/good/consinit.scl (working copy) @@ -1 +0,0 @@ -i : int = 3; \ No newline at end of file Index: tools/tests/good/wiki3.scl --- tools/tests/good/wiki3.scl (revision 505) +++ tools/tests/good/wiki3.scl (working copy) @@ -1,9 +0,0 @@ -f : () -> void = -{ - var i : int; - var j : int; - - i := 0; - j := i; - i := j + i; -} Index: tools/tests/good/funtype.scl --- tools/tests/good/funtype.scl (revision 505) +++ tools/tests/good/funtype.scl (working copy) @@ -1 +0,0 @@ -var f : (int, bool) -> float; \ No newline at end of file Index: tools/tests/good/empty.scl Index: tools/transformer/scoolc.str --- tools/transformer/scoolc.str (revision 505) +++ tools/transformer/scoolc.str (working copy) @@ -1,6 +0,0 @@ -module scoolc - -imports liblib Scool - -strategies - main = io-wrap(id) Index: tools/transformer/Makefile --- tools/transformer/Makefile (revision 505) +++ tools/transformer/Makefile (working copy) @@ -1,6 +0,0 @@ - -scoolc: scoolc.str - strc -i $< -I ../parser -la stratego-lib - -clean: - rm -rf scoolc scoolc.dep scoolc.o scoolc.c .libs Index: tools/scoolc --- tools/scoolc (revision 505) +++ tools/scoolc (working copy) @@ -1,4 +0,0 @@ -#!/bin/sh -# -*- sh -*- - -parser/parse-scool $1 | transformer/scoolc Index: tools/gen.yml --- tools/gen.yml (revision 505) +++ tools/gen.yml (working copy) @@ -1,9 +0,0 @@ ---- -Autogeneration of the Scool parser references: !S::Suite - contents: - - Generation: !S::Iterate - over: !pathlist <<pwd>>/tests/good/(*).scl - iter: [it_file, it_name] - test: - Generation <<it_name>>: !S::Cmd - command: parser/parse-scool "<<it_file>>" > "<<pwd>>/tests/good/<<it_name>>.ref" Index: tools/parser/grammar/Class.sdf --- tools/parser/grammar/Class.sdf (revision 505) +++ tools/parser/grammar/Class.sdf (working copy) @@ -1,18 +0,0 @@ -module Class - -imports - Lexical Decl - -exports - sorts Class AccessBlock AccessModifier - context-free syntax - "{" AccessBlock* "}" -> Class {cons("Class")} - - AccessModifier "{" Decl* "}" -> AccessBlock {cons("Accessblock")} - - "public" -> AccessModifier {cons("Public")} - "protected" -> AccessModifier {cons("Protected")} - "private" -> AccessModifier {cons("Private")} - - lexical restrictions - AccessModifier -/- [A-Za-z] Index: tools/parser/grammar/Decl.sdf --- tools/parser/grammar/Decl.sdf (revision 505) +++ tools/parser/grammar/Decl.sdf (working copy) @@ -1,48 +0,0 @@ -module Decl - -imports - Lexical Type Guard Stm - -exports - sorts Decl - context-free syntax - - "var" Id ":" Type ";" -> Decl {cons("VarDec")} - "var" Id ":" Type ":=" Exp ";" -> Decl {cons("VarDec")} - Id ":" Type "=" Exp ";" -> Decl {cons("ConsDec")} - Id ":" Type ";" -> Decl {cons("ConsDec")} - - Id ":" "(" {(Id ":" Type) ","}* ")" "->" Type - "=" "{" Stm* "}" -> Decl {cons("FunDec")} - - Id ":" "[" {(Id ":" Type Guard) ","}* "]" "->" Type - "=" "{" Stm* "}" -> Decl {cons("StaticFunDec")} - - Id ":" "[" {(Id ":" Type Guard) ","}* "]" "(" {(Id ":" Type) ","}* ")" "->" Type - "=" "{" Stm* "}" -> Decl {cons("BiFunDec")} - - Id ":" "(" {(Id ":" Type) ","}* ")" "->" Type - "=>" Exp -> Decl {cons("FunDec")} - - Id ":" "[" {(Id ":" Type Guard) ","}* "]" "->" Type - "=>" Exp -> Decl {cons("StaticFunDec")} - - Id ":" "[" {(Id ":" Type Guard) ","}* "]" "(" {(Id ":" Type) ","}* ")" "->" Type - "=>" Exp -> Decl {cons("BiFunDec")} - - - "decl" Id ":" "(" {(Type | (Id ":" Type)) ","}* ")" - "->" Type ";" -> Decl {cons("FunPreDec")} - - - Id ":" "[" {(Id ":" Type) ","}* "]" "->" Type - "=" "{" Stm* "}" -> Decl {cons("StaticFunDec")} - - Id ":" "[" {(Id ":" Type) ","}* "]" "(" {(Id ":" Type) ","}* ")" "->" Type - "=" "{" Stm* "}" -> Decl {cons("BiFunDec")} - - Id ":" "[" {(Id ":" Type) ","}* "]" "->" Type - "=>" Exp -> Decl {cons("StaticFunDec")} - - Id ":" "[" {(Id ":" Type) ","}* "]" "(" {(Id ":" Type) ","}* ")" "->" Type - "=>" Exp -> Decl {cons("BiFunDec")} \ No newline at end of file Index: tools/parser/grammar/Exp.sdf --- tools/parser/grammar/Exp.sdf (revision 505) +++ tools/parser/grammar/Exp.sdf (working copy) @@ -1,43 +0,0 @@ -module Exp - -imports - Lexical Type ExpOrType Class - -exports - sorts Exp - context-free syntax - - ExpOrType -> Exp - Int -> Exp {cons("Int")} - String -> Exp {cons("String")} - Id "(" {Exp ","}* ")" -> Exp {cons("FunCall")} - Id "[" {Exp ","}* "]" - "(" {Exp ","}* ")" -> Exp {cons("BiFunCall")} - Exp "+" Exp -> Exp {cons("Sum")} - Exp "-" Exp -> Exp {cons("Sub")} - Exp "*" Exp -> Exp {cons("Mul")} - Exp "/" Exp -> Exp {cons("Div")} - Exp "=" Exp -> Exp {cons("Eq")} - Exp "!=" Exp -> Exp {cons("Neq")} - Exp "<" Exp -> Exp {cons("Inf")} - Exp ">" Exp -> Exp {cons("Sup")} - Exp ">=" Exp -> Exp {cons("SupEq")} - Exp "<=" Exp -> Exp {cons("InfEq")} - Exp ":=" Exp -> Exp {cons("Affect")} - Class -> Exp - Exp "." Id -> Exp {cons("Field")} - Id "." Id "(" {Exp ","}* ")" -> Exp {cons("MethodCall")} - - context-free priorities - - {left: - Exp "/" Exp -> Exp - Exp "*" Exp -> Exp - } -> {left: - Exp "+" Exp -> Exp - Exp "-" Exp -> Exp - } -> {right: - Exp ":=" Exp -> Exp - } \ No newline at end of file Index: tools/parser/grammar/Scool.sdf --- tools/parser/grammar/Scool.sdf (revision 505) +++ tools/parser/grammar/Scool.sdf (working copy) @@ -1,11 +0,0 @@ -module Scool - -imports - Decl - -exports - sorts Program - context-free start-symbols Program - context-free syntax - - Decl* -> Program {cons("Program")} Index: tools/parser/grammar/ExpOrType.sdf --- tools/parser/grammar/ExpOrType.sdf (revision 505) +++ tools/parser/grammar/ExpOrType.sdf (working copy) @@ -1,12 +0,0 @@ -module ExpOrType - -imports - Lexical Exp - -exports - - sorts ExpOrType - context-free syntax - Id "[" {Exp ","}* "]" -> ExpOrType {cons("StaticFunCall")} - Id -> ExpOrType {cons("Var")} - Id "::" Exp -> ExpOrType {cons("Scope")} Index: tools/parser/grammar/Type.sdf --- tools/parser/grammar/Type.sdf (revision 505) +++ tools/parser/grammar/Type.sdf (working copy) @@ -1,18 +0,0 @@ -module Type - -imports - ExpOrType - - -exports - - sorts Type - context-free syntax - - ExpOrType -> Type - "(" {Type ","}* ")" "->" Type -> Type {cons("FunType")} - "[" {Type ","}* "]" "->" Type -> Type {cons("StaticFunType")} - "[" {Type ","}* "]" - "(" {Type ","}* ")" "->" Type -> Type {cons("BiFunType")} - "class" -> Type {cons("Class")} - "class" "<" Type -> Type {cons("Class")} Index: tools/parser/grammar/Lexical.sdf --- tools/parser/grammar/Lexical.sdf (revision 505) +++ tools/parser/grammar/Lexical.sdf (working copy) @@ -1,28 +0,0 @@ -module Lexical - -exports - sorts Id Int String Asterisk Slash BlockComment CommentPart Cpp - lexical syntax - - [A-Za-z][A-Za-z0-9\_]* -> Id {cons("Id")} - [0-9]+ -> Int {cons("Int")} - "\"" [A-Za-z0-9]* "\"" -> String {cons("String")} - "//" ~[\n]* [\n] -> LAYOUT - [\ \t\n] -> LAYOUT - "/+" ~[]* "+/" -> Cpp - "class" -> Id {reject} - - BlockComment -> LAYOUT - - "/*" CommentPart* "*/" -> BlockComment - ~[\/\*] -> CommentPart - Asterisk -> CommentPart - Slash -> CommentPart - BlockComment -> CommentPart - [\/] -> Slash - [\*] -> Asterisk - - lexical restrictions - Id -/- [A-Za-z] - Asterisk -/- [\/] - Slash -/- [\*] Index: tools/parser/grammar/Guard.sdf --- tools/parser/grammar/Guard.sdf (revision 505) +++ tools/parser/grammar/Guard.sdf (working copy) @@ -1,10 +0,0 @@ -module Guard - -imports - Exp - -exports - sorts Guard - context-free syntax - - "where" Exp -> Guard {cons("Guard")} Index: tools/parser/grammar/Stm.sdf --- tools/parser/grammar/Stm.sdf (revision 505) +++ tools/parser/grammar/Stm.sdf (working copy) @@ -1,17 +0,0 @@ -module Stm - -imports - Lexical Exp Decl - -exports - sorts Stm - context-free syntax - - ";" -> Stm {cons("EmptyStm")} - Exp ";" -> Stm {cons("ExpStm")} - "->" Exp ";" -> Stm {cons("Return")} - "{" Stm* "}" -> Stm {cons("Block")} - "if" "(" Exp ")" Stm ("else" Stm)? -> Stm {cons("If")} - "while" "(" Exp ")" Stm -> Stm {cons("While")} - Decl -> Stm - Cpp -> Stm {cons("CppStm")} Index: tools/parser/parse-scool --- tools/parser/parse-scool (revision 505) +++ tools/parser/parse-scool (working copy) @@ -1,8 +0,0 @@ -#!/bin/sh -# -*- sh -*- - -if [ $# -eq 0 ]; then - echo "usage: parse-scool file.scl" -else - sglri -p parser/Scool.tbl -i $1 -fi Index: tools/parser/Makefile --- tools/parser/Makefile (revision 505) +++ tools/parser/Makefile (working copy) @@ -1,20 +0,0 @@ -SDF = $(wildcard grammar/*.sdf) -OUT = Scool - -all: Scool.def Scool.tbl Scool.str - -Scool.def: $(SDF) - pack-sdf -i grammar/Scool.sdf -o $@ - -Scool.tbl: Scool.def - sdf2table -i $< -o $@ -m Scool - -Scool.rtg: Scool.def - sdf2rtg -i $< -m Scool -o $@ - -Scool.str: Scool.rtg - rtg2sig --module Scool -i $< -o $@ - -clean: - rm -rf Scool.* log.* - Index: tools/Makefile --- tools/Makefile (revision 505) +++ tools/Makefile (working copy) @@ -1,14 +0,0 @@ -all: - cd parser && make - cd transformer && make - -clean: - rm -rf log.* - cd parser && make clean - cd transformer && make clean - -check: all - uttk test.yml - -gen: all - uttk gen.yml

19 years

505: Remove external link to transformers.

by Quentin Hocquet

https://svn.lrde.epita.fr/svn/oln/trunk Index: ChangeLog from Quentin Hocquet <quentin.hocquet(a)lrde.epita.fr> Remove external link to transformers. * tools: Remove svn:external property. 0 files changed Property changes on: tools ___________________________________________________________________ Name: svn:externals - transformers -r 1407 https://svn.lrde.epita.fr/svn/transformers/trunk +

19 years

oln-0.10 10.223: Fix an ambiguity with G++ 4.0

by Roland Levillain

Sorry for the ugly patch, but Vcs is broken on my machine, and prdiff neither works. Index: 10.222/olena/ChangeLog Index: 10.222/olena/oln/arith/internal/opdecls.hh --- 10.222/olena/ChangeLog Thu, 15 Sep 2005 17:50:38 +0200 levill_r (oln/o/30_ChangeLog 1.27.1.36.1.3.1.11.1.5.1.64.1.47.1.93.1.27.2.4 600) +++ 10.222(w)/olena/ChangeLog Wed, 21 Jun 2006 19:30:10 +0200 levill_r (oln/o/30_ChangeLog 1.27.1.36.1.3.1.11.1.5.1.64.1.47.1.93.1.27.2.4 600) @@ -1,3 +1,8 @@ +2006-06-21 Roland Levillain <roland(a)lrde.epita.fr> + + * oln/arith/internal/opdecls.hh (oln_arith_declare_binop_procs_): + Remove the third operator, causing a an ambiguity with G++ 4.0. + 2005-09-15 Roland Levillain <roland(a)lrde.epita.fr> Adjust for G++ 4.0. --- 10.222/olena/oln/arith/internal/opdecls.hh Tue, 13 Apr 2004 17:31:32 +0200 van-vl_n (oln/b/22_opdecls.hh 1.19 600) +++ 10.222(w)/olena/oln/arith/internal/opdecls.hh Fri, 16 Jun 2006 17:50:32 +0200 levill_r (oln/b/22_opdecls.hh 1.19 600) @@ -218,18 +218,41 @@ T2, \ ntg_return_type(OPNAME, T1, T2)>()), \ input1, input2); \ - } \ - \ - /* Same as above, with inline conversion in the functor. */ \ - template<class IRet, class I1, class I2> inline \ - typename mute<I1, oln_value_type(IRet)>::ret \ - OPNAME(const abstract::image<I1>& input1, const abstract::image<I2>& input2) \ - { \ - return apply2(f_##OPNAME<oln_value_type(I1), \ - oln_value_type(I2), \ - oln_value_type(IRet)>(), \ - input1, input2); \ } +/* FIXME: Used to be part from the previous macro, but causes ambiguous + calls with G++ 4.0 and 4.1: theses compiler seems to consider that + + OPNAME(ima1, ima2); + + could be both interpreted as a call to + + template<class I1, class I2> inline + typename arith_return_type_proxy_##OPNAME##_<I1, I2>::ret + OPNAME(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) + + or + + template<class IRet, class I1, class I2> inline + typename mute<I1, oln_value_type(IRet)>::ret + OPNAME(const abstract::image<I1>& input1, + const abstract::image<I2>& input2) + + despite the fact that this call doesn't resolve the first parameter + (`IRet') of the second version. It might be a bug in the 4.x branch + of G++. */ +// +// +// /* Same as above, with inline conversion in the functor. */ +// template<class IRet, class I1, class I2> inline +// typename mute<I1, oln_value_type(IRet)>::ret +// OPNAME(const abstract::image<I1>& input1, const abstract::image<I2>& input2) +// { +// return apply2(f_##OPNAME<oln_value_type(I1), +// oln_value_type(I2), +// oln_value_type(IRet)>(), +// input1, input2); +// } /// Apply OPNAME with a constant as second operand. # define oln_arith_declare_binopcst_procs_(OPNAME) \

19 years

504: Document method checks in Static tour

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/static ChangeLog | 13 +++++ tests/tour.cc | 126 +++++++++++++++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 133 insertions(+), 6 deletions(-) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Document method checks in Static tour. * tests/tour.cc (static_hierarchy_with_methods::test): Rename as... (static_hierarchy_with_methods::test1): ...this. (main): Adjust. (static_hierarchy_with_methods::D): New. (static_hierarchy_with_methods::test2): New. (static_hierarchy_with_method_checks): New section. Add a reference (Concept Checking). 2006-06-15 Roland Levillain <roland(a)lrde.epita.fr> Index: tests/tour.cc --- tests/tour.cc (révision 503) +++ tests/tour.cc (révision 504) @@ -31,6 +31,7 @@ #include <cassert> #include <mlc/assert.hh> +#include <mlc/contract.hh> #include <mlc/is_a.hh> #include <mlc/cmp.hh> @@ -394,7 +395,7 @@ namespace static_hierarchy_with_methods { - void test() + void test1() { C c; assert (c.foo() == 4); @@ -412,20 +413,133 @@ } // end of namespace static_hierarchy_with_methods -// FIXME: Introduce static checks of methods (kind of concept checking). +// --------------------------- // +// Enforcing method checking. // +// --------------------------- // + +/* For a given `Exact' type, consider the `A<Exact>::foo' method. + This method relies on the fact that `Exact' has an `impl_foo' + method. However, the compiler let you instantiate an a class + `A<Exact>' with an `Exact' type not fulfilling this requirement, + and even worse, you can instantiate an object of this ill-formed + type! The compiler will complain only when it tries to resolve the + call to the (missing) `impl_foo' method. */ + +namespace static_hierarchy_with_methods +{ + + // For instance, let's introduce an ill-formed concrete subclass of A. + struct D : public A<D> + { + // No `impl_foo'. + }; + + /* `D' is not a valid exact type for A. Despite this fact, we can + instantiate this template with `D', as well as an object of this + type! */ + void test2() + { + // Valid (!). + typedef A<D> A_D; + // Equally valid (!). + A_D a; + // This call would fail if it were not disabled. +#if 0 + a.foo(); +#endif + } + +} // end of namespace static_hierarchy_with_methods + + +/* Metalic proposes a concept checking tool similar to the one used in + the Boost Concept Check Library (BCCL) [2], + `mlc_check_method_impl'. We use it to check that SCOOP abstract + polymorphic methods defined in an abstract class have a valid + implementation in one of the subclasses (i.e., "between" this + abstraction and the exact type). */ + +namespace static_hierarchy_with_method_checks +{ + + template <typename Exact> + struct A : public stc::any<Exact> + { + int foo() { return this->exact().impl_foo(); } + int impl_foo() { return 1; } + int bar() { return this->exact().impl_bar(); } + + /* Method checks are placed in the destructor, since they must + reside within a function body. */ + ~A() + { + /* `foo' is abstract in `A'. Ensure A's subclasses define an + implementation for this method. */ + mlc_check_method_impl(Exact, int, bar, /* no arg */, /* no const */); + } + }; + + template <typename Exact> + struct B : public A< stc_find_exact(B, Exact) > + { + int impl_foo() { return 2; } + int impl_bar() { return 3; } + }; + + struct C : public B<C> + { + int impl_foo() { return 4; } + }; + + struct D : public A<D> + { + // No `impl_foo'. + }; + + + void test() + { + /* Invalid template instantiation, because of `impl_foo' missing. + Upon this code, the compiler would emit an error message + similar to this one: + + error: 'impl_bar' is not a member of + 'static_hierarchy_with_method_checks::D' + + */ +#if 0 + typedef A<D> A_D; + A_D a; +#endif + } + +} // end of namespace static_hierarchy_with_method_checks + +/*-------. +| Misc. | +`-------*/ + // Run dynamic tests. int main() { static_hierarchy_with_any::test(); - static_hierarchy_with_methods::test(); + static_hierarchy_with_methods::test1(); } -/* References: - [1] Coplien, James O. (1995, February). "Curiously Recurring - Template Patterns". C++ Report: 24-27. */ + +/*-------------. +| References. | +`-------------*/ + +/* [1] James O. Coplien. ``Curiously Recurring Template + Patterns''. C++ Report: 24-27. 1995, February. + + [2] Jeremy Siek, Andrew Lumsdaine. ``Concept Checking: Binding + Parametric Polymorphism in C++''. In Proceedings of the ``Workshop + on C++ Template Programming''. 2000. */

19 years

503: More on SCOOP methods in Static tour

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/static ChangeLog | 18 +++++++++++++++++ tests/tour.cc | 61 +++++++++++++++++++++++++++++++++++++++++++++------------- 2 files changed, 66 insertions(+), 13 deletions(-) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> More on SCOOP methods in Static tour. * tests/tour.cc (dynamic_hierarchy::A::foo) (dynamic_hierarchy::A::bar, dynamic_hierarchy::B::foo) (dynamic_hierarchy::B::bar, dynamic_hierarchy::C::foo): Return an int value. (static_hierarchy_with_methods::A::foo) (static_hierarchy_with_methods::A::impl_foo) (static_hierarchy_with_methods::A::bar) (static_hierarchy_with_methods::B::impl_foo) (static_hierarchy_with_methods::B::impl_bar) (static_hierarchy_with_methods::C::impl_foo): Likewise. (static_hierarchy_with_methods): Add comments. (static_hierarchy_with_methods::test): New. (main): Call it. Index: tests/tour.cc --- tests/tour.cc (révision 502) +++ tests/tour.cc (copie de travail) @@ -75,25 +75,25 @@ struct A { // A virtual method. - virtual void foo() { /* ... */ } + virtual int foo() { return 1; } // A virtual pure method. - virtual void bar() = 0; + virtual int bar() = 0; }; // `B' is a concrete class. struct B { // A redefined method. - virtual void foo() { /* ... */ } + virtual int foo() { return 2; } // `B::bar' is defined. - virtual void bar() { /* ... */ } + virtual int bar() { return 3; } }; // `C' is a concrete class. struct C { // `B::foo' is redefined. - virtual void foo() { /* ... */ } + virtual int foo() { return 4; } }; } // end of namespace dynamic_hierarchy @@ -338,9 +338,22 @@ // Methods. // // --------- // -// Add the methods. +/* We have laid down the foundations of our classes. Now it's time to + add some methods. -// FIXME: Comments. + Unlike classic C++, SCOOP doesn't use the `virtual' keyword to + define polymorphic methods. As SCOOP performs a static resolution + of method calls, it can't rely on `virtual' (which is dynamic per + se). Instead, a manual dispatch of method call is used: each + polymorphic method is turned into a facade, and there is one + implementation per class defining this method actually. The facade + retrieves the exact type of the object, and calls the + implementation corresponding to this type. A SCOOP abstract + polymorphic method (the equivalent of C++ ``virtual pure'' method) + has no implementation in the class where its facade is defined. + + The convention is to name `impl_m' the implementation(s) of the + facade `m'. */ namespace static_hierarchy_with_methods { @@ -351,12 +364,12 @@ /* Facade of a statically-dispatched method. Notice there is no `virtual' keyword: the (static) dispatch is done manually through the delegation to impl_foo. */ - void foo() { this->exact().impl_foo(); } + int foo() { return this->exact().impl_foo(); } // Implementation of the method. - void impl_foo() { /* ... */ } + int impl_foo() { return 1; } // A ``virtual'' pure (i.e., abstract) method. - void bar() { this->exact().impl_bar(); } + int bar() { return this->exact().impl_bar(); } // (No `impl_bar', since bar is abstract.) }; @@ -364,20 +377,41 @@ struct B : public A< stc_find_exact(B, Exact) > { // A redefined method. - void impl_foo() { /* ... */ } + int impl_foo() { return 2; } // B::bar (implementation) is defined. - void impl_bar() { /* ... */ } + int impl_bar() { return 3; } }; struct C : public B<C> { // Redefinition. - void impl_foo() { /* ... */ } + int impl_foo() { return 4; } }; } // end of namespace static_hierarchy_with_methods +namespace static_hierarchy_with_methods +{ + + void test() + { + C c; + assert (c.foo() == 4); + assert (c.bar() == 3); + + B<C>& b = c; + assert (b.foo() == 4); + assert (b.bar() == 3); + + A<C>& a = c; + assert (a.foo() == 4); + assert (a.bar() == 3); + } + +} // end of namespace static_hierarchy_with_methods + + // FIXME: Introduce static checks of methods (kind of concept checking). @@ -385,6 +419,7 @@ int main() { static_hierarchy_with_any::test(); + static_hierarchy_with_methods::test(); } /* References:

19 years

502: More on the retrieval of/conversion to the exact type in Static tour

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/static ChangeLog | 15 +++++++++++- tests/tour.cc | 70 ++++++++++++++++++++++++++++++++++++++++++++++++---------- 2 files changed, 73 insertions(+), 12 deletions(-) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> More on the retrieval of and the conversion to the exact type in Static tour. * tests/tour.cc (static_hierarchy_with_any): More on the retrieval of and the conversion to the exact type. (main): Run dynamic tests. (static_hierarchy_with_any::A) (static_hierarchy_with_a_non_leaf_concrete_class::A) (static_hierarchy_with_methods::A): Use stc::any instead of stc::any__simple. 2006-06-14 Roland Levillain <roland(a)lrde.epita.fr> Add stc_to_exact and stc_to_exact_ macros. Index: tests/tour.cc --- tests/tour.cc (révision 500) +++ tests/tour.cc (copie de travail) @@ -28,7 +28,14 @@ /// \file tests/tour.cc /// \brief A tour of Static and SCOOP features. +#include <cassert> + +#include <mlc/assert.hh> +#include <mlc/is_a.hh> +#include <mlc/cmp.hh> + # include <stc/any.hh> +#include <stc/exact.hh> # include <stc/find_exact.hh> // FIXME: ``Fil rouge'': building a small (but complete) static @@ -41,7 +48,7 @@ // having introduced the vtypes. // FIXME: Things to show: -// - exact +// - exact (more) // - super // - virtual types (and macros for super) // - multiple super @@ -167,8 +174,8 @@ to this type. In fact, there is not a single `stc::any' class, but several, which have their advantages and drawbacks w.r.t. speed, memory print and support for diamond inheritance. - We'll only deal with `stc::any__simple' in this Static tour: - where you'll see `stc::any', simply read `stc::any__simple'. + We'll only deal with `stc::any' (an alias for `stc::any__simple') + in this Static tour. `stc::any' is used as the base class of any top class of a static hierarchy. It is passed the `Exact' type, just like any non-leaf @@ -176,7 +183,7 @@ derived, i.e., at the bottom of an inheritance tree). */ template <typename Exact> - struct A : public stc::any__simple<Exact> + struct A : public stc::any<Exact> { }; @@ -199,11 +206,47 @@ } // end of namespace static_hierarchy_with_any -// ------------ // -// stc::exact. // -// ------------ // +// -------------------------------- // +// Getting back to the exact type. // +// -------------------------------- // -// FIXME: To do. +namespace static_hierarchy_with_any +{ + void test() + { + // Metalic assertions. + mlc::assert_< mlc_is_a_(C, A) >::check(); + mlc::assert_< mlc_is_a_(C, B) >::check(); + + + // Getting the exact type. + + // `stc::any' has an `exact_type' typedef. + typedef A<C>::exact_type exact_type_of_A_1; + // But you can also use stc_to_exact_ to get this type. + typedef stc_to_exact_(A<C>) exact_type_of_A_2; + // Check these types. + mlc::assert_< mlc_eq(exact_type_of_A_1, C) >::check(); + mlc::assert_< mlc_eq(exact_type_of_A_2, C) >::check(); + + + // Converting an object to its exact type. + + // Create a C. + C c; + // See it through an abstraction. + A<C>& a = c; + // And get it back, with no runtime overhead (i.e., dynamic_cast). + C& c2 = a.exact(); + // Ensure we got back the same object. + assert (&c2 == &c); + + // stc::exact provides the same service. + C& c3 = stc::exact(a); + assert (&c3 == &c); + } + +} // end of namespace static_hierarchy_with_any // --------------------------- // @@ -236,7 +279,7 @@ /* A is left unchanged (it is still an abstract class). */ template <typename Exact> - struct A : public stc::any__simple<Exact> + struct A : public stc::any<Exact> { }; @@ -303,7 +346,7 @@ { template <typename Exact> - struct A : public stc::any__simple<Exact> + struct A : public stc::any<Exact> { /* Facade of a statically-dispatched method. Notice there is no `virtual' keyword: the (static) dispatch is done manually @@ -337,7 +380,12 @@ // FIXME: Introduce static checks of methods (kind of concept checking). -int main() {} + +// Run dynamic tests. +int main() +{ + static_hierarchy_with_any::test(); +} /* References:

19 years

501: Add stc_to_exact and stc_to_exact macros.

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/static ChangeLog | 14 ++++++++++++++ stc/exact.hh | 8 ++++++-- stc/vtypes.hh | 2 +- tests/exact.cc | 14 ++++++++++++++ tests/find_exact.cc | 5 ++--- tests/vtypes-and-exact.cc | 10 +++++++--- 6 files changed, 44 insertions(+), 9 deletions(-) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add stc_to_exact and stc_to_exact_ macros. * stc/exact.hh (stc_to_exact, stc_to_exact_): New macros. * stc/vtypes.hh (type_of_): Use the stc_to_exact macro instead of stc::to_exact_. * tests/exact.cc (main): Perform additional static tests. * tests/find_exact.cc (main): Use the stc_to_exact_ macro instead of stc::to_exact_. * tests/vtypes-and-exact.cc (main): Likewise Check the super classes. (A): Use stc::any instead of stc::any__simple. Index: stc/exact.hh --- stc/exact.hh (révision 500) +++ stc/exact.hh (copie de travail) @@ -35,14 +35,18 @@ # include <mlc/bexpr.hh> +/// \def Get the exact type of \a T. +#define stc_to_exact(T) \ + typename stc_to_exact_(T) + +#define stc_to_exact_(T) \ + stc::to_exact_< T >::ret # define stc_internal_is_any(T) \ mlc::bexpr_< sizeof(internal::any_select(internal::makePtr< T >())) == \ sizeof(internal::yes_) > - - namespace stc { Index: stc/vtypes.hh --- stc/vtypes.hh (révision 500) +++ stc/vtypes.hh (copie de travail) @@ -528,7 +528,7 @@ struct type_of_ \ { \ /* Get the exact type of \a from_type. */ \ - typedef typename stc::to_exact_<from_type>::ret from_exact_type; \ + typedef stc_to_exact(from_type) from_exact_type; \ \ /* Look for the typedef in internal types. */ \ typedef typename \ Index: tests/exact.cc --- tests/exact.cc (révision 500) +++ tests/exact.cc (copie de travail) @@ -56,6 +56,20 @@ int main() { + // Ensure stc::is_any_ works properly. + mlc::assert_< stc::is_any_< abstraction<concrete> > >::check(); + mlc::assert_< stc::is_any_< sub_abstraction<concrete> > >::check(); + mlc::assert_< stc::is_any_< concrete > >::check(); + + // Check stc_to_exact. + mlc::assert_< + mlc_eq(stc_to_exact_(abstraction<concrete>), concrete) + >::check(); + + mlc::assert_< + mlc_eq(stc_to_exact_(sub_abstraction<concrete>), concrete) + >::check(); + //----------------------------------------- { Index: tests/find_exact.cc --- tests/find_exact.cc (révision 500) +++ tests/find_exact.cc (copie de travail) @@ -65,7 +65,6 @@ mlc::assert_< mlc_is_a_(C, A) >::check(); mlc::assert_< mlc_is_a_(C, B) >::check(); - mlc::assert_< mlc_eq(stc::to_exact_< A< B<> > >::ret, - B<stc::itself>) >::check(); - mlc::assert_< mlc_eq(stc::to_exact_< A<C> >::ret, C) >::check(); + mlc::assert_< mlc_eq( stc_to_exact_(A< B<> >), B<stc::itself> ) >::check(); + mlc::assert_< mlc_eq( stc_to_exact_(A<C>), C ) >::check(); } Index: tests/vtypes-and-exact.cc --- tests/vtypes-and-exact.cc (révision 500) +++ tests/vtypes-and-exact.cc (copie de travail) @@ -113,7 +113,7 @@ }; template <typename Exact> - struct A : public stc::any__simple<Exact> + struct A : public stc::any<Exact> { // Aliases. typedef my_type_of(A, foo) foo_type; @@ -224,9 +224,13 @@ using my::B; using my::C; + // Check super classes. + mlc::assert_<mlc_is_a_(C, A)>::check(); + mlc::assert_<mlc_is_a_(C, B)>::check(); + // Check exact types of A<C> and B<C>. - mlc::assert_<mlc_eq(stc::to_exact_< A<C> >::ret, C)>::check(); - mlc::assert_<mlc_eq(stc::to_exact_< B<C> >::ret, C)>::check(); + mlc::assert_<mlc_eq(stc_to_exact_(A<C>), C)>::check(); + mlc::assert_<mlc_eq(stc_to_exact_(B<C>), C)>::check(); // Check types associated to A<C>.

19 years

500: Document stc_find_exact and stc::itself in Static tour

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/static ChangeLog | 9 ++ tests/tour.cc | 257 +++++++++++++++++++++++++++++++++++++--------------------- 2 files changed, 173 insertions(+), 93 deletions(-) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Document stc_find_exact and stc::itself in Static tour. * tests/tour.cc (dynamic_hierarchy, simple_static_hierarchy): (static_hierarchy_with_methods): Aesthetic changes. (static_hierarchy_with_any): Rephrase comments. (static_hierarchy_with_a_non_leaf_concrete_class): New section. Index: tests/tour.cc --- tests/tour.cc (révision 499) +++ tests/tour.cc (révision 500) @@ -29,6 +29,7 @@ /// \brief A tour of Static and SCOOP features. # include <stc/any.hh> +# include <stc/find_exact.hh> // FIXME: ``Fil rouge'': building a small (but complete) static // hierarchy, using all features from Static. Possibly, this @@ -40,9 +41,7 @@ // having introduced the vtypes. // FIXME: Things to show: -// - any // - exact -// - find_exact // - super // - virtual types (and macros for super) // - multiple super @@ -58,46 +57,36 @@ | A small dynamic hierarchy. | `----------------------------*/ -// Normally, we'd be writing something like this: +/* Our first step in this tour will be the definition of a static + library. In classic (dynamic) OO programming, our example would + look like this: */ namespace dynamic_hierarchy { - // A is abstract. + // `A' is an abstract class. struct A { // A virtual method. - virtual void foo() - { - // ... - } + virtual void foo() { /* ... */ } // A virtual pure method. virtual void bar() = 0; }; - // B is abstract. + // `B' is a concrete class. struct B { // A redefined method. - virtual void foo() - { - // ... - } - // B::bar is defined. - virtual void bar() - { - // ... - } + virtual void foo() { /* ... */ } + // `B::bar' is defined. + virtual void bar() { /* ... */ } }; - // C is concrete + // `C' is a concrete class. struct C { - // A redefined method. - virtual void foo() - { - // ... - } + // `B::foo' is redefined. + virtual void foo() { /* ... */ } }; } // end of namespace dynamic_hierarchy @@ -107,16 +96,16 @@ | A small static hierarchy. | `---------------------------*/ -// Let's start building a small static hierarchy. Converting the first -// dynamic hierarchy results in: - -// FIXME: Comments. +/* Let's start building a small static hierarchy similar to the above + dynamic hierarchy. */ namespace simple_static_hierarchy { /* In traditional OO design, a object has two types : + - a static type, known at compile time; - a dynamic type or exact type, known at run time. + The dynamic type is more precise (or equally precise) than the static type: it's a subclass of the static type. @@ -128,20 +117,22 @@ In the Static C++ Object-Oriented Paradigm (SCOOP), an object still has two types, but they are both static: + - the current type, which can be be an abstraction type; - the exact type. + As everything is static, SCOOP must rely on the static type system of C++, i.e, the current type must hold the information of the exact type. This is achieved through the use of templates: a current type embeds the exact type as a template parameter. Consequently, in SCOOP all derivable classes of a hierarchy are - turned into templates and have an ``Exact'' parameter, which is - the exact static type of the object, à la Curiously Recurring - Template Pattern (CRTP) [1]. + turned into templates and have an `Exact' parameter, which is the + exact static type of the object, à la ``Curiously Recurring + Template Pattern'' (CRTP) [1]. Let's have a look at small example of static inheritance, with - only two classes, A and B. */ + only two classes, `A' and `B'. */ template <typename Exact> struct A @@ -152,64 +143,152 @@ { }; - /* For instance, in the code above, A is turned into a template - class and has an Exact parameter, and B doesn't derive from just - A, but from A<B>. This trick allows us to write: + /* In the above code, `A' is turned into a template class and has an + `Exact' parameter, and `B' doesn't derive from just `A', but from + `A<B>'. This trick allows us to write: A<B>* a = new B; - As you can see, the current type still holds the exact type! In - the next section, we'll see how to actually get back the exact - type. */ + As you can see, the current type still holds the exact type! + Later, we'll see how to actually get back the exact type. */ } // end of namespace simple_static_hierarchy -/*-----------. -| stc::any. | -`-----------*/ + +// ---------- // +// stc::any. // +// ---------- // namespace static_hierarchy_with_any { /* To ease the retrieval of the exact type, we'll make use of - stc::any. This is an instrumentation of the hierarchy to ease + `stc::any'. This is an instrumentation of the hierarchy to ease the retrieval of the exact type and the conversion of the object - to this type. In fact, there is not a single stc::any class, but - several, which have their advantages and drawbacks w.r.t. speed, - memory print and support for diamond inheritance. We'll only deal - with stc::any__simple in this Static tour. - - stc::any is used as the base class of any top class of a static - hierarchy: it is passed the Exact type, just like any non-leaf - class of the hierarchy. */ + to this type. In fact, there is not a single `stc::any' class, + but several, which have their advantages and drawbacks + w.r.t. speed, memory print and support for diamond inheritance. + We'll only deal with `stc::any__simple' in this Static tour: + where you'll see `stc::any', simply read `stc::any__simple'. + + `stc::any' is used as the base class of any top class of a static + hierarchy. It is passed the `Exact' type, just like any non-leaf + class of the hierarchy (a leaf class is a class which is not + derived, i.e., at the bottom of an inheritance tree). */ template <typename Exact> struct A : public stc::any__simple<Exact> { }; - /* Now, let's turn be into a derivable class: we only have to make - it a template class, with an Exact parameter, and let it pass - this exact type to A. */ + /* Now, let's turn `B' be into a derivable class: we only have to + make it a template class, with an `Exact' parameter, and let it + pass this exact type to `A'. */ template <typename Exact> struct B : public A<Exact> { }; - /* We now introduce a concrete leaf class, C, which derives from B, - and passes its own type as exact type. */ + /* We now introduce a concrete leaf class, `C', which derives from + `B', and passes its own type as exact type. */ struct C : public B<C> { }; -} // end of namespace static_hierarchy +} // end of namespace static_hierarchy_with_any -// FIXME: stc/exact.hh. -// FIXME: stc/find_exact.hh and the non-leaf concrete classes. -// -// « Implicitly, our non-leaf classes are abstract. (...) » +// ------------ // +// stc::exact. // +// ------------ // + +// FIXME: To do. + + +// --------------------------- // +// Non-leaf concrete classes. // +// --------------------------- // + +/* All classes carrying an exact type are implicitly abstract classes. + Thus, with our current modeling, non-leaf classes are + compulsorily abstract. This is in compliance with good OO design + practices: in an class hierarchy, non-leaf classes should be + abstract. But what if we wanted (for a reason or another) B to be + a concrete (i.e., instantiable) class? The form `B<>' is not + allowed: a value must be provided for the `Exact' parameter. This is + the role of the stc::itself tag. + + By convention, a class whose exact type is `B<stc::itself>' is + considered concrete. To shorten the coding style, non-leaf + concrete classes take `stc::itself' as default value for their + `Exact' parameter (see below). This way, `B<>' becomes a correct + type. + + The only remaining difficulty is to pass the base class the right + exact type. A small metacode is required here, hidden behind the + `stc_find_exact' helper macro. The code below explains the + necessary changes. */ + +namespace static_hierarchy_with_a_non_leaf_concrete_class +{ + + /* A is left unchanged (it is still an abstract class). */ + + template <typename Exact> + struct A : public stc::any__simple<Exact> + { + }; + + /* B is turned into a concrete class. To achieve this, we apply two + changes: + + 1. the parameter passed to A (B's base class) is no longer + `Exact', but `stc_find_exact(B, Exact)'. The `stc_find_exact' + macro evaluates to `B<>' (i.e., `B<stc::itself>') or to + `Exact', depending on whether `Exact' is equal to + `stc::itself' or not; + + 2. `Exact' takes a default value, `stc::itself', so that one can + abbreviate `B<stc::itself>' to `B<>' (this change is a pure + matter of style and is optional). */ + + template <typename Exact = stc::itself> + struct B : public A< stc_find_exact(B, Exact) > + { + }; + + /* C is left unchanged. */ + + struct C : public B<C> + { + }; + + /* If we loot at the classes above C and B<> in the inheritance + tree, we have: + + A<C> A< B<> > + ^ ^ + | | + B<C> B<> + ^ + | + C + + The exact type is correctly passed to super classes. */ + +} // end of namespace static_hierarchy_with_a_non_leaf_concrete_class + +/* To put it in a nutshell: + + - non-leaf classes are abstract by default in SCOOP; + - to turn a non-leaf class `Foo' into a concrete class, you have to + - pass it `stc_find_exact(Foo, Exact)' instead of `Exact' as + exact type parameter to its super class; + - optionally (but recommended), give its `Exact' parameter a + default value, `stc::itself'; + - to use such a class as a concrete one, simply use it with an empty + `Exact' parameter: `Foo<>'. */ // --------- // @@ -226,48 +305,31 @@ template <typename Exact> struct A : public stc::any__simple<Exact> { - // A static ``virtual'' method. Notice there is no virtual - // keyword: the (static) dispatch is done manually through the - // delegation to impl_foo. - void foo() - { - this->exact().impl_foo(); - } - void impl_foo() - { - // Empty. - } - - // A virtual pure method. - virtual void bar() - { - this->exact().impl_bar(); - } - // No impl_bar, since bar is virtual pure; + /* Facade of a statically-dispatched method. Notice there is no + `virtual' keyword: the (static) dispatch is done manually + through the delegation to impl_foo. */ + void foo() { this->exact().impl_foo(); } + // Implementation of the method. + void impl_foo() { /* ... */ } + + // A ``virtual'' pure (i.e., abstract) method. + void bar() { this->exact().impl_bar(); } + // (No `impl_bar', since bar is abstract.) }; template <typename Exact> - struct B : public A<Exact> - { - // Redefinition. - void impl_foo() - { - // Empty. - } - // Definition. - void impl_bar() + struct B : public A< stc_find_exact(B, Exact) > { - // Implementation goes here. - } + // A redefined method. + void impl_foo() { /* ... */ } + // B::bar (implementation) is defined. + void impl_bar() { /* ... */ } }; struct C : public B<C> { // Redefinition. - void impl_foo() - { - // Empty. - } + void impl_foo() { /* ... */ } }; } // end of namespace static_hierarchy_with_methods @@ -281,3 +343,12 @@ [1] Coplien, James O. (1995, February). "Curiously Recurring Template Patterns". C++ Report: 24-27. */ + + + +/// Local Variables: +/// ispell-local-dictionary: "american" +/// End: + +// LocalWords: inline stc namespace vtypes OO struct CRTP typename metacode +// LocalWords: instantiable impl ispell american

19 years

499: Start a Static tour

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/static ChangeLog | 4 tests/Makefile.am | 6 - tests/tour.cc | 283 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 292 insertions(+), 1 deletion(-) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> * tests/tour.cc: Start a Static tour. 2006-06-12 Roland Levillain <roland(a)lrde.epita.fr> Index: tests/Makefile.am --- tests/Makefile.am (révision 498) +++ tests/Makefile.am (copie de travail) @@ -16,7 +16,9 @@ super \ vtypes \ vtypes-and-exact \ - vtypes-multiple-supers + vtypes-multiple-supers \ + \ + tour any_SOURCES = any.cc entry_SOURCES = entry.cc @@ -28,4 +30,6 @@ vtypes_and_exact_SOURCES = vtypes-and-exact.cc vtypes_multiple_supers_SOURCES = vtypes-multiple-supers.cc +tour_SOURCES = tour.cc + TESTS = $(check_PROGRAMS) Index: tests/tour.cc --- tests/tour.cc (révision 0) +++ tests/tour.cc (révision 499) @@ -0,0 +1,283 @@ +// Copyright (C) 2006 EPITA Research and Development Laboratory. +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +/// \file tests/tour.cc +/// \brief A tour of Static and SCOOP features. + +# include <stc/any.hh> + +// FIXME: ``Fil rouge'': building a small (but complete) static +// hierarchy, using all features from Static. Possibly, this +// construction could be progressive, i.e., made of several attempts, +// each enclosed in its own namespace. +// +// Be as simple as possible, and introduce features one by one. For +// instance, don't introduce the multiple inheritance system after +// having introduced the vtypes. + +// FIXME: Things to show: +// - any +// - exact +// - find_exact +// - super +// - virtual types (and macros for super) +// - multiple super +// - entry + + +// Welcome to this tour of the Static library! + +// FIXME: Intro. + + +/*----------------------------. +| A small dynamic hierarchy. | +`----------------------------*/ + +// Normally, we'd be writing something like this: + +namespace dynamic_hierarchy +{ + + // A is abstract. + struct A + { + // A virtual method. + virtual void foo() + { + // ... + } + // A virtual pure method. + virtual void bar() = 0; + }; + + // B is abstract. + struct B + { + // A redefined method. + virtual void foo() + { + // ... + } + // B::bar is defined. + virtual void bar() + { + // ... + } + }; + + // C is concrete + struct C + { + // A redefined method. + virtual void foo() + { + // ... + } + }; + +} // end of namespace dynamic_hierarchy + + +/*---------------------------. +| A small static hierarchy. | +`---------------------------*/ + +// Let's start building a small static hierarchy. Converting the first +// dynamic hierarchy results in: + +// FIXME: Comments. + +namespace simple_static_hierarchy +{ + /* In traditional OO design, a object has two types : + - a static type, known at compile time; + - a dynamic type or exact type, known at run time. + The dynamic type is more precise (or equally precise) than the + static type: it's a subclass of the static type. + + The inclusion polymorphism allows the programmer to manipulate an + object while knowing only it's compile time type: the type of the + object only needs to satisfy an interface (through inheritance) + required by the algorithm. + + + In the Static C++ Object-Oriented Paradigm (SCOOP), an object + still has two types, but they are both static: + - the current type, which can be be an abstraction type; + - the exact type. + As everything is static, SCOOP must rely on the static type + system of C++, i.e, the current type must hold the information of + the exact type. This is achieved through the use of templates: a + current type embeds the exact type as a template parameter. + + Consequently, in SCOOP all derivable classes of a hierarchy are + turned into templates and have an ``Exact'' parameter, which is + the exact static type of the object, à la Curiously Recurring + Template Pattern (CRTP) [1]. + + Let's have a look at small example of static inheritance, with + only two classes, A and B. */ + + template <typename Exact> + struct A + { + }; + + struct B : public A<B> + { + }; + + /* For instance, in the code above, A is turned into a template + class and has an Exact parameter, and B doesn't derive from just + A, but from A<B>. This trick allows us to write: + + A<B>* a = new B; + + As you can see, the current type still holds the exact type! In + the next section, we'll see how to actually get back the exact + type. */ + +} // end of namespace simple_static_hierarchy + +/*-----------. +| stc::any. | +`-----------*/ + +namespace static_hierarchy_with_any +{ + /* To ease the retrieval of the exact type, we'll make use of + stc::any. This is an instrumentation of the hierarchy to ease + the retrieval of the exact type and the conversion of the object + to this type. In fact, there is not a single stc::any class, but + several, which have their advantages and drawbacks w.r.t. speed, + memory print and support for diamond inheritance. We'll only deal + with stc::any__simple in this Static tour. + + stc::any is used as the base class of any top class of a static + hierarchy: it is passed the Exact type, just like any non-leaf + class of the hierarchy. */ + + template <typename Exact> + struct A : public stc::any__simple<Exact> + { + }; + + /* Now, let's turn be into a derivable class: we only have to make + it a template class, with an Exact parameter, and let it pass + this exact type to A. */ + + template <typename Exact> + struct B : public A<Exact> + { + }; + + /* We now introduce a concrete leaf class, C, which derives from B, + and passes its own type as exact type. */ + + struct C : public B<C> + { + }; + +} // end of namespace static_hierarchy + +// FIXME: stc/exact.hh. + +// FIXME: stc/find_exact.hh and the non-leaf concrete classes. +// +// « Implicitly, our non-leaf classes are abstract. (...) » + + +// --------- // +// Methods. // +// --------- // + +// Add the methods. + +// FIXME: Comments. + +namespace static_hierarchy_with_methods +{ + + template <typename Exact> + struct A : public stc::any__simple<Exact> + { + // A static ``virtual'' method. Notice there is no virtual + // keyword: the (static) dispatch is done manually through the + // delegation to impl_foo. + void foo() + { + this->exact().impl_foo(); + } + void impl_foo() + { + // Empty. + } + + // A virtual pure method. + virtual void bar() + { + this->exact().impl_bar(); + } + // No impl_bar, since bar is virtual pure; + }; + + template <typename Exact> + struct B : public A<Exact> + { + // Redefinition. + void impl_foo() + { + // Empty. + } + // Definition. + void impl_bar() + { + // Implementation goes here. + } + }; + + struct C : public B<C> + { + // Redefinition. + void impl_foo() + { + // Empty. + } + }; + +} // end of namespace static_hierarchy_with_methods + + +// FIXME: Introduce static checks of methods (kind of concept checking). + +int main() {} + +/* References: + + [1] Coplien, James O. (1995, February). "Curiously Recurring + Template Patterns". C++ Report: 24-27. */

19 years

498: Add stc_find_exact

by Roland Levillain

https://svn.lrde.epita.fr/svn/oln/trunk/static ChangeLog | 10 +++++++ stc/Makefile.am | 1 stc/find_exact.hh | 59 +++++++++++++++++++++++++++++++++++++++++++ tests/Makefile.am | 2 + tests/find_exact.cc | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 143 insertions(+) Index: ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Add stc_find_exact. * stc/find_exact.hh: New. * tests/find_exact.cc (main): New test. * stc/Makefile.am (nobase_stc_HEADERS): Add find_exact.hh. * tests/Makefile.am (check_PROGRAMS): Add find_exact. (find_exact_SOURCES): New. Index: tests/find_exact.cc --- tests/find_exact.cc (révision 0) +++ tests/find_exact.cc (révision 0) @@ -0,0 +1,71 @@ +// Copyright (C) 2006 EPITA Research and Development Laboratory +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +# include <mlc/assert.hh> +# include <mlc/is_a.hh> + +# include <stc/any.hh> +# include <stc/find_exact.hh> +# include <stc/exact.hh> + +namespace my +{ + + /// An abstract class. + template <typename Exact> + struct A : stc::any__simple<Exact> + { + }; + + /// An abstract class, possibly concrete. + template <typename Exact = stc::itself> + struct B : public A< stc_find_exact(B, Exact) > + { + }; + + /// A concrete class. + struct C : public B<C> + { + }; + +} // end of namespace my + +int +main() +{ + using my::A; + using my::B; + using my::C; + + mlc::assert_< mlc_is_a_(B<>, A) >::check(); + mlc::assert_< mlc_is_a_(C, A) >::check(); + mlc::assert_< mlc_is_a_(C, B) >::check(); + + mlc::assert_< mlc_eq(stc::to_exact_< A< B<> > >::ret, + B<stc::itself>) >::check(); + mlc::assert_< mlc_eq(stc::to_exact_< A<C> >::ret, C) >::check(); +} Index: tests/Makefile.am --- tests/Makefile.am (révision 497) +++ tests/Makefile.am (copie de travail) @@ -11,6 +11,7 @@ any \ entry \ exact \ + find_exact \ multiple-supers \ super \ vtypes \ @@ -20,6 +21,7 @@ any_SOURCES = any.cc entry_SOURCES = entry.cc exact_SOURCES = exact.cc +find_exact_SOURCES = find_exact.cc multiple_supers_SOURCES = multiple-supers.cc super_SOURCES = super.cc vtypes_SOURCES = vtypes.cc Index: stc/find_exact.hh --- stc/find_exact.hh (révision 0) +++ stc/find_exact.hh (révision 0) @@ -0,0 +1,59 @@ +// Copyright (C) 2006 EPITA Research and Development Laboratory. +// +// This file is part of the Olena Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License version 2 as published by the +// Free Software Foundation. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this library; see the file COPYING. If not, write to +// the Free Software Foundation, 51 Franklin Street, Fifth Floor, +// Boston, MA 02111-1307, USA. +// +// As a special exception, you may use this file as part of a free +// software library without restriction. Specifically, if other files +// instantiate templates or use macros or inline functions from this +// file, or you compile this file and link it with other files to +// produce an executable, this file does not by itself cause the +// resulting executable to be covered by the GNU General Public +// License. This exception does not however invalidate any other +// reasons why the executable file might be covered by the GNU General +// Public License. + +#ifndef STATIC_FIND_EXACT_HH +# define STATIC_FIND_EXACT_HH + +# define stc_find_exact(Abstraction, ExactType) \ + typename stc::find_exact< Abstraction, ExactType >::ret + +namespace stc +{ + + /// Special tag to be passed as exact type to make a static abstract + /// class ``concrete''. + struct itself; + + /// Find the exact type for \a Abstraction whose ``Exact'' template + /// parameter is \a exact_type + template <template <class> class abstraction, typename exact_type> + struct find_exact + { + typedef exact_type ret; + }; + + /// Specialization for stc::itself. + template <template <class> class abstraction> + struct find_exact<abstraction, stc::itself> + { + typedef abstraction<stc::itself> ret; + }; + +} // end of namespace stc + + +#endif // ! STATIC_FIND_EXACT_HH Index: stc/Makefile.am --- stc/Makefile.am (révision 497) +++ stc/Makefile.am (copie de travail) @@ -5,6 +5,7 @@ any.hh \ entry.hh \ exact.hh \ + find_exact.hh \ valist_aggregator.hh \ vtypes.hh \ \

19 years

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches