ID: 6164

Название работы: Редактор логических схем алгоритмовАвтоматизация проектирования компьютерных систем

Категория: Лабораторная работа

Предметная область: Информатика, кибернетика и программирование

Описание: Автоматизация проектирования компьютерных систем Краткое описание программы Интерфейс пользователя: Пользователь может выполнить одно из следующих действий: Открыть существующий файл для просмотра и дальнейшего редактирования алгоритма. ...

Язык: Русский

Дата добавления: 2012-12-30

Размер файла: 125.74 KB

Работу скачали: 16 чел.

Автоматизация проектирования компьютерных систем

Краткое описание программы

Интерфейс пользователя:

1.  Пользователь может выполнить одно из следующих действий:
2.  Открыть существующий файл для просмотра и дальнейшего редактирования алгоритма.
3.  Создать новый файл.
4.  Сохранить измененный алгоритм в указанный  файл.
5.  Редактировать алгоритм.
6.  Редактировать файл в который в дальнейшем будет сохранен файл.

Скриншот программы:

Формат записи алгоритма

ЛСА (логическая схема алгоритма) - это компактная запись алгоритма, хотя и с потерей наглядности, представляет собой конечную строку символов. Строка начинается символом B (начало) и заканчивается символом Е (конец).

Внутри строки записывают буквы входного и выходного алфавитов (Хi и Yi), между которыми могут располагаться стрелки с индексами ( >i и <i ). Стрелки с одинаковыми индексами создают неразрывную пару, соответствующую условному (если стрелка расположена после Хi) или безусловному переходу (если стрелка расположена после Yi).

Формат вершин алгоритма: “X1”, “Y1”,”Y5,Y6,Y7”, “B”,”E”.

Основные методы класса AlgProcessor.

public String parse( String str) – преобразует исходную строку в массив лексем.

Возвращает строку «suceeded» если входные данные корректны или сообщение об ошибки.

public void saveAlgorithm(String fileName) – преобразует массив лексем в объект алгоритма ( матрица переходов, матрица соотношения сигналов и список управляющих сигналов. А также пробует записать алгоритм в файл.

public void loadAlgorithm(String fileName)  - пытается считать готовый алгоритм из файла.

public String createLSA() – преобразовывает алгоритм в строку для вывода.

Листинг программы:

import javax.swing.*;

public class Program{

 

 public static void main(String[] args) {

 MainFrame frame = new MainFrame();

 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

 frame.setVisible(true);

}

}

import java.awt.Dimension;

import java.awt.Image;

import java.awt.Toolkit;

import java.awt.event.*;

import javax.swing.*;

public class MainFrame extends JFrame {

private static final long serialVersionUID = 1L;

 

private JPanel colPanel;

 

public MainFrame() {

 Toolkit kit = Toolkit.getDefaultToolkit();

 Dimension screenSize = kit.getScreenSize();

 colPanel = new LSAPanel();

 add(colPanel);

 

 setTitle("Proga Chuba");

 setBounds(300, 200, screenSize.width/3, screenSize.height/6);

 Image im = kit.getImage("dinamo.gif");

 setIconImage(im);

 

 JMenuBar menuBar = new JMenuBar();

 setJMenuBar(menuBar);

 JMenu fileMenu = new JMenu("File");

 JMenuItem newItem = fileMenu.add(new AbstractAction("New"){

  public void actionPerformed(ActionEvent event){

   ((LSAPanel) colPanel).newA();

  }

 });

 fileMenu.addSeparator();

 JMenuItem saveItem = fileMenu.add(new AbstractAction("Save"){

  public void actionPerformed(ActionEvent event){

   ((LSAPanel) colPanel).save();

  }

 });

 JMenuItem loadItem = fileMenu.add(new AbstractAction("Load"){

  public void actionPerformed(ActionEvent event){

   ((LSAPanel) colPanel).load();

  }

 });

 fileMenu.addSeparator();

 JMenuItem exitItem = fileMenu.add(new AbstractAction ("Exit"){

  public void actionPerformed(ActionEvent event){

   System.exit(0);

  }

 });

 JMenu helpMenu = new JMenu("Help");

 //JMenuItem aboutItem = helpMenu.add("About...");

 JMenuItem aboutItem = helpMenu.add(new AbstractAction("About..."){

  public void actionPerformed(ActionEvent event){

   about();

  }

 });

 menuBar.add(fileMenu);

 menuBar.add(helpMenu);

 setResizable(false);

 

}

public void about(){

       JOptionPane.showMessageDialog(this,

               "Computer-aided Designing of Computer Systems\nCopyright (c) 2011 Alexander Chub",

               "About", JOptionPane.INFORMATION_MESSAGE);

}

}

import java.awt.Color;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JTextField;

public class LSAPanel extends JPanel{

 

 private static final long serialVersionUID = 1L;

 

JTextField  inputField;

JTextField folderField;

JLabel messageBox, messageBoxInp, messageBoxFol, messageBoxNul;

 public LSAPanel(){

 

 JButton checkButton = new JButton("Check");

 

 setBackground(Color.LIGHT_GRAY);

 inputField = new JTextField();

 folderField = new JTextField();

 messageBoxInp = new JLabel("            Input field:");

 messageBoxFol = new JLabel("            Name of file:");

 messageBox = new JLabel("");

 this.setLayout((new GridLayout(3,2)));

 this.add(messageBoxInp);

 this.add(inputField);

 this.add(messageBoxFol);

 this.add(folderField);

 this.add(messageBox);

 add(checkButton);

 checkButton.addActionListener(new ActionListener(){

  public void actionPerformed(ActionEvent event) {

   check();

  }

 });

}

 public void newA(){

 inputField.setText("");

 folderField.setText("");

}

 

 private void check(){

 AlgProcessor proc = new AlgProcessor();

 String inputLine = inputField.getText();

 messageBox.setText(proc.parse(inputLine));

 proc.createAlgorithm();

 messageBox.setText(proc.checkValid());

}

 

 public void save(){

 AlgProcessor proc = new AlgProcessor();

 String fileName = folderField.getText();

 String inputLine = inputField.getText();

 messageBox.setText(proc.parse(inputLine));

 proc.createAlgorithm();

 proc.saveAlgorithm(fileName);

 

}

 

 public void load(){

 AlgProcessor proc = new AlgProcessor();

 String fileName = folderField.getText();

 proc.loadAlgorithm(fileName);

 if(fileName.equals(""))

  messageBox.setText("            File not found");

 String str = proc.createLSA();

 inputField.setText(str);

 }

}

import java.io.Serializable;

import java.util.ArrayList;

public class Algorithm implements Serializable{

 

 private static final long serialVersionUID = 1L;

 

 private int[][] mConnections;

 private int[][] mSignals;

 private ArrayList<String> signals;

 

 

 public Algorithm(){

}

 

 public Algorithm(int[][] mC, int[][] mS, ArrayList<String> signs){

 System.out.println("Connection matrix:  ");

 

 mConnections =mC;

 mSignals = mS;

 signals = signs;

}

 

 

 public void AlgOutput(){

 System.out.println("Connection matrix:  "+ mConnections.length);

 int nNodes = mConnections.length;

 for(int i = 0; i < nNodes; i++){

  

  for(int j = 0; j < nNodes; j++){

   System.out.print(mConnections[i][j]+"  ");

  }

  System.out.println();

 }

 System.out.println("Signals matrix:  "+ mSignals[0].length);

 for(String s:signals)

  System.out.print(s+" ");

 int nExNodes = mSignals.length;

 int nSignals =mSignals[0].length;

 System.out.println();

 for(int i = 0; i < nExNodes; i++){

  for(int j = 0; j < nSignals; j++){

   System.out.print(mSignals[i][j]+"  ");

  }

  System.out.println();

 }

 

}

 

 @Override

 public String toString(){

 ArrayList<String> lexems = new ArrayList<String>();

 int nExNodes = mSignals.length;

 int nSignals =mSignals[0].length;

 lexems.add("B/");

 

 for(int i = 0; i < nExNodes; i++){

  String s = "";

  for(int j = 0; j < nSignals; j++){

   if(mSignals[i][j] ==1){

    s+=","+signals.get(j);

   }

  }

  

  s=s.substring(1,s.length())+"/";

  lexems.add(s);

 }

 lexems.add("E");

 

 

 int nNodes = mConnections.length;

 int pointer = 1;

 for(int out = 0; out < nNodes; out++){

  

  for(int in = 0; in < nNodes; in++){

   if((mConnections[out][in]==1)&&(out!=in)){

    String s = lexems.get(out);

    s = s+">"+pointer+"/" +

      "";

    lexems.set(out, s);

    s = lexems.get(in+1);

    s = "<" + pointer+"/"+s;

    lexems.set(in+1, s);

    pointer++;

   }

   //System.out.print(mConnections[i][j]+"  ");

  }

  System.out.println();

 }

 

 

 String returnLine = "";

 for(String s:lexems){

  returnLine+=s;

 }

 return returnLine;

}

 

 private boolean isY(int[] mas){

 int sum = 0;

 for(int i = 0; i<mas.length;i++) {

  sum+= mas[i];

 }

 if(sum>1) return false;

 else return true;

 

}

 

 public String findInfiniteLoop(){

 String messageLine="algorithm is correct";

 int nNodes = mConnections.length;

 

 //int pointer = 1;

 for(int out = 0; out < nNodes; out++){

  if(!isY(mConnections[out])) continue;

  for(int in = 0; in < nNodes; in++){

   int current = mConnections[out][in];

   if((current==1)&&(out>in)){

    messageLine = " infinite loop at  "+out;

    return messageLine;

   }

  }

 }  

 return messageLine;

}

 

}

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.util.ArrayList;

import java.util.regex.Pattern;

public class AlgProcessor {

 private ArrayList<String> parsedAlg;

 private TableCreator creator;

 private Algorithm alg;

 

 

 public AlgProcessor() {

 creator =new TableCreator();

}

 

 

 // parsing string variable to algorithm lexems

 public String parse( String str){

 

 Pattern pat = Pattern.compile("/");

 String[] lexems = pat.split(str);

 

 parsedAlg = new ArrayList<String>();

 for(int i = 0;i<lexems.length;i++) {

  parsedAlg.add(lexems[i]);

  System.out.println(lexems[i]);

 }

 

 return checkLexValid();

}

 

 //creating algorithm

 public void createAlgorithm(){

 

 int[][] mConnections;

 int[][] mSignals;

 ArrayList<String> signals;

 creator.connect(parsedAlg);  

 mConnections = creator.connectNodes(parsedAlg);

 mSignals = creator.connectSignals();

 signals = creator.fromXYSetsToArray();

 

 alg = new Algorithm(mConnections, mSignals, signals);

 alg.AlgOutput();

 //from parsedAlg to two matrix incapsulated into an object of class Algorithm

 

 }

 

 public void saveAlgorithm(String fileName){

 FileOutputStream fos;

 ObjectOutputStream oos;

 try {

  fos = new FileOutputStream(fileName);

  oos = new ObjectOutputStream(fos);

  oos.writeObject(alg);

  oos.flush();

  oos.close();

 } catch (IOException e) {

  e.printStackTrace();

 }

 

}

 

 public void loadAlgorithm(String fileName) {

 FileInputStream fis;

 ObjectInputStream ois;

 //Algorithm alg1;

 try {

  fis = new FileInputStream(fileName);

  ois = new ObjectInputStream(fis);

   alg =(Algorithm)ois.readObject();

 } catch (IOException e) {

  e.printStackTrace();

 } catch (ClassNotFoundException e) {

  e.printStackTrace();

 }

 

 //alg1.AlgOutput();

}

 

 public String createLSA(){

 return alg.toString();

}

 

 

 public String checkValid(){

 return alg.findInfiniteLoop();

}

 

 

 private String checkLexValid(){

 String str = "succeded";

 if(!parsedAlg.get(0).equals("B")){

  str = "Algorithm must beginned with B";

  return str;

 }

 if(!parsedAlg.get(parsedAlg.size()-1).equals("E")){

  str = "Algorithm must ended  with E";

  return str;

 }

 

 for(int i = 1; i<parsedAlg.size()-1;i++){

  String s = parsedAlg.get(i);

  if(s.length()<2){

   str = s +"  Not valid lexeme at "+ i;

   return str;

  }

 }

 return str;

}

}

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

import java.util.regex.Pattern;

import nodes.*;

public class TableCreator {

 

 private ArrayList<Node> nodes;

 private int counter;

 private Set<String> xSignals;

 private Set<String> ySignals;

//-----------------------------------------------------------------------------

 

 private boolean isExec(String a){

 if((a.charAt(0)!='>')&&(a.charAt(0)!='<'))

  return true;

 else return false;

}

 

 

 boolean isArrUp(String a){

 if(a.charAt(0)=='>')

  return true;

 else return false;

 }

 

 boolean isArrDown(String a){if(a.charAt(0)=='<')

 return true;

 else return false;

 }

 

 

 private int getType(String a){

 if((a.charAt(0)=='B')) return 0;

 if((a.charAt(0)=='X')) return 1;

 if((a.charAt(0)=='Y')||(a.charAt(0)=='(')) return 2;

 if((a.charAt(0)=='E')) return 3;

 else return 100;

}

//----------------------------------------

 private ArrayList<String> parseSignals(String s){

 //TODO

 Pattern pat = Pattern.compile(",");

 String[] tokens = pat.split(s);

 ArrayList<String> listY = new ArrayList<String>();

 for(int i = 0;i<tokens.length;i++) listY.add(tokens[i]);

 return listY;

}

 

//---------------------------------------------

 

 public ArrayList<Node> connect(ArrayList<String> parsedAlg){

 nodes = new ArrayList<Node>();

 xSignals = new HashSet<String>();

 ySignals = new HashSet<String>();

 int type;

 //Node node;

 

 

 int  j = 0;

 for(String lexeme:parsedAlg){

  

  if(isExec(lexeme)){

   type = getType(lexeme);

   switch(type){

    case 0: {

     BeginNode bNode =new BeginNode(counter);

     nodes.add(bNode);

     bNode.setZCode(j);

  

     break;

    }

    case 1: {

     XNode xNode = new XNode(counter, lexeme);

     xSignals.add(lexeme);

     xNode.setZCode(j);

     nodes.add(xNode);

     break;

    }

    case 2:{

     YNode yNode = new YNode(counter);

     ArrayList<String> outSignals = parseSignals(lexeme);

     yNode.setConds(outSignals);

     ySignals.addAll(outSignals);

     yNode.setZCode(j);

     nodes.add(yNode);

     

     break;

    }

    case 3:{

     EndNode eNode = new EndNode(counter);

     nodes.add(eNode);

     eNode.setZCode(j);

     

    }

   }

   counter++;

  }

  j++;

 }

 return nodes;

}

 

 public void testConnect(ArrayList<String> parsedAlg){

 connectNodes(parsedAlg);

}

 

 public void testSignals(){

 int[][] mSignals = connectSignals();

 int n = mSignals.length;

 int m = mSignals[0].length;

 System.out.println("n= "+n+"   m= "+m);

 for(int i = 0; i<n;i++){

  for(int j = 0; j<m;j++){

   System.out.print(mSignals[i][j]+" ");

  }

  System.out.println();

 }

}

 

 private int getIdFromZCode(int zCode){

 for(Node node:nodes){

  if(node.getZCode()==zCode){

   return node.getId();

  }

 }

 return -1;

}

 

 public int[][] connectSignals(){

 ArrayList<String> signals = this.fromXYSetsToArray();

 int nHigh = nodes.size()-2;

 int nWidth = signals.size();

 int[][] mSignals = new int[nodes.size()-2][signals.size()];

 for(int i = 0; i<nHigh;i++){

  if(nodes.get(i+1) instanceof XNode){

   XNode xNode =(XNode)nodes.get(i+1) ;

   String x = xNode.getXCondition();

   for(int j = 0; j<nWidth; j++) {

    if(signals.get(j).equals(x)){

     mSignals[i][j] =1;

    }else{

     mSignals[i][j] = 0;

    }

   }

  }

  if(nodes.get(i+1) instanceof YNode){

   YNode yNode = (YNode)nodes.get(i+1);

   ArrayList<String> ys =yNode.getConds();

   for(int j = 0; j<nWidth; j++) {

    mSignals[i][j] = 0;

    for(String y:ys){

     if(signals.get(j).equals(y)){

      mSignals[i][j] = 1;

      break;

     }

    }

   }

  }

 }

 

 return mSignals;

}

 

 public int[][] connectNodes(ArrayList<String> parsedAlg){

 

 int nOfArr = (parsedAlg.size() - nodes.size())/2;

 int[] fromArr = new int[nOfArr];

 int[] toArr = new int[nOfArr];

 //arrowConnection[] arrCon = new arrowConnection[numOfArr];

 fromArr =this.getAllFromArrow(parsedAlg, nOfArr);

 toArr = this.getAllToArrow(parsedAlg, fromArr);

 for(int i =0; i<nOfArr; i++){

  fromArr[i] =getFromNode(fromArr[i],parsedAlg);

  toArr[i] = getNodeTo(toArr[i],parsedAlg);

 }

 

 for(int i =0; i<nOfArr; i++){

  fromArr[i] =getIdFromZCode(fromArr[i]);

  toArr[i] = getIdFromZCode(toArr[i]);

 }

 

 int n = nodes.size()-1;

 int[][] matrixConnect = new int[n][n];

 for(int i = 0; i<n;i++){

  for(int j = 0; j<n;j++){

   matrixConnect[i][j] = 0;

  }

 }

 

 

 for(int i =0; i<nOfArr; i++){

  if(nodes.get(fromArr[i]) instanceof XNode){

   XNode xNode = (XNode)nodes.get(fromArr[i]);

   xNode.setSecondRef(nodes.get(toArr[i]));

   nodes.set(fromArr[i], xNode);

  }else{

   Node node =nodes.get(fromArr[i]);

   node.setRef(nodes.get(toArr[i]));

   nodes.set(fromArr[i], node);

  }

  matrixConnect[fromArr[i]][toArr[i]-1] = 1;;

 }

 

 for(int i =0; i<nodes.size()-1; i++){

  if(nodes.get(i).getRef()==null){

   nodes.get(i).setRef(nodes.get(i+1));

   matrixConnect[i][i] = 1;

  }

 }

 for(int i = 0; i<n;i++){

  for(int j = 0; j<n;j++){

   System.out.print(matrixConnect[i][j]+" ");

  }

  System.out.println();

 }

 return matrixConnect;

}

 

 public ArrayList<String> fromXYSetsToArray(){

 ArrayList<String> signals = new ArrayList<String>();  

 Iterator<String> it = xSignals.iterator();

 while(it.hasNext()){

  signals.add(it.next());

 }

 it =ySignals.iterator();

 while(it.hasNext()){

  signals.add(it.next());

 }

 return signals;

}

 

 

 private int[] getAllFromArrow(ArrayList<String> parsedAlg,int nOfArr ){

 int[] arrsFrom = new int[nOfArr];

 int currentAr = 0;

 for(int i = 0; i<parsedAlg.size();i++){

  if(currentAr>=parsedAlg.size()){

   System.out.println("Error to ou of bounds");

  }

  if(isArrUp(parsedAlg.get(i))){

   arrsFrom[currentAr] = i;

   currentAr++;

  }

 }

 return arrsFrom;

}

 

 

 

 private int[] getAllToArrow(ArrayList<String> parsedAlg,int[] arrsFrom ){

 int[] arrsTo = new int[arrsFrom.length];

 for(int i = 0; i<arrsTo.length;i++){

  String arrFrom = parsedAlg.get(arrsFrom[i]);

  for(int j = 0; j<parsedAlg.size();j++){

   if (isArrDown(parsedAlg.get(j))){

    String arrTo = parsedAlg.get(j);

    if(arrTo.charAt(1)==arrFrom.charAt(1)){

     arrsTo[i]= j;

     break;

    }

   }

  }

 }

 return arrsTo;

}

 

 private int getFromNode(int pArrFrom, ArrayList<String> parsedAlg){

 int pointer =pArrFrom--;

 

 while(pointer>=0){

  String s = parsedAlg.get(pointer);

  if(isExec(s)){

   return pointer;

  }

  pointer--;

 }

 return -1;

}

 

 private int getNodeTo(int pArrTo, ArrayList<String> parsedAlg){

 int pointer =pArrTo++;

 while(pointer<parsedAlg.size()){

  String s = parsedAlg.get(pointer);

  if(isExec(s)){

   return pointer;

  }

  pointer++;

 }

 return -1;

}

 

}

package nodes;

public abstract class Node {

 protected int id;

 protected Node ref;

 protected int zCode;

 

 /**Constructors*/

 public Node(){

}

 

 public Node(int id){

 this.id = id;

}

 

 public Node(int id, Node ref){

 this.id = id;

 this.ref = ref;

}

 

 /**Get and Set functions*/

 public int getId(){

 return id;

}

 

 public void setId(int a){

 id=a;

}

 

 

 public Node getRef(){

 return ref;

}

 

 public void setRef(Node ref){

 this.ref = ref;

}

 

 public int getZCode(){

 return zCode;

}

 

 public void setZCode(int a){

 zCode=a;

}

}

package nodes;

public class BeginNode extends Node{

 public BeginNode(){

 super();

}

 

 public BeginNode(int id){

 super(id);

}

 

 /*public String toString(){

 return id+" "+"Begin  "+zCode+"   "+ref.id;

}*/

}

package nodes;

public class EndNode extends Node{

 public EndNode(int id){

 super(id);

}

 

 /*public String toString(){

 return id+"  "+" End "+ +zCode;

}*/

}

package nodes;

public class XNode extends Node {

 private Node ref2;

 private String xCond;

 

 

 public XNode(){

 super();

}

 

 public XNode(int id){

 super(id);

}

 

 public XNode(int id, Node ref, String xCond){

 this.id = id;

 this.ref = ref;

 this.xCond = xCond;

}

 

 public XNode(int id, String xCond){

 this.id = id;

 this.xCond = xCond;

}

 public void setSecondRef(Node ref){

 ref2=ref;

}

 

 public Node getSecondRef(){

 return ref2;

}

 

 public void setCondition(String cond) {

 xCond = cond;

}

 

 public String getXCondition(){

 return xCond;

}

 

// @Override

// public String toString(){

//  return id+"  "+xCond+ "  "+ zCode+"   "+ref.id+"   "+ref2.id;

// }

 

}

package nodes;

import java.util.ArrayList;

public class YNode extends Node{

 // There can be list of outputSignals

 private ArrayList<String> yConds = new ArrayList<String>();

 

 

 public YNode(){

 super();

}

 

 public YNode(int id){

 super(id);

}

 

 public YNode(int id, Node ref, ArrayList<String> conds){

 this.id = id;

 this.ref = ref;

 this.yConds = conds;

}

 

 

 /** getters setters*/

 public void addYCond(String cond){

 yConds.add(cond);

}

 

 public ArrayList<String> getConds(){

 return yConds;

}

 

 public String getCond(int id){

 return yConds.get(id);

}

 

 public void setConds(ArrayList<String> a){

 yConds = a;

}

 

 /*public String toString(){

 return id+"  "+yConds.get(0)+" " + zCode+"   "+ref.id;

 }*/

}