References of Control_Flow_Normalization

@Article{	  ammarguellat:control-flow,
  title		= {A Control-flow normalization algorithm and its
		  complexity},
  author	= {Z. Ammarguellat},
  journal	= {{IEEE} Transactions on Software Engineering},
  volume	= {18},
  number	= {3},
  pages		= {237--251},
  year		= {1992},
  note		= { A simple method is presented for normalizing the
		  control-flow of programs to facilitate program
		  transformations, program analysis, and automatic
		  parallelization. This method does not make use of code
		  replication. The normalization results in a restructuring
		  of the code that obviates the need for control dependency
		  relations},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@InProceedings{	  ashcroft.manna:translation,
  title		= {The translation of GOTO programs into WHILE programs},
  author	= {E. Ashcroft and Z. Manna},
  booktitle	= {Proceedings of {IFIP} Congress 71},
  editor	= {C.V. Freiman and J.E. Griffith and J.L. Rosenfeld},
  volume	= {1},
  pages		= {250--255},
  publisher	= {North-Holland},
  year		= {1972},
  note		= { It is shown that every flowchart program can be written
		  without go to statements by using while statements. The
		  transformation does not give rise to less efficient
		  programs and, moreover, the structure of the original
		  flowchart program is preserved},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@Article{	  boehm.jacopini:flow,
  author	= {C. Boehm and G. Jacopini},
  title		= {Flow Diagrams, Turing Machines and Languages with only Two
		  Formation Rules},
  journal	= {Communications of the ACM},
  year		= {1966},
  pages		= {366-371},
  month		= may,
  abstract	= {This paper contains a proof that every program with gotos
		  can be transformed into a semantically equivalent program
		  without goto. A transformation algorithm is given. },
  contents	= {Wolfgang Gellerich: Die Autoren beweisen(!), dass man ohne
		  GOTO auskommt und geben, wenn ich mich richtig erinnere,
		  auch einen allgemeinen Umstrukturierungsalgorithmus an, der
		  aber fuer die Praxis nicht taugt.},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@InProceedings{	  bush:automatic,
  author	= {Eric Bush},
  title		= {The Automatic Restructuring of COBOL},
  booktitle	= {CSM'85: Proceedings of the 1985 Conference on Software
		  Maintenance, {\rm (Washington, DC; November 11-13, 1985)}},
  year		= {November 1985},
  pages		= {35-41},
  abstract	= {Reduction of flow graphs in COBOL programs into so-called
		  normal form. PITS},
  class		= {Alteration, Re-Code, Control_Flow_Normalization }
}

@Article{	  miller.straus:implications,
  title		= {Implications of automatic restructuring COBOL},
  author	= {J. Miller and B. Straus III},
  journal	= {{ACM} Sigplan Notices},
  volume	= {22},
  number	= {6},
  pages		= {76--82},
  year		= {1987},
  note		= { The question whether or not mechanical transformations of
		  unstructured program code to a structured equivalent can
		  provide an improvement in the understanding of that program
		  is addressed. As an example the language COBOL is examined.
		  The paper also discusses a tool (called Structured
		  Retrofit) that performs such transformations for COBOL
		  mechanically},
  class		= {Alteration, Re-Code, Control_Flow_Normalization,
		  Program_Transformations }
}

@Article{	  oulsnam:unraveling,
  title		= {Unraveling unstructured programs},
  author	= {G. Oulsnam},
  journal	= {The Computer Journal},
  volume	= {25},
  number	= {3},
  pages		= {379--387},
  year		= {1982},
  note		= { A method for transforming unstructured program flowcharts
		  into structured ones is presented. The form of the derived
		  structured programs is such that the original unstructured
		  programs can be easily recovered, thus revealing what
		  overheads in space and time are inherent in the structured
		  forms},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@InProceedings{	  pleszkoch.linger.ea:eliminating,
  title		= {Eliminating non-traversable paths from structured
		  programs},
  author	= {M. Pleszkoch and R. Linger and A. Hevner},
  pages		= {156--164},
  booktitle	= {\cite{SM92}},
  year		= {1992},
  note		= { Considers the problem of control variables (i.e., ranging
		  over the Booleans or some small enumeration type) that
		  obscure the structure of otherwise structured programs.
		  Control flow is represented by regular expressions which
		  are further processed (subset construction) to find a
		  version of the program without redundant control paths},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@Article{	  ramshaw:eliminating,
  title		= {Eliminating goto's while preserving program structure},
  author	= {L. Ramshaw},
  journal	= {Journal of the {ACM}},
  volume	= {35},
  number	= {4},
  pages		= {893-920},
  year		= {1988},
  note		= { A method is described to eliminate GO-TO statements from
		  a program while the program's original structure is being
		  preserved},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@Article{	  urschler:automatic,
  title		= {The automatic restructuring of programs},
  author	= {G. Urschler},
  journal	= {{IBM} Journal of Research and Development},
  volume	= {19},
  pages		= {181--194},
  year		= {1975},
  note		= { A method is described that allows the translation of an
		  unstructured program into a set of top-down structured,
		  semantically founded, go-to-free modules. This method leads
		  to a certain amount of code replication},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@Article{	  williams.ossher:conversion,
  title		= {Conversion of unstructured flow diagrams into structured
		  form},
  author	= {M. Williams and H. Ossher},
  journal	= {The Computer Journal},
  volume	= {21},
  number	= {2},
  pages		= {161--167},
  year		= {1978},
  note		= { Various already proposed methods to convert unstructured
		  flow diagrams into equivalent structured ones are
		  discussed. Moreover a general method for performing such
		  conversions is discussed},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}

@Book{		  zima.chapman:supercompilers,
  author	= {H. Zima and B. Chapman},
  title		= {Supercompilers for Parallel and vector Computers},
  publisher	= {Addison-Wesley},
  year		= {1991},
  series	= {ACM Frontier Series},
  abstract	= {This book contains (beside other topics) a description how
		  to discover loops in programs with gotos and how to
		  tranform those structures into while or repeat loops.},
  contents	= {Wolfgang Gellerich: Gute Darstellung wie man in
		  GOTO-Programmen Schleifen findet und sie gegen WHILE- oder
		  REPEAT-Schleifen ersetzt.},
  class		= {Alteration, Re-Code, Control_Flow_Normalization}
}